def add_dock(self, title, widget, hidden=True):
"""Adds the move history dock to the main window."""
dock = QDockWidget(title, self)
dock.setWidget(widget)
if hidden:
dock.hide()
return dock
def _init_widgets(self):
window = QMainWindow()
window.setWindowFlags(Qt.Widget)
# pseudo code text box
self._textedit = QCCodeEdit(self)
self._textedit.setTextInteractionFlags(Qt.TextSelectableByKeyboard
| Qt.TextSelectableByMouse)
self._textedit.setLineWrapMode(QCCodeEdit.NoWrap)
textedit_dock = QDockWidget('Code', self._textedit)
window.setCentralWidget(textedit_dock)
textedit_dock.setWidget(self._textedit)
# decompilation
self._options = QDecompilationOptions(self,
self.workspace.instance,
options=None)
options_dock = QDockWidget('Decompilation Options', self._options)
window.addDockWidget(Qt.RightDockWidgetArea, options_dock)
options_dock.setWidget(self._options)
layout = QHBoxLayout()
layout.addWidget(window)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.workspace.plugins.instrument_code_view(self)
def new_console(tabto=None, floating=False, dockingarea=QtCore.Qt.RightDockWidgetArea):
"""
Create a new console and float it as a max widget
tabto: name of a widget on top of which the console should be tabbed
floating: True to float the console, False to leave it docked
dockingarea: The docking area for docking the window (default = right)
"""
main_window = GetQMaxMainWindow()
# create and setup a console
console = PythonConsole(formats=HUGOS_THEME)
console.setStyleSheet("background-color: #333333;")
# create a dock widget for the console
dock_widget = QDockWidget(main_window)
dock_widget.setWidget(console)
dock_widget.setObjectName("pyconsole")
dock_widget.setWindowTitle("Python Console")
main_window.addDockWidget(dockingarea, dock_widget)
if not tabto is None:
tabw = main_window.findChild(QWidget, tabto)
main_window.tabifyDockWidget(tabw, dock_widget)
dock_widget.setFloating(floating)
dock_widget.show()
# make the console do stuff
console.eval_queued()
return console
def init_tree_main_widget(self):
"""
Inicijalizuje layout main window-a, layout strane, tree, tabove, dugmadi i labele
"""
self.tabs = QTabWidget()
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.closeMyTab)
leftDock = QDockWidget()
leftDock.setFixedWidth(250)
leftDock.setWidget(self.tabs)
leftDock.setAllowedAreas(Qt.LeftDockWidgetArea)
leftDock.setFeatures(QDockWidget.NoDockWidgetFeatures)
layout = QGridLayout()
self.page = QVBoxLayout()
self.central = QWidget()
self.central.setFixedSize(730, 700)
self.central.setLayout(self.page)
self.central.setStyleSheet("background-color:white")
self.LeftButton = QPushButton()
self.PageLabel = QLabel()
self.PageLabel.setAlignment(Qt.AlignCenter)
self.PageLabel.setText("Nema trenutno otvorene strane")
self.RightButton = QPushButton()
self.LeftButton.setFixedSize(30, 30)
self.RightButton.setFixedSize(30, 30)
self.LeftButton.setIcon(QIcon("src/lbutton.png"))
self.RightButton.setIcon(QIcon("src/rbutton.png"))
layout.addWidget(self.central, 0, 0, 1, 5)
layout.addWidget(self.LeftButton, 1, 1, 2, 1)
layout.addWidget(self.PageLabel, 1, 2, 2, 1)
layout.addWidget(self.RightButton, 1, 3, 2, 1)
tmpWidget = QWidget()
tmpWidget.setLayout(layout)
self.setCentralWidget(tmpWidget)
self.addDockWidget(Qt.LeftDockWidgetArea, leftDock)
def _make_dock(name, widgets=[], tab_with=None):
dock = QDockWidget(name)
dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
dock_widget = QWidget()
layout = QVBoxLayout()
for widget in widgets:
layout.addWidget(widget)
dock_widget.setLayout(layout)
dock.setWidget(dock_widget)
key = f"hide {name.lower()} dock"
if key in prefs and prefs[key]:
dock.hide()
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
if tab_with is not None:
self.tabifyDockWidget(tab_with, dock)
return layout
def _init_widgets(self):
layout = QVBoxLayout()
w = QWidget()
w.setLayout(layout)
dock = QDockWidget("States")
dock.setWidget(w)
self.disasm_view.main_window.addDockWidget(Qt.RightDockWidgetArea,
dock)
self.layout = layout
self._init_states_viewer()
def change_combat(self, i):
remove_widget(current_type="country_changed")
self.delete_widget = country_model(self.test_widget,
file_name=self.file_name,
Number_Id=i)
Qrightwidget = QDockWidget()
Qrightwidget.setWidget(self.delete_widget)
mainwindow.addDockWidget(Qt.RightDockWidgetArea, Qrightwidget)
self.delete_mainwidget = Qrightwidget
remove_widget_list.append((self, "country_changed"))
def createDockWidget(self):
"""
Criar dock
"""
dock_wgt = QDockWidget()
dock_wgt.setWindowTitle("Dock Exemplo")
dock_wgt.setAllowedAreas(Qt.AllDockWidgetAreas)
dock_wgt.setWidget(QTextEdit())
self.addDockWidget(Qt.LeftDockWidgetArea, dock_wgt)
def __init__(self):
super(MainWindowV2, self).__init__()
# self.model - вместо трёх отдельных lists (arr_sheet, arr_Dash, arr_Tab)
# в QStandardItemModel будем append-ить
# один из трёх классов, наследующихся от QStandardItem
self.model = QStandardItemModel(self)
self.tabWidget = QTabWidget(self)
self.tabWidget.setTabPosition(QTabWidget.South)
self.tabWidget.setTabsClosable(True) # можно премещать вкладки
self.tabWidget.setMovable(
True) # но пока по нажатию ничего не происходит
self.tabWidget.tabCloseRequested.connect(self.closeTabFromTabWidget)
self.setCentralWidget(self.tabWidget)
# summerfield "Rapid GUI Programming" ch6
logDockWidget = QDockWidget("Tabs", self)
logDockWidget.setTitleBarWidget(QWidget())
# logDockWidget = QDockWidget(self)
logDockWidget.setObjectName("LogDockWidget")
logDockWidget.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
logDockWidget.setFeatures(QDockWidget.DockWidgetMovable)
# logDockWidget.setMinimumSize(100, 0)
self.navListView = QListView()
self.navListView.setModel(self.model)
logDockWidget.setWidget(self.navListView)
self.addDockWidget(Qt.LeftDockWidgetArea, logDockWidget)
self.createActions()
tabsToolbar = self.addToolBar("Tabs")
tabsToolbar.setObjectName("tabsToolBar")
tabsToolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
for action in [
self.newChartAction, self.newTableAction,
self.newDashboardAction, self.closeTabAction
]:
tabsToolbar.addAction(action)
self.navListView.selectionModel().selectionChanged.connect(
self.setActiveTab)
# easy start
self.newChart()
class Main(QMainWindow):
""" MainWindow which contains all widgets of POSM.
"""
def __init__(self, parent=None):
super(Main, self).__init__(parent)
self.setWindowTitle("POSM")
# All widgets should be destryed when the main window is closed. This the widgets can use the destroyed widget
# to allow clean up. E.g. save the database of the TileLoader.
self.setAttribute(QtCore.Qt.WA_DeleteOnClose, True)
self.resize(config.config.window_size[0], config.config.window_size[1])
self.elements_loader = ElementsLoader()
# Element Viewer as DockWidget
self.element_viewer = ElementViewer(self)
self.dock_element_viewer = QDockWidget()
self.dock_element_viewer.setWindowTitle("Element Viewer")
self.dock_element_viewer.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.dock_element_viewer.setWidget(self.element_viewer)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea,
self.dock_element_viewer)
# LayerManger as DockWidget
self.layer_manager = LayerManager(self)
self.dock_layer_manager = QDockWidget()
self.dock_layer_manager.setWindowTitle("Layer Manager")
self.dock_layer_manager.setFeatures(QDockWidget.DockWidgetFloatable
| QDockWidget.DockWidgetMovable)
self.dock_layer_manager.setWidget(self.layer_manager)
self.addDockWidget(QtCore.Qt.RightDockWidgetArea,
self.dock_layer_manager)
self.viewer = Viewer.Viewer(self)
self.setCentralWidget(self.viewer)
self.viewer.setFocus()
self.viewer.setFocusPolicy(QtCore.Qt.StrongFocus)
self.changeset = Changeset(self)
self.changset_form = ChangesetForm(self)
self.toolbar = QToolBar()
self.toolbar.addAction("Load Elements", self.viewer.load_elements)
self.toolbar.addAction("Undo Changes", self.viewer.undo_changes)
self.toolbar.addAction("Create Node",
partial(self.viewer.change_mode, "new_node"))
self.toolbar.addAction("Upload Changes", self.changset_form.show)
self.toolbar.addAction("Open Configuration",
partial(os.startfile, str(config.path_config)))
self.addToolBar(self.toolbar)
self.statusBar().showMessage("Welcome to POSM!")
class JobSearchAggregator:
def __init__(self, job_service):
self.app = QApplication(sys.argv)
self.job_service = job_service
self.list_view = ListView()
self.info_panel = JobInfoPanel()
self.dock = QDockWidget()
self.dock.setWidget(self.list_view)
self.dock.setFeatures(self.dock.NoDockWidgetFeatures)
self.dock.setTitleBarWidget(QWidget())
self.main_window = MainWindow()
self.main_window.setCentralWidget(self.info_panel)
self.main_window.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
self.list_view.selectionModel().currentChanged.connect(self.list_item_selected)
def run(self):
self.__populate_item_model()
self.list_view.select(0)
self.main_window.show()
sys.exit(self.app.exec_())
def __populate_item_model(self):
jobs = self.job_service.gather_all_jobs()
self.uids = [job.uid for job in jobs]
[self.list_view.append(job) for job in jobs]
def list_item_selected(self, index):
job_id = self.uids[index.row()]
job = self.job_service.consult_job(job_id)
self.info_panel.title.setText(job.title)
self.info_panel.description.setPlainText(job.description)
self.info_panel.about.setPlainText(job.about)
restrictions = '\n\n'.join(job.restrictions)
self.info_panel.restrictions.setPlainText(restrictions)
requirements = '\n\n'.join(job.requirements)
self.info_panel.requirements.setPlainText(requirements)
add_marker = 'try { add_marker(' + f'{job.location.lat}, {job.location.lng})' + '} catch(e) {}'
self.info_panel.webpage.runJavaScript(add_marker)
self.info_panel.set_contact_info(job.contact_info.contact,
job.contact_info.email,
job.contact_info.website,
job.company)
class LiverSupportWidget(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.segmented_images = LivSupp_SegmentedImagesWidget()
self.dockWidget = QDockWidget()
self.dockWidget.setTitleBarWidget(QWidget())
self.dockWidget.setWidget(self.segmented_images)
layout = QVBoxLayout(self)
layout.addWidget(self.dockWidget)
def createDockWindows(self):
# Info
dock = QDockWidget('Details', self)
dock.setObjectName("DETAILS")
dock.setAllowedAreas(Qt.AllDockWidgetAreas)
self.detailsWidget = InfoPanelWidget(self)
self.project_widget.treeCurrentItemChanged.connect(
self.detailsWidget.setItem)
self.project_widget.treeCurrentItemChanged.connect(
self.currentItemChanged)
dock.setWidget(self.detailsWidget)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
def createDockWindows(self):
dock = QDockWidget("Współrzędne Geograficzne Panelu: ", self)
s = ephem.Sun()
s.compute(epoch=ephem.now())
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.multiWidget3 = QWidget()
font5 = QFont("Arial", 12)
font6 = QFont("Arial", 17)
self.vLayout3 = QGridLayout()
self.result = QLabel(self.latlong)
self.latitude = QLabel('Szerokość')
self.longitude = QLabel('Długość')
self.dateandtime = QLabel('Data i Czas')
self.solarpanelcor = QLabel('WSPÓŁRZĘDNE PANELU SŁONECZNEGO: ')
self.latitudeEdit = QLineEdit()
self.latitudeEdit.setFixedHeight(28)
self.latitudeEdit.setFixedWidth(386)
self.latitudeEdit.setStatusTip(
"Wprowadzona szerokość powinna być w stopniach dziesiętnych (np.: 51.100000)"
)
self.longitudeEdit = QLineEdit()
self.longitudeEdit.setFixedHeight(28)
self.longitudeEdit.setFixedWidth(386)
self.longitudeEdit.setStatusTip(
"Wprowadzona długość powinna być w stopniach dziesiętnych (np.: 17.03333)"
)
self.dateandtimeEdit = QLineEdit()
self.dateandtimeEdit.setFixedHeight(28)
self.dateandtimeEdit.setFixedWidth(386)
self.dateandtimeEdit.setStatusTip(
"Wprowadzona data powinna być w formacie: rok/mies/dzień<spacja>godz:min:sek (np.: 2022/12/4 8:12:7)"
)
self.button = QPushButton('Wylicz współrzędne / Przerwij liczenie',
self)
self.button.clicked.connect(self.handleButton3)
self.latitude.setFont(font5)
self.longitude.setFont(font5)
self.dateandtime.setFont(font5)
self.button.setFont(font6)
self.button.setStatusTip("Rozpoczyna Obliczenia")
self.vLayout3.addWidget(self.latitude)
self.vLayout3.addWidget(self.latitudeEdit)
self.vLayout3.addWidget(self.longitude)
self.vLayout3.addWidget(self.longitudeEdit)
self.vLayout3.addWidget(self.dateandtime)
self.vLayout3.addWidget(self.dateandtimeEdit)
self.vLayout3.addWidget(self.button)
self.multiWidget3.setLayout(self.vLayout3)
dock.setWidget(self.multiWidget3)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
class MainWindow(QMainWindow):
def __init__(self,application,parent=None):
super(MainWindow,self).__init__(parent)
#private attributes
self.menuBar_ = QMenuBar()
self.fileMenu_ = FileMenu(self)
self.editMenu_ = EditMenu(self)
self.toolbarDoc_ = QDockWidget(self)
self.toolbarWidget_ = Toolbar(self)
self.setGeometry(0,0,1280,720)
#public attributes
self.application = application
self.contentTab = ContentTab()
self.statusBar = QStatusBar()
#menuBar
self.menuBar_.addMenu(self.fileMenu_)
self.menuBar_.addMenu(self.editMenu_)
self.menuBar_.addAction("Help",self.helpFunc)
self.setMenuBar(self.menuBar_)
#statusBar
self.statusBar.showMessage("status bar")
self.setStatusBar(self.statusBar)
#toolBar
self.toolbarDoc_.setFeatures(QDockWidget.NoDockWidgetFeatures )
self.addDockWidget(Qt.LeftDockWidgetArea,self.toolbarDoc_)
self.toolbarDoc_.setWidget(self.toolbarWidget_)
#contentab
self.setCentralWidget(self.contentTab)
def helpFunc(self):
"""
Call the help tab
To be added
"""
print("called helpFunc")
def quit(self):
"""
Quit the application
"""
self.application.quit()
def createFileList(self):
self.files = QListWidget()
self.files.setSelectionMode(QAbstractItemView.SingleSelection)
self.files.setSortingEnabled(False)
self.files.itemSelectionChanged.connect(self.onSelect)
self.files.itemDoubleClicked.connect(self.onToggle)
self.files.setEnabled(False)
dock = QDockWidget("Images", self)
dock.setAllowedAreas(Qt.LeftDockWidgetArea)
dock.setFixedWidth(320)
dock.setFeatures(QDockWidget.NoDockWidgetFeatures)
dock.setWidget(self.files)
self.addDockWidget(Qt.LeftDockWidgetArea, dock)
def make_dock_widget(parent,
name,
view,
area,
allowedAreas,
features=QDockWidget.DockWidgetClosable
| QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetFloatable):
dock = QDockWidget(name, parent)
dock.setObjectName(name)
dock.setAllowedAreas(allowedAreas)
dock.setFeatures(features)
dock.setWidget(view)
parent.addDockWidget(area, dock)
return dock
def gui_init(self):
pref_menu = menu_item(u'Preferences')
ref_menu = menu_item(u'Reference')
gen_menu = menu_item(u'Device')
gen_menu.addChildren(menu_item(u'GRBL', self.showGrblDialog))
file_menu = menu_item(self.qapp.tr(u'File'))
file_menu.addChildren(menu_item(u'New', self.newProject),
menu_item(u'Open', self.openProject),
menu_item(u'Import...', self.openFile),
menu_item(u'Save', self.saveProject),
menu_item(u'Exit', self.qapp.exit))
pref_menu.addChildren(gen_menu, menu_item(u'Settings'))
ref_menu.addChildren(menu_item(u'Help'),
menu_item(u'About', self.showAbout))
self.mainDialog.addMenuItems(file_menu, pref_menu, ref_menu)
self.cnc_indicator = work_indicator(u'CNC')
self.mainDialog.addStatusObj(self.cnc_indicator)
self.progressBar = QProgressBar()
self.progressBar.setTextVisible(True)
self.progressBar.setAlignment(Qt.AlignCenter)
self.progressBar.minimum = 1
self.progressBar.maximum = 100
self.mainDialog.addPermanentStatusObj(self.progressBar)
'''Инициализациия таблицы содержания'''
treeDock = QDockWidget(self.qapp.tr(u'Project tree'), self.mainDialog)
treeDock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.mainDialog.addDockWidget(Qt.LeftDockWidgetArea, treeDock)
self.mainnodes = [Node("Samples"), Node("Other")]
self.project_tree = ProjectTree(self, self.mainnodes)
self.project_tree.doubleClicked.connect(self.on_tree_clicked)
treeDock.setWidget(self.project_tree)
'''Инициализациия центра'''
jog = JogWidget(app=self.qapp,
axies=self.controls,
pinAcions=self.pinAcions,
motorActions=self.send_to_grbl)
self.mainDialog.addToCenter(jog)
jog.raise_()
def demo_docking_widgets():
"""
Demonstrates how to create a QWidget with PySide2 and attach it to the 3dsmax main window.
Creates two types of dockable widgets, a QDockWidget and a QToolbar
"""
# Retrieve 3ds Max Main Window QWdiget
main_window = GetQMaxMainWindow()
# QAction reused by both dockable widgets.
cylinder_icon_path = os.path.dirname(os.path.realpath(__file__)) + "\\cylinder_icon_48.png"
cylinder_icon = QtGui.QIcon(cylinder_icon_path)
create_cyl_action = QAction(cylinder_icon, u"Create Cylinder", main_window)
create_cyl_action.triggered.connect(create_cylinder)
# QDockWidget construction and placement over the main window
dock_widget = QDockWidget(main_window)
# Set for position persistence
dock_widget.setObjectName("Creators")
# Set to see dock widget name in toolbar customize popup
dock_widget.setWindowTitle("Creators")
dock_tool_button = QToolButton()
dock_tool_button.setAutoRaise(True)
dock_tool_button.setDefaultAction(create_cyl_action)
dock_tool_button.setToolButtonStyle(QtCore.Qt.ToolButtonTextOnly)
dock_widget.setWidget(dock_tool_button)
main_window.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dock_widget)
dock_widget.setFloating(True)
dock_widget.show()
# QToolBar construction and attachement to main window
toolbar_widget = QToolBar(main_window)
# Set for position persistence
toolbar_widget.setObjectName("Creators TB")
# Set to see dock widget name in toolbar customize popup
toolbar_widget.setWindowTitle("Creators TB")
toolbar_widget.setFloatable(True)
toolbar_widget.addAction(create_cyl_action)
main_window.addToolBar(QtCore.Qt.BottomToolBarArea, toolbar_widget)
toolbar_widget.show()
toolbar_position = get_pos_to_dock_toolbar(dock_widget)
make_toolbar_floating(toolbar_widget, toolbar_position)
def create_dock_widget(self):
"""
Sets up a dock widget for Markdown hot previewing, hidden by default.
:return: None
"""
dock = QDockWidget("Markdown Viewer", self)
dock.setWidget(self.md_text_edit)
dock.visibilityChanged.connect(
lambda visible: visible and self.update_markdown_viewer(
)) # precludes slowdowns
self.addDockWidget(Qt.BottomDockWidgetArea, dock)
dock_act = dock.toggleViewAction()
dock_act.setShortcuts([
QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_M),
QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_C)
])
self.view_menu.addSeparator() # Does nothing on Mac
self.view_menu.addAction(dock_act)
dock.close()
def _on_select():
global edd
it = ed.scene().selectedItems()
if len(it) > 0:
it = it[0]
else:
it = None
if isinstance(it, Element):
edd = QDockWidget()
edd.setWidget(it.editor())
edd.setWindowTitle('Element properties')
edd.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetFloatable)
w.addDockWidget(Qt.LeftDockWidgetArea, edd)
elif edd is not None:
w.removeDockWidget(edd)
edd = None
class Window(QMainWindow):
def __init__(self):
super(Window, self).__init__()
interactiveMap = InteractiveMap(self)
self.setCentralWidget(interactiveMap)
self.countryInfo = QDockWidget("Country Information", self)
self.countryInfo.setFeatures(QDockWidget.DockWidgetClosable)
self.countryInfo.setFixedWidth(300)
self.countryInfo.hide()
self.addDockWidget(Qt.RightDockWidgetArea, self.countryInfo)
self.setWindowTitle("Project Fiscal")
def showCountryDock(self, country):
if self.countryInfo.isHidden():
self.countryInfo.show()
self.countryInfo.setWidget(country)
def __create_dock_and_menu(self, name, view):
# TODO: Check if name exists in docks
if name in self.docks:
dock_widget = self.docks[name]
self.window.removeDockWidget(dock_widget)
else:
dock_widget = QDockWidget(name)
new_action = QAction(name, self)
new_action.setStatusTip("Create a new file")
new_action.setCheckable(True)
new_action.setChecked(True)
new_action.triggered.connect(
lambda state: self.switch_view(state, self.widgets[name]))
self.view_menu.addAction(new_action)
self.docks[name] = dock_widget
self.widgets[name].dock = dock_widget
dock_widget.setWidget(view)
dock_widget.setAllowedAreas(Qt.AllDockWidgetAreas)
self.window.addDockWidget(Qt.RightDockWidgetArea, dock_widget)
dock_widget.raise_()
def createDockWindows(self):
dock = QDockWidget("Customers", self)
dock.setAllowedAreas(Qt.LeftDockWidgetArea | Qt.RightDockWidgetArea)
self.customerList = QListWidget(dock)
self.customerList.addItems(
("John Doe, Harmony Enterprises, 12 Lakeside, Ambleton",
"Jane Doe, Memorabilia, 23 Watersedge, Beaton",
"Tammy Shea, Tiblanka, 38 Sea Views, Carlton",
"Tim Sheen, Caraba Gifts, 48 Ocean Way, Deal",
"Sol Harvey, Chicos Coffee, 53 New Springs, Eccleston",
"Sally Hobart, Tiroli Tea, 67 Long River, Fedula"))
dock.setWidget(self.customerList)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
dock = QDockWidget("Paragraphs", self)
self.paragraphsList = QListWidget(dock)
self.paragraphsList.addItems(
("Thank you for your payment which we have received today.",
"Your order has been dispatched and should be with you within "
"28 days.",
"We have dispatched those items that were in stock. The rest of "
"your order will be dispatched once all the remaining items "
"have arrived at our warehouse. No additional shipping "
"charges will be made.",
"You made a small overpayment (less than $5) which we will keep "
"on account for you, or return at your request.",
"You made a small underpayment (less than $1), but we have sent "
"your order anyway. We'll add this underpayment to your next "
"bill.",
"Unfortunately you did not send enough money. Please remit an "
"additional $. Your order will be dispatched as soon as the "
"complete amount has been received.",
"You made an overpayment (more than $5). Do you wish to buy more "
"items, or should we return the excess to you?"))
dock.setWidget(self.paragraphsList)
self.addDockWidget(Qt.RightDockWidgetArea, dock)
self.viewMenu.addAction(dock.toggleViewAction())
self.customerList.currentTextChanged.connect(self.insertCustomer)
self.paragraphsList.currentTextChanged.connect(self.addParagraph)
def _init_widgets(self):
main = QMainWindow()
main.setWindowFlags(Qt.Widget)
# main.setCorner(Qt.TopLeftCorner, Qt.TopDockWidgetArea)
# main.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
pathtree = QPathTree(self.current_simgr, self.current_state, self, self.workspace, parent=main)
pathtree_dock = QDockWidget('PathTree', pathtree)
main.setCentralWidget(pathtree_dock)
# main.addDockWidget(Qt.BottomDockWidgetArea, pathtree_dock)
pathtree_dock.setWidget(pathtree)
simgrs = QSimulationManagers(self.workspace.instance, self.current_simgr, self.current_state, parent=main)
simgrs_dock = QDockWidget('SimulationManagers', simgrs)
main.addDockWidget(Qt.RightDockWidgetArea, simgrs_dock)
simgrs_dock.setWidget(simgrs)
state_viewer = StateInspector(self.workspace, self.current_state, parent=self)
state_viewer_dock = QDockWidget('Selected State', state_viewer)
main.addDockWidget(Qt.RightDockWidgetArea, state_viewer_dock)
state_viewer_dock.setWidget(state_viewer)
self._pathtree = pathtree
self._simgrs = simgrs
self._state_viewer = state_viewer
main_layout = QHBoxLayout()
main_layout.addWidget(main)
main_layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(main_layout)
it.setText(0, elem_name)
category_item.addChild(it)
self.addTopLevelItem(category_item)
if __name__ == "__main__":
app = QApplication()
w = QMainWindow()
w.setMinimumSize(640, 480)
elems = ElementTree()
elems.create_from_dict(ELEMENTS)
elems.expandAll()
dw = QDockWidget()
dw.setWidget(elems)
dw.setWindowTitle('Elements')
dw.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetFloatable)
w.addDockWidget(Qt.LeftDockWidgetArea, dw)
sim = Simulator()
schem = Schematic()
sim.root = schem.root
g = Gate('or', 1, 2, False)
g.name = 'gate'
el = GateElement(sim, g)
schem.add_element(el)
ed = SchematicEditor(schem)
t = QTimer(w)
class MainWindow(QMainWindow):
changePage = Signal(bool)
def __init__(self):
super().__init__()
self.setWindowTitle('Petro-Explorer v1.0')
win_icon = QIcon('icons/Logo.ico')
self.setWindowIcon(win_icon)
self.setStyleSheet('background-color: #363f49;')
self.header = Header()
self.navigation = Navigation()
self.p_top_bar = PetrophysicsTopBar()
self.s_top_bar = StatisticsTopBar()
self.p_options_1 = PetrophysicsOptions(_mode='KCarman')
self.p_options_2 = PetrophysicsOptions(_mode='TCoates')
self.p_options_3 = PetrophysicsOptions(_mode='Winland')
self.p_options_4 = PetrophysicsOptions(_mode='RQIFZI')
self.p_options_5 = PetrophysicsOptions(_mode='Lucia')
self.p_options_6 = PetrophysicsOptions(_mode='DParsons')
self.s_options_1 = StatisticsOptions(_mode='Regression')
self.s_options_2 = StatisticsOptions(_mode='Statistics')
self.s_options_3 = StatisticsOptions(_mode='Histogram')
self.s_options_4 = StatisticsOptions(_mode='Boxplot')
self.sp_controls = SpreadsheetControls()
self.plot_controls = PlotControls()
self.plot_viewer = PlotViewer()
self.spreadsheet = Spreadsheet()
self.status_bar = QStatusBar()
self.scroll_area_1 = QScrollArea()
self.scroll_area_1.setWidget(self.spreadsheet)
self.scroll_area_1.setWidgetResizable(True)
self.scroll_area_2 = QScrollArea()
self.scroll_area_2.setWidget(self.plot_viewer)
self.scroll_area_2.setWidgetResizable(True)
self.bar_widget = QWidget()
self.bar_widget.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Maximum)
self.central_widget = QWidget()
self.options_widget = QWidget()
self.docking_options = QDockWidget()
self.docking_options.setWidget(self.options_widget)
self.docking_options.setTitleBarWidget(
DockWidgetRibbon(' Opções de cálculo'))
self.docking_options2 = QDockWidget()
self.docking_options2.setWidget(self.sp_controls)
self.docking_options2.setTitleBarWidget(
DockWidgetRibbon(' Controles de visualização'))
self.setCentralWidget(self.central_widget)
self.setStatusBar(self.status_bar)
self.addToolBar(self.navigation)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea,
self.docking_options)
self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea,
self.docking_options2)
self.connections()
self.buildLayout()
self.centralWidget().setStyleSheet('background-color: #2e3843')
self.spreadsheet.setStyleSheet('background-color: white')
self.status_bar.setStyleSheet('color: white')
def buildLayout(self):
stacked_layout_1 = QStackedLayout()
# stacked_layout_1.addWidget(QWidget())
stacked_layout_1.addWidget(self.p_top_bar)
stacked_layout_1.addWidget(self.s_top_bar)
stacked_layout_2 = QStackedLayout()
# stacked_layout_2.addWidget(QWidget())
stacked_layout_2.addWidget(self.p_options_1)
stacked_layout_2.addWidget(self.p_options_2)
stacked_layout_2.addWidget(self.p_options_3)
stacked_layout_2.addWidget(self.p_options_4)
stacked_layout_2.addWidget(self.p_options_5)
stacked_layout_2.addWidget(self.p_options_6)
stacked_layout_2.addWidget(self.s_options_1)
stacked_layout_2.addWidget(self.s_options_2)
stacked_layout_2.addWidget(self.s_options_3)
stacked_layout_2.addWidget(self.s_options_4)
self.stacked_layout_3 = QStackedLayout()
self.stacked_layout_3.addWidget(self.scroll_area_1)
self.stacked_layout_3.addWidget(self.scroll_area_2)
central_widget_layout = QVBoxLayout()
central_widget_layout.addWidget(self.bar_widget)
central_widget_layout.addLayout(self.stacked_layout_3)
self.central_widget.setLayout(central_widget_layout)
self.bar_widget.setLayout(stacked_layout_1)
self.options_widget.setLayout(stacked_layout_2)
def connections(self):
self.navigation.PetroAnalysis.connect(
lambda: self.bar_widget.layout().setCurrentIndex(0))
self.navigation.StatsAnalysis.connect(
lambda: self.bar_widget.layout().setCurrentIndex(1))
self.navigation.Save.connect(lambda: self.saveDialog())
self.navigation.Import.connect(lambda: self.importDialog())
self.navigation.About.connect(lambda: self.aboutDialog())
self.navigation.Help.connect(lambda: self.helpDialog())
self.navigation.header.HomePage.connect(
lambda: self.changePage.emit(True))
self.navigation.ViewSheet.connect(lambda: self.displaySheet())
self.navigation.ViewPlot.connect(lambda: self.displayPltE())
self.navigation.New.connect(lambda: self.spreadsheet.addBlankSheet())
self.p_top_bar.KCarman.connect(
lambda: self.options_widget.layout().setCurrentIndex(0))
self.p_top_bar.TCoates.connect(
lambda: self.options_widget.layout().setCurrentIndex(1))
self.p_top_bar.Winland.connect(
lambda: self.options_widget.layout().setCurrentIndex(2))
self.p_top_bar.DParsons.connect(
lambda: self.options_widget.layout().setCurrentIndex(5))
self.p_top_bar.Lucia.connect(
lambda: self.options_widget.layout().setCurrentIndex(4))
self.p_top_bar.RF.connect(
lambda: self.options_widget.layout().setCurrentIndex(3))
self.s_top_bar.Regr.connect(
lambda: self.options_widget.layout().setCurrentIndex(6))
self.s_top_bar.StatDesc.connect(
lambda: self.options_widget.layout().setCurrentIndex(7))
self.s_top_bar.Boxplt.connect(
lambda: self.options_widget.layout().setCurrentIndex(9))
self.s_top_bar.Hist.connect(
lambda: self.options_widget.layout().setCurrentIndex(8))
self.s_options_1.run_button.clicked.connect(self.startRegr)
self.s_options_2.run_button.clicked.connect(self.startStat)
self.s_options_3.run_button.clicked.connect(self.startHist)
self.s_options_4.run_button.clicked.connect(self.startBxpl)
self.p_options_1.run.clicked.connect(self.startKCoz)
self.p_options_2.run.clicked.connect(self.startTCoa)
self.p_options_3.run.clicked.connect(self.startWinl)
self.p_options_4.run.clicked.connect(self.startFZIR)
self.p_options_5.run.clicked.connect(self.startLuci)
self.p_options_6.run.clicked.connect(self.startDyks)
self.sp_controls.AddColumn.connect(
lambda: self.spreadsheet.addColumn())
self.sp_controls.AddRow.connect(lambda: self.spreadsheet.addRow())
self.sp_controls.DeleteRow.connect(
lambda: self.spreadsheet.deleteRow())
self.sp_controls.DeleteColumn.connect(
lambda: self.spreadsheet.deleteColumn())
self.plot_controls.run_button.clicked.connect(lambda: self.startPltE())
self.plot_controls.erasePlot.connect(
lambda: self.plot_viewer.erasePlot())
self.plot_viewer.feedPlotControls.connect(
self.plot_controls.fillFromJson)
def startPltE(self):
old_json = self.plot_viewer.json_data
title = self.plot_controls.modify_title.text()
xtype = self.plot_controls.modify_x_axis_type.currentText()
ytype = self.plot_controls.modify_y_axis_type.currentText()
xlabel = self.plot_controls.modify_x_axis_label.text()
ylabel = self.plot_controls.modify_y_axis_label.text()
if len(self.plot_controls.modify_lower_x_range.text()) > 0:
lxrange = float(self.plot_controls.modify_lower_x_range.text())
else:
lxrange = None
if len(self.plot_controls.modify_upper_x_range.text()) > 0:
uxrange = float(self.plot_controls.modify_upper_x_range.text())
else:
uxrange = None
if len(self.plot_controls.modify_lower_y_range.text()) > 0:
lyrange = float(self.plot_controls.modify_lower_y_range.text())
else:
lyrange = None
if len(self.plot_controls.modify_upper_y_range.text()) > 0:
uyrange = float(self.plot_controls.modify_upper_y_range.text())
else:
uyrange = None
if len(self.plot_controls.add_x_trace.text()) > 0 and len(
self.plot_controls.add_y_trace.text()):
trace_type = self.plot_controls.type_of_trace.currentText()
x_trace = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.plot_controls.
add_x_trace.text(
))]
y_trace = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.plot_controls.
add_y_trace.text(
))]
trace_name = self.plot_controls.trace_name.text()
else:
trace_type = None
x_trace = None
y_trace = None
trace_name = None
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.loadPltE(io_operations_handler.results))
io_operations_handler.loadParameters(f=pceManifold,
_args=[
old_json, title, xtype, ytype,
xlabel, ylabel, lxrange,
uxrange, lyrange, uyrange,
trace_type, x_trace, y_trace,
trace_name
])
io_operations_handler.start()
def loadPltE(self, results, typ='Regressão'):
self.plot_viewer.loadPlot(results[0], results[1], _type=typ)
self.displayPltE()
def displayPltE(self):
self.stacked_layout_3.setCurrentIndex(1)
self.docking_options2.setWidget(self.plot_controls)
#self.removeDockWidget(self.docking_options3)
#self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options2)
def loadSheet(self, df):
self.spreadsheet.changeModel(data=df, header=list(df.keys()))
self.displaySheet()
def displaySheet(self):
self.stacked_layout_3.setCurrentIndex(0)
self.docking_options2.setWidget(self.sp_controls)
self.status_bar.clearMessage()
#self.removeDockWidget(self.docking_options2)
#self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, self.docking_options3)
def importDialog(self):
func = None
file_settings = QFileDialog().getOpenFileName(
self,
'Importar Arquivo',
filter=
"Todos os arquivos (*);; Arquivo de Texto (*.txt);; Arquivo CSV (*.csv);; "
"Planilha Excel (*.xlsx)")
if ".txt" in file_settings[0]:
func = Data.readTXT
if ".csv" in file_settings[0]:
func = Data.readCSV
if ".xlsx" in file_settings[0]:
func = Data.readExcel
self.status_bar.showMessage('Importando arquivo. Aguarde.')
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.loadSheet(io_operations_handler.results))
io_operations_handler.loadParameters(f=func,
_args=[
file_settings[0],
])
io_operations_handler.start()
def saveDialog(self):
func = None
file_settings = QFileDialog().getSaveFileName(
self,
"Salvar Arquivo",
filter="Arquivo de Texto (*.txt);; Arquivo CSV (*.csv);; "
"Planilha Excel (*.xlsx)")
if ".txt" in file_settings[0]:
func = Data.toTXT
if ".csv" in file_settings[0]:
func = Data.toCSV
if ".xlsx" in file_settings[0]:
func = Data.toExcel
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.loadParameters(
f=func, _args=[self.spreadsheet.retrieveModel(), file_settings[0]])
io_operations_handler.start()
def aboutDialog(self):
icon = QIcon(r'icons/sobre.png')
text = "O Petro-Explorer é um software desenvolvido no Laboratório de Exploração e Produção de Petróleo (" \
"LENEP) da UENF para análises petrofísicas e estatísticas de dados de rocha. "
msg = QMessageBox()
msg.setWindowTitle('Sobre Petro-Explorer')
msg.setWindowIcon(icon)
msg.setText(text)
msg.exec_()
def helpDialog(self):
icon = QIcon(r'icons/ajuda.png')
text = r"Para utilizar o Petro-Explorer de maneira correta siga os seguintes passos:" \
"\n1 - Clique no botão Novo na barra de navegação, isto irá limpar quaisquer dados de antigas análises.\n" \
"2 - Para começar a sua análise é preciso importar os dados, assim, clique no botão Importar para escolher o seu arquivo. Atente para o fato que somente três tipos de arquivo são suportados (i.e. *.txt, *.csv, *.xlsx). Depois da sua escolha, os dados devem aparecer na planilha do software.\n" \
"3 - Se você desejar realizar uma análise petrofísica, clique no botão de Análise Petrofísica na barra de navegação. Caso queira realizar uma análise estatística, clique no botão de Análise Estatística na barra de navegação.\n" \
"4 - Selecione na barra superior à planilha, a análise que desejas realizar sobre seus dados.\n" \
"5 - No canto direito da janela, selecione os parâmetros de sua análise assim como o destino de seus resultados. Clique no botão 'Começar Análise' para continuar.\n" \
"6 - Analise seus resultados na planilha, e, quando disponível, no gráfico também.\n" \
"7 - Quando terminar, clique no botão Salvar para salvar os resultados de suas análises no disco.\n" \
"8 - Caso queira realizar outra análise, clique no botão \"Novo\" e comece novamente.\n"
msg = QMessageBox()
msg.setWindowTitle('Ajuda')
msg.setWindowIcon(icon)
msg.setText(text)
msg.exec_()
def startRegr(self):
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.s_options_1.
payload['x_column'])]
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.s_options_1.
payload['y_column'])]
_type = self.s_options_1.payload['calculate']
dgr = self.s_options_1.degree.value()
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayRegr(self.s_options_1.payload['output_column'],
io_operations_handler.results))
io_operations_handler.loadParameters(f=regressionManifold,
_args=[xdata, ydata, dgr, _type])
io_operations_handler.start()
def startStat(self):
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.s_options_2.
payload['x_column'])]
mthd = self.s_options_2.payload['calculate']
qtl = self.s_options_2.quartile.value()
pctl = self.s_options_2.percentile.value()
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayStat(self.s_options_2.payload['output_column'],
io_operations_handler.results))
io_operations_handler.loadParameters(f=statisticsManifold,
_args=[xdata, mthd, qtl, pctl])
io_operations_handler.start()
def startHist(self):
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.s_options_3.
payload['x_column'])]
nbins = self.s_options_3.payload['y_column']
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayHist(io_operations_handler.results))
io_operations_handler.loadParameters(f=histogramManifold,
_args=[xdata, nbins])
io_operations_handler.start()
def startBxpl(self):
indexes = []
columns = self.s_options_4.payload['column_range']
for col in columns:
indexes.append(self.spreadsheet.model.header_info.index(col))
xdata = self.spreadsheet.model.input_data[:, indexes]
box_orientation = self.s_options_4.payload['y_column']
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayBxpl(io_operations_handler.results))
io_operations_handler.loadParameters(f=boxplotManifold,
_args=[xdata, box_orientation])
io_operations_handler.start()
def startKCoz(self):
#you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
k = None
phi = None
svgr = None
prp = self.p_options_1.payload['calculate']
if prp == 'Permeabilidade (mD)':
phi = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.p_options_1.
payload['x_column'])]
svgr = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_1.
payload['y_column'])]
elif prp == 'SVgr (cm-1)':
k = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.p_options_1.
payload['x_column'])]
phi = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.p_options_1.
payload['y_column'])]
else:
k = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.p_options_1.
payload['x_column'])]
phi = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.
index(self.p_options_1.
payload['y_column'])]
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayKCoz(io_operations_handler.results))
io_operations_handler.loadParameters(f=kCarmanManifold,
_args=[k, phi, svgr, prp])
io_operations_handler.start()
def startTCoa(self):
#you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
prp = self.p_options_2.payload['calculate']
if prp == "Swir (%)":
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_2.
payload['x_column'])]
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_2.
payload['y_column'])]
zdata = None
else:
xdata = None
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_2.
payload['y_column'])]
zdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_2.
payload['x_column'])]
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayTCoa(io_operations_handler.results))
io_operations_handler.loadParameters(f=tCoatesManifold,
_args=[xdata, ydata, zdata, prp])
io_operations_handler.start()
def startWinl(self):
#you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
if self.p_options_3.payload['x_column'] != '':
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_3.
payload['x_column'])]
else:
xdata = []
if self.p_options_3.payload['y_column'] != '':
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_3.
payload['y_column'])]
else:
ydata = []
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayWinl(io_operations_handler.results))
io_operations_handler.loadParameters(f=winlandManifold,
_args=[xdata, ydata])
io_operations_handler.start()
def startFZIR(self):
# you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
if self.p_options_4.payload['x_column'] != '':
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_4.
payload['x_column'])]
else:
xdata = None
if self.p_options_4.payload['y_column'] != '':
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_4.
payload['y_column'])]
else:
ydata = None
if self.p_options_4.payload['z_column'] != '':
zdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_4.
payload['z_column'])]
else:
zdata = None
prp = self.p_options_4.payload['calculate']
un = self.p_options_4.payload['column_range']
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayFZIR(io_operations_handler.results))
io_operations_handler.loadParameters(
f=fzManifold, _args=[xdata, ydata, zdata, un, prp])
io_operations_handler.start()
def startLuci(self):
#you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
if self.p_options_5.payload['x_column'] != '':
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_5.
payload['x_column'])]
else:
xdata = []
if self.p_options_5.payload['y_column'] != '':
ydata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_5.
payload['y_column'])]
else:
ydata = []
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayLuci(io_operations_handler.results))
io_operations_handler.loadParameters(f=luciaManifold,
_args=[xdata, ydata])
io_operations_handler.start()
def startDyks(self):
#you need to ascertain if x corresponds to Permeability, y to Porosity and z to Swir/Svgr
if self.p_options_6.payload['x_column'] != '':
xdata = self.spreadsheet.model.input_data[:,
self.spreadsheet.model.
header_info.index(
self.p_options_6.
payload['x_column'])]
else:
xdata = []
prp = self.p_options_6.payload['calculate']
io_operations_handler = HandlerThread()
io_operations_handler.messageSent.connect(self.status_bar.showMessage)
io_operations_handler.daemon = True
io_operations_handler.hasFinished.connect(
lambda: self.displayDyks(io_operations_handler.results))
io_operations_handler.loadParameters(f=dParsonsManifold,
_args=[xdata, prp])
io_operations_handler.start()
def displayKCoz(self, content):
content = list(content)
content.insert(0, 'Resultados - Kozeny-Carman')
self.spreadsheet.addColumn(content)
def displayWinl(self, content):
self.loadPltE(content[:2])
content[2].insert(0, 'R35 - Winland')
content[3].insert(0, 'Ports - Winland')
self.spreadsheet.addColumn(content[2])
self.spreadsheet.addColumn(content[3])
def displayTCoa(self, content):
content.insert(0, 'Resultados - Timur Coates')
self.spreadsheet.addColumn(content)
def displayDyks(self, content):
content.insert(0, 'Resultados - Dykstra-Parsons')
self.spreadsheet.addColumn(content)
self.p_options_6.results.setText(
'Atenção! Resultado pode ser diferente do coeficiente calculado através do gráfico de probabilidade. \n'
+ str(content[0]) + ': ' + str(content[1]))
def displayLuci(self, results):
self.loadPltE(results[:2])
results[2].insert(0, 'Resultados - RFN/Lucia')
self.spreadsheet.addColumn(results[2])
def displayFZIR(self, results):
results[0].insert(0, 'Resultados - RQI (μm)')
self.spreadsheet.addColumn(results[0])
results[1].insert(0, 'Resultados - PhiZ')
self.spreadsheet.addColumn(results[1])
self.loadPltE(results[2:])
def displayRegr(self, display_name, results):
self.s_options_1.results.setText(str(results[0]))
self.loadPltE(results[-2:])
def displayStat(self, display_name, results):
self.s_options_2.results.setText(str(results))
def displayHist(self, results):
self.loadPltE(results, 'Histograma')
def displayBxpl(self, results):
self.loadPltE(results, 'Boxplot')
def __init__(self, app):
super(MainWindow, self).__init__()
self._app = app
self._selectedIndex = None
# model
nodeFactory = NodeFactory()
rootNode = nodeFactory.create(NodeType.General, 'Root')
# for i in range(10000): # for testing
childNode0 = nodeFactory.create(NodeType.General, 'RightPirateLeg',
rootNode)
childNode1 = nodeFactory.create(NodeType.General, 'RightPirateLeg_END',
childNode0)
childNode2 = nodeFactory.create(NodeType.General, 'LeftFemur',
rootNode)
childNode3 = nodeFactory.create(NodeType.Sphere, 'LeftTibia',
childNode2)
childNode4 = nodeFactory.create(NodeType.Sphere, 'LeftFoot',
childNode3)
transform = childNode4.component(ComponentType.Transform)
qTransform = transform.component()
translation = qTransform.translation()
translation.setX(5)
qTransform.setTranslation(translation)
# childNode5 = nodeFactory.create(NodeType.Box, 'LeftFoot_END', childNode4)
self._model = SceneGraphModel(rootNode)
self._sceneView = SceneView(rootNode.entity())
self._container = self.createWindowContainer(self._sceneView)
# scene graph view
self._treeView = QTreeView()
self._treeView.setModel(self._model)
self._treeView.setHeaderHidden(True)
self._treeView.setAlternatingRowColors(True)
dockWidget = QDockWidget()
dockWidget.setWidget(self._treeView)
dockWidget.setWindowTitle('Scene Graph')
dockWidget.setObjectName('sceneGraph')
sceneGraphToggleAction = dockWidget.toggleViewAction()
self.addDockWidget(Qt.LeftDockWidgetArea, dockWidget)
# property editor
propertyEditor = PropertyEditor(self._model, nodeFactory,
FieldFactory())
dockWidget = QDockWidget()
dockWidget.setWidget(propertyEditor)
dockWidget.setWindowTitle('Property Editor')
dockWidget.setObjectName('propertyEditor')
propertyEditorToggleAction = dockWidget.toggleViewAction()
self.addDockWidget(Qt.RightDockWidgetArea, dockWidget)
# menu
menuBar = self.menuBar()
menu = menuBar.addMenu('&File')
exitAction = menu.addAction('E&xit')
exitAction.triggered.connect(self.close)
menu.addAction(exitAction)
menu = menuBar.addMenu('&Windows')
menu.addAction(sceneGraphToggleAction)
menu.addAction(propertyEditorToggleAction)
menuBar.addMenu(menu)
# central widget
#button = QPushButton()
self.setCentralWidget(self._container)
# selection change event
selectionModel = self._treeView.selectionModel()
selectionModel.currentChanged.connect(propertyEditor.changeSelection)
class SchemeEditor(QMainWindow):
"""Scheme editor is the widget responsible for the scheme editing experience.
As its main components, SchemeEditor contains the following widgets:
- scheme - the canvas for dragging and connecting nodes to form signals;
- toolbox - a list of draggable nodes to be put on the scheme;
- (optionally) config widget - a widget for manipulating properties of nodes.
"""
def __init__(self, parent=None):
super().__init__(parent)
self._scheme = None
self._scheme_view = Scheme.View()
self._toolbox = None
self.setCentralWidget(self._scheme_view)
self.toolbox_dock = QDockWidget("Node Toolbox", self)
self.toolbox_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.toolbox_dock.setFeatures(QDockWidget.DockWidgetMovable
| QDockWidget.DockWidgetFloatable)
self.addDockWidget(Qt.LeftDockWidgetArea, self.toolbox_dock)
self.setToolbox(Toolbox(self))
self.config_widget_dock = QDockWidget("Configuration", self)
self.config_widget_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.addDockWidget(Qt.RightDockWidgetArea, self.config_widget_dock)
self.config_widget_dock.hide()
def scheme(self):
return self._scheme
def toolbox(self):
return self._toolbox
def schemeView(self):
return self._scheme_view
def toolboxView(self):
return self.toolbox_dock.widget()
def setScheme(self, scheme: Scheme):
if self._scheme is not None:
self._scheme_view.configRequested.disconnect(self.showConfigWidget)
self._scheme.setCustomDropEvent(self.toolbox().DragMimeType, None)
self._scheme = scheme
if self._scheme is not None:
self._scheme_view.setScene(self._scheme)
# Conect the signal for config widget
self._scheme_view.configRequested.connect(self.showConfigWidget)
# Add a custom drop event for the scheme from the toolbox
self._scheme.setCustomDropEvent(self.toolbox().DragMimeType,
self.toolbox().schemeDropEvent)
def setToolbox(self, toolbox):
self._toolbox = toolbox
self.toolbox_dock.setWidget(self._toolbox.getView())
def showConfigWidget(self, node):
"""Show config widget for a node.
This function is automatically connected as a slot to the scheme view's configRequested signal.
"""
self.config_widget_dock.setWidget(node.configWidget())
self.config_widget_dock.show()
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
QApplication.setApplicationName('Sherloq')
QApplication.setOrganizationName('Guido Bartoli')
QApplication.setOrganizationDomain('www.guidobartoli.com')
QApplication.setApplicationVersion(ToolTree().version)
QApplication.setWindowIcon(QIcon('icons/sherloq_white.png'))
self.setWindowTitle('{} {}'.format(QApplication.applicationName(),
QApplication.applicationVersion()))
self.mdi_area = QMdiArea()
self.setCentralWidget(self.mdi_area)
self.filename = None
self.image = None
modify_font(self.statusBar(), bold=True)
tree_dock = QDockWidget(self.tr('TOOLS'), self)
tree_dock.setObjectName('tree_dock')
tree_dock.setAllowedAreas(Qt.LeftDockWidgetArea
| Qt.RightDockWidgetArea)
self.addDockWidget(Qt.LeftDockWidgetArea, tree_dock)
self.tree_widget = ToolTree()
self.tree_widget.setObjectName('tree_widget')
self.tree_widget.itemDoubleClicked.connect(self.open_tool)
tree_dock.setWidget(self.tree_widget)
tools_action = tree_dock.toggleViewAction()
tools_action.setText(self.tr('Show tools'))
tools_action.setToolTip(self.tr('Toggle toolset visibility'))
tools_action.setShortcut(QKeySequence(Qt.Key_Tab))
tools_action.setObjectName('tools_action')
tools_action.setIcon(QIcon('icons/tools.svg'))
help_action = QAction(self.tr('Show help'), self)
help_action.setToolTip(self.tr('Toggle online help'))
help_action.setShortcut(QKeySequence.HelpContents)
help_action.setObjectName('help_action')
help_action.setIcon(QIcon('icons/help.svg'))
help_action.setCheckable(True)
help_action.setEnabled(False)
load_action = QAction(self.tr('&Load image...'), self)
load_action.setToolTip(self.tr('Load an image to analyze'))
load_action.setShortcut(QKeySequence.Open)
load_action.triggered.connect(self.load_file)
load_action.setObjectName('load_action')
load_action.setIcon(QIcon('icons/load.svg'))
quit_action = QAction(self.tr('&Quit'), self)
quit_action.setToolTip(self.tr('Exit from Sherloq'))
quit_action.setShortcut(QKeySequence.Quit)
quit_action.triggered.connect(self.close)
quit_action.setObjectName('quit_action')
quit_action.setIcon(QIcon('icons/quit.svg'))
tabbed_action = QAction(self.tr('&Tabbed'), self)
tabbed_action.setToolTip(self.tr('Toggle tabbed view for window area'))
tabbed_action.setShortcut(QKeySequence(Qt.Key_F10))
tabbed_action.setCheckable(True)
tabbed_action.triggered.connect(self.toggle_view)
tabbed_action.setObjectName('tabbed_action')
tabbed_action.setIcon(QIcon('icons/tabbed.svg'))
prev_action = QAction(self.tr('&Previous'), self)
prev_action.setToolTip(self.tr('Select the previous tool window'))
prev_action.setShortcut(QKeySequence.PreviousChild)
prev_action.triggered.connect(self.mdi_area.activatePreviousSubWindow)
prev_action.setObjectName('prev_action')
prev_action.setIcon(QIcon('icons/previous.svg'))
next_action = QAction(self.tr('&Next'), self)
next_action.setToolTip(self.tr('Select the next tool window'))
next_action.setShortcut(QKeySequence.NextChild)
next_action.triggered.connect(self.mdi_area.activateNextSubWindow)
next_action.setObjectName('next_action')
next_action.setIcon(QIcon('icons/next.svg'))
tile_action = QAction(self.tr('&Tile'), self)
tile_action.setToolTip(
self.tr('Arrange windows into non-overlapping views'))
tile_action.setShortcut(QKeySequence(Qt.Key_F11))
tile_action.triggered.connect(self.mdi_area.tileSubWindows)
tile_action.setObjectName('tile_action')
tile_action.setIcon(QIcon('icons/tile.svg'))
cascade_action = QAction(self.tr('&Cascade'), self)
cascade_action.setToolTip(
self.tr('Arrange windows into overlapping views'))
cascade_action.setShortcut(QKeySequence(Qt.Key_F12))
cascade_action.triggered.connect(self.mdi_area.cascadeSubWindows)
cascade_action.setObjectName('cascade_action')
cascade_action.setIcon(QIcon('icons/cascade.svg'))
close_action = QAction(self.tr('Close &All'), self)
close_action.setToolTip(self.tr('Close all open tool windows'))
close_action.setShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_W))
close_action.triggered.connect(self.mdi_area.closeAllSubWindows)
close_action.setObjectName('close_action')
close_action.setIcon(QIcon('icons/close.svg'))
self.full_action = QAction(self.tr('Full screen'), self)
self.full_action.setToolTip(self.tr('Switch to full screen mode'))
self.full_action.setShortcut(QKeySequence.FullScreen)
self.full_action.triggered.connect(self.change_view)
self.full_action.setObjectName('full_action')
self.full_action.setIcon(QIcon('icons/full.svg'))
self.normal_action = QAction(self.tr('Normal view'), self)
self.normal_action.setToolTip(self.tr('Back to normal view mode'))
self.normal_action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_F12))
self.normal_action.triggered.connect(self.change_view)
self.normal_action.setObjectName('normal_action')
self.normal_action.setIcon(QIcon('icons/normal.svg'))
about_action = QAction(self.tr('&About...'), self)
about_action.setToolTip(self.tr('Information about this program'))
about_action.triggered.connect(self.show_about)
about_action.setObjectName('about_action')
about_action.setIcon(QIcon('icons/sherloq_alpha.png'))
about_qt_action = QAction(self.tr('About &Qt'), self)
about_qt_action.setToolTip(
self.tr('Information about the Qt Framework'))
about_qt_action.triggered.connect(QApplication.aboutQt)
about_qt_action.setIcon(QIcon('icons/Qt.svg'))
file_menu = self.menuBar().addMenu(self.tr('&File'))
file_menu.addAction(load_action)
file_menu.addSeparator()
self.recent_actions = [None] * self.max_recent
for i in range(len(self.recent_actions)):
self.recent_actions[i] = QAction(self)
self.recent_actions[i].setVisible(False)
self.recent_actions[i].triggered.connect(self.open_recent)
file_menu.addAction(self.recent_actions[i])
file_menu.addSeparator()
file_menu.addAction(quit_action)
view_menu = self.menuBar().addMenu(self.tr('&View'))
view_menu.addAction(tools_action)
view_menu.addAction(help_action)
view_menu.addSeparator()
view_menu.addAction(self.full_action)
view_menu.addAction(self.normal_action)
window_menu = self.menuBar().addMenu(self.tr('&Window'))
window_menu.addAction(prev_action)
window_menu.addAction(next_action)
window_menu.addSeparator()
window_menu.addAction(tile_action)
window_menu.addAction(cascade_action)
window_menu.addAction(tabbed_action)
window_menu.addSeparator()
window_menu.addAction(close_action)
help_menu = self.menuBar().addMenu(self.tr('&Help'))
help_menu.addAction(help_action)
help_menu.addSeparator()
help_menu.addAction(about_action)
help_menu.addAction(about_qt_action)
main_toolbar = self.addToolBar(self.tr('&Toolbar'))
main_toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
main_toolbar.addAction(load_action)
main_toolbar.addSeparator()
main_toolbar.addAction(tools_action)
main_toolbar.addAction(help_action)
main_toolbar.addSeparator()
main_toolbar.addAction(prev_action)
main_toolbar.addAction(next_action)
main_toolbar.addSeparator()
main_toolbar.addAction(tile_action)
main_toolbar.addAction(cascade_action)
main_toolbar.addAction(tabbed_action)
main_toolbar.addAction(close_action)
# main_toolbar.addSeparator()
# main_toolbar.addAction(self.normal_action)
# main_toolbar.addAction(self.full_action)
main_toolbar.setAllowedAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea)
main_toolbar.setObjectName('main_toolbar')
settings = QSettings()
settings.beginGroup('main_window')
self.restoreGeometry(settings.value('geometry'))
self.restoreState(settings.value('state'))
self.recent_files = settings.value('recent_files')
if self.recent_files is None:
self.recent_files = []
elif not isinstance(self.recent_files, list):
self.recent_files = [self.recent_files]
self.update_recent()
settings.endGroup()
prev_action.setEnabled(False)
next_action.setEnabled(False)
tile_action.setEnabled(False)
cascade_action.setEnabled(False)
close_action.setEnabled(False)
tabbed_action.setEnabled(False)
self.tree_widget.setEnabled(False)
self.showNormal()
self.normal_action.setEnabled(False)
self.show_message(self.tr('Ready'))
class MainWindow(QMainWindow):
"""Provides the parent window that includes the BookmarkWidget,
BrowserTabWidget, and a DownloadWidget, to offer the complete
web browsing experience."""
def __init__(self):
super(MainWindow, self).__init__()
self.setWindowTitle('PySide2 tabbed browser Example')
self._tab_widget = BrowserTabWidget(create_main_window_with_browser)
self._tab_widget.enabled_changed.connect(self._enabled_changed)
self._tab_widget.download_requested.connect(self._download_requested)
self.setCentralWidget(self._tab_widget)
self.connect(self._tab_widget, QtCore.SIGNAL("url_changed(QUrl)"),
self.url_changed)
self._bookmark_dock = QDockWidget()
self._bookmark_dock.setWindowTitle('Bookmarks')
self._bookmark_widget = BookmarkWidget()
self._bookmark_widget.open_bookmark.connect(self.load_url)
self._bookmark_widget.open_bookmark_in_new_tab.connect(self.load_url_in_new_tab)
self._bookmark_dock.setWidget(self._bookmark_widget)
self.addDockWidget(Qt.LeftDockWidgetArea, self._bookmark_dock)
self._find_tool_bar = None
self._actions = {}
self._create_menu()
self._tool_bar = QToolBar()
self.addToolBar(self._tool_bar)
for action in self._actions.values():
if not action.icon().isNull():
self._tool_bar.addAction(action)
self._addres_line_edit = QLineEdit()
self._addres_line_edit.setClearButtonEnabled(True)
self._addres_line_edit.returnPressed.connect(self.load)
self._tool_bar.addWidget(self._addres_line_edit)
self._zoom_label = QLabel()
self.statusBar().addPermanentWidget(self._zoom_label)
self._update_zoom_label()
self._bookmarksToolBar = QToolBar()
self.addToolBar(Qt.TopToolBarArea, self._bookmarksToolBar)
self.insertToolBarBreak(self._bookmarksToolBar)
self._bookmark_widget.changed.connect(self._update_bookmarks)
self._update_bookmarks()
def _update_bookmarks(self):
self._bookmark_widget.populate_tool_bar(self._bookmarksToolBar)
self._bookmark_widget.populate_other(self._bookmark_menu, 3)
def _create_menu(self):
file_menu = self.menuBar().addMenu("&File")
exit_action = QAction(QIcon.fromTheme("application-exit"), "E&xit",
self, shortcut = "Ctrl+Q", triggered=qApp.quit)
file_menu.addAction(exit_action)
navigation_menu = self.menuBar().addMenu("&Navigation")
style_icons = ':/qt-project.org/styles/commonstyle/images/'
back_action = QAction(QIcon.fromTheme("go-previous",
QIcon(style_icons + 'left-32.png')),
"Back", self,
shortcut = QKeySequence(QKeySequence.Back),
triggered = self._tab_widget.back)
self._actions[QWebEnginePage.Back] = back_action
back_action.setEnabled(False)
navigation_menu.addAction(back_action)
forward_action = QAction(QIcon.fromTheme("go-next",
QIcon(style_icons + 'right-32.png')),
"Forward", self,
shortcut = QKeySequence(QKeySequence.Forward),
triggered = self._tab_widget.forward)
forward_action.setEnabled(False)
self._actions[QWebEnginePage.Forward] = forward_action
navigation_menu.addAction(forward_action)
reload_action = QAction(QIcon(style_icons + 'refresh-32.png'),
"Reload", self,
shortcut = QKeySequence(QKeySequence.Refresh),
triggered = self._tab_widget.reload)
self._actions[QWebEnginePage.Reload] = reload_action
reload_action.setEnabled(False)
navigation_menu.addAction(reload_action)
navigation_menu.addSeparator()
new_tab_action = QAction("New Tab", self,
shortcut = 'Ctrl+T',
triggered = self.add_browser_tab)
navigation_menu.addAction(new_tab_action)
close_tab_action = QAction("Close Current Tab", self,
shortcut = "Ctrl+W",
triggered = self._close_current_tab)
navigation_menu.addAction(close_tab_action)
edit_menu = self.menuBar().addMenu("&Edit")
find_action = QAction("Find", self,
shortcut = QKeySequence(QKeySequence.Find),
triggered = self._show_find)
edit_menu.addAction(find_action)
edit_menu.addSeparator()
undo_action = QAction("Undo", self,
shortcut = QKeySequence(QKeySequence.Undo),
triggered = self._tab_widget.undo)
self._actions[QWebEnginePage.Undo] = undo_action
undo_action.setEnabled(False)
edit_menu.addAction(undo_action)
redo_action = QAction("Redo", self,
shortcut = QKeySequence(QKeySequence.Redo),
triggered = self._tab_widget.redo)
self._actions[QWebEnginePage.Redo] = redo_action
redo_action.setEnabled(False)
edit_menu.addAction(redo_action)
edit_menu.addSeparator()
cut_action = QAction("Cut", self,
shortcut = QKeySequence(QKeySequence.Cut),
triggered = self._tab_widget.cut)
self._actions[QWebEnginePage.Cut] = cut_action
cut_action.setEnabled(False)
edit_menu.addAction(cut_action)
copy_action = QAction("Copy", self,
shortcut = QKeySequence(QKeySequence.Copy),
triggered = self._tab_widget.copy)
self._actions[QWebEnginePage.Copy] = copy_action
copy_action.setEnabled(False)
edit_menu.addAction(copy_action)
paste_action = QAction("Paste", self,
shortcut = QKeySequence(QKeySequence.Paste),
triggered = self._tab_widget.paste)
self._actions[QWebEnginePage.Paste] = paste_action
paste_action.setEnabled(False)
edit_menu.addAction(paste_action)
edit_menu.addSeparator()
select_all_action = QAction("Select All", self,
shortcut = QKeySequence(QKeySequence.SelectAll),
triggered = self._tab_widget.select_all)
self._actions[QWebEnginePage.SelectAll] = select_all_action
select_all_action.setEnabled(False)
edit_menu.addAction(select_all_action)
self._bookmark_menu = self.menuBar().addMenu("&Bookmarks")
add_bookmark_action = QAction("&Add Bookmark", self,
triggered = self._add_bookmark)
self._bookmark_menu.addAction(add_bookmark_action)
add_tool_bar_bookmark_action = QAction("&Add Bookmark to Tool Bar", self,
triggered = self._add_tool_bar_bookmark)
self._bookmark_menu.addAction(add_tool_bar_bookmark_action)
self._bookmark_menu.addSeparator()
tools_menu = self.menuBar().addMenu("&Tools")
download_action = QAction("Open Downloads", self,
triggered = DownloadWidget.open_download_directory)
tools_menu.addAction(download_action)
window_menu = self.menuBar().addMenu("&Window")
window_menu.addAction(self._bookmark_dock.toggleViewAction())
window_menu.addSeparator()
zoom_in_action = QAction(QIcon.fromTheme("zoom-in"),
"Zoom In", self,
shortcut = QKeySequence(QKeySequence.ZoomIn),
triggered = self._zoom_in)
window_menu.addAction(zoom_in_action)
zoom_out_action = QAction(QIcon.fromTheme("zoom-out"),
"Zoom Out", self,
shortcut = QKeySequence(QKeySequence.ZoomOut),
triggered = self._zoom_out)
window_menu.addAction(zoom_out_action)
reset_zoom_action = QAction(QIcon.fromTheme("zoom-original"),
"Reset Zoom", self,
shortcut = "Ctrl+0",
triggered = self._reset_zoom)
window_menu.addAction(reset_zoom_action)
about_menu = self.menuBar().addMenu("&About")
about_action = QAction("About Qt", self,
shortcut = QKeySequence(QKeySequence.HelpContents),
triggered=qApp.aboutQt)
about_menu.addAction(about_action)
def add_browser_tab(self):
return self._tab_widget.add_browser_tab()
def _close_current_tab(self):
if self._tab_widget.count() > 1:
self._tab_widget.close_current_tab()
else:
self.close()
def close_event(self, event):
main_windows.remove(self)
event.accept()
def load(self):
url_string = self._addres_line_edit.text().strip()
if url_string:
self.load_url_string(url_string)
def load_url_string(self, url_s):
url = QUrl.fromUserInput(url_s)
if (url.isValid()):
self.load_url(url)
def load_url(self, url):
self._tab_widget.load(url)
def load_url_in_new_tab(self, url):
self.add_browser_tab().load(url)
def url_changed(self, url):
self._addres_line_edit.setText(url.toString())
def _enabled_changed(self, web_action, enabled):
action = self._actions[web_action]
if action:
action.setEnabled(enabled)
def _add_bookmark(self):
index = self._tab_widget.currentIndex()
if index >= 0:
url = self._tab_widget.url()
title = self._tab_widget.tabText(index)
icon = self._tab_widget.tabIcon(index)
self._bookmark_widget.add_bookmark(url, title, icon)
def _add_tool_bar_bookmark(self):
index = self._tab_widget.currentIndex()
if index >= 0:
url = self._tab_widget.url()
title = self._tab_widget.tabText(index)
icon = self._tab_widget.tabIcon(index)
self._bookmark_widget.add_tool_bar_bookmark(url, title, icon)
def _zoom_in(self):
new_zoom = self._tab_widget.zoom_factor() * 1.5
if (new_zoom <= WebEngineView.maximum_zoom_factor()):
self._tab_widget.set_zoom_factor(new_zoom)
self._update_zoom_label()
def _zoom_out(self):
new_zoom = self._tab_widget.zoom_factor() / 1.5
if (new_zoom >= WebEngineView.minimum_zoom_factor()):
self._tab_widget.set_zoom_factor(new_zoom)
self._update_zoom_label()
def _reset_zoom(self):
self._tab_widget.set_zoom_factor(1)
self._update_zoom_label()
def _update_zoom_label(self):
percent = int(self._tab_widget.zoom_factor() * 100)
self._zoom_label.setText("{}%".format(percent))
def _download_requested(self, item):
# Remove old downloads before opening a new one
for old_download in self.statusBar().children():
if type(old_download).__name__ == 'download_widget' and \
old_download.state() != QWebEngineDownloadItem.DownloadInProgress:
self.statusBar().removeWidget(old_download)
del old_download
item.accept()
download_widget = download_widget(item)
download_widget.removeRequested.connect(self._remove_download_requested,
Qt.QueuedConnection)
self.statusBar().addWidget(download_widget)
def _remove_download_requested(self):
download_widget = self.sender()
self.statusBar().removeWidget(download_widget)
del download_widget
def _show_find(self):
if self._find_tool_bar is None:
self._find_tool_bar = FindToolBar()
self._find_tool_bar.find.connect(self._tab_widget.find)
self.addToolBar(Qt.BottomToolBarArea, self._find_tool_bar)
else:
self._find_tool_bar.show()
self._find_tool_bar.focus_find()
def write_bookmarks(self):
self._bookmark_widget.write_bookmarks()
