def __init__(self):
QWidget.__init__(self)
self.setMinimumSize(1000,500)
self.html = QWebView()
vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
back = QAction(QIcon(os.path.join(get_image_file_path(),"left.png")), _("back"), self)
back.triggered.connect(self.html.back)
toolbar.addAction(back)
home = QAction(QIcon(os.path.join(get_image_file_path(),"home.png")), _("home"), self)
home.triggered.connect(self.home)
toolbar.addAction(home)
self.tb_url=QLineEdit()
self.tb_url.returnPressed.connect(self.browse)
toolbar.addWidget(self.tb_url)
vbox.addWidget(toolbar)
self.default_url = "http://www.gpvdm.com/welcome.html"
self.tb_url.setText(self.default_url)
self.browse()
vbox.addWidget(self.html)
self.setLayout(vbox)
return
def clusters(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.order_widget = order_widget()
self.order_widget.new_text = _("New cluster configuration")
self.order_widget.delete_text = _("Delete configuration")
self.order_widget.clone_text = _("Clone configuration")
self.order_widget.rename_text = _("Rename configuration")
self.order_widget.new_dlg_text = _("New cluster configuration:")
self.order_widget.base_file_name = "cluster"
self.order_widget.new_tab_name = _("Cluster")
self.order_widget.clone_dlg_text = _(
"Clone the current cluster configuration to a cluster configuration called:"
)
self.order_widget.rename_dlg_text = _(
"Rename the cluster configuration to be called:")
self.order_widget.delete_dlg_text = _(
"Should I remove the cluster configuration ")
self.order_widget.init()
toolbar.addWidget(self.order_widget)
return toolbar
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.setWindowTitle("My Awesome App")
label = QLabel("THIS IS AWESOME!!!")
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
self.addToolBar(toolbar)
# Andriod Button
button_action = QAction(QIcon("android.png"), "Your button", self)
button_action.setStatusTip('This is your button')
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
#Second Button
button_action2 = QAction(QIcon('android.png'), 'Your button2', self)
button_action2.setStatusTip('This is your button 2')
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action2)
#CheckBox
toolbar.addWidget(QLabel('Hello'))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def display_filter(self, main_widget: QToolBar) -> None:
main_widget.addWidget(self._layer_select)
def add_filters_block(label_name: str, filters_ui: List[FilterUI],
toolbar: QToolBar) -> None:
widget = QWidget()
layout = QHBoxLayout(widget)
label = QLabel(label_name)
label.setFont(QFont("Times", 12))
layout.addWidget(label)
for filter_ui in filters_ui:
filter_ui.display_filter(layout)
toolbar.addWidget(widget)
named_filters: Dict[Filters,
LayerFilterUI] = LayerFiltersUI.filters_to_dict(
self.filters_ui)
add_filters_block(
"Has Mask: ",
[
named_filters[Filters.LAYER_HAS_MASK],
named_filters[Filters.LAYER_NO_MASK]
],
main_widget,
)
add_filters_block(
"Certified:",
[
named_filters[Filters.LAYER_CERTIFIED],
named_filters[Filters.LAYER_NOT_CERTIFIED]
],
main_widget,
)
def toolbar(self) -> QToolBar:
toolbar = QToolBar(self)
toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
label = QLabel("Blend:")
toolbar.addWidget(label)
blend_combo_box = QComboBox()
modes_list = [
o for o in getmembers(QPainter)
if o[0].startswith('CompositionMode_')
]
blend_combo_box.addItems(
[f[0].replace('CompositionMode_', '') for f in modes_list])
blend_combo_box.setCurrentText('Screen')
blend_combo_box.currentTextChanged.connect(
self._blend_current_text_changed)
toolbar.addWidget(blend_combo_box)
toolbar.addSeparator()
show_scale_bar_action = QAction(QIcon(":/icons/icons8-ruler-16.png"),
"Scale Bar", self)
show_scale_bar_action.triggered.connect(self._show_scale_bar)
show_scale_bar_action.setCheckable(True)
toolbar.addAction(show_scale_bar_action)
show_mask_action = QAction(QIcon(":/icons/icons8-ruler-16.png"),
"Mask", self)
show_mask_action.triggered.connect(self._show_mask)
show_mask_action.setCheckable(True)
toolbar.addAction(show_mask_action)
return toolbar
def __init__(self, name="", parent_dataset=None, ax=None):
"""
**Constructor**
Keyword Arguments:
- name {[type]} -- [description] (default: {""})
- parent_dataset {[type]} -- [description] (default: {None})
- ax {[type]} -- [description] (default: {None})
"""
super().__init__(name, parent_dataset, ax)
# add widgets specific to the theory
tb = QToolBar()
tb.setIconSize(QSize(24, 24))
self.spinbox = QSpinBox()
self.spinbox.setRange(1, self.MAX_MODES) # min and max number of modes
self.spinbox.setSuffix(" modes")
self.spinbox.setValue(self.parameters["nmodes"].value) #initial value
tb.addWidget(self.spinbox)
self.modesaction = tb.addAction(
QIcon(':/Icon8/Images/new_icons/icons8-visible.png'), 'View modes')
self.modesaction.setCheckable(True)
self.modesaction.setChecked(True)
self.thToolsLayout.insertWidget(0, tb)
connection_id = self.spinbox.valueChanged.connect(
self.handle_spinboxValueChanged)
connection_id = self.modesaction.triggered.connect(
self.modesaction_change)
def createNavBar(self) -> None:
navbar = NavBar()
self.addToolBar(navbar)
self.addToolBarBreak()
backButton = Action("Go Back", self)
backButton.triggered.connect(self.browserEngineView.back)
forwardButton = Action("Go Forward", self)
forwardButton.triggered.connect(self.browserEngineView.forward)
reloadButton = Action("Reload Page", self)
reloadButton.triggered.connect(self.browserEngineView.reload)
homeButton = Action("Go to Home", self)
homeButton.triggered.connect(self.navigateHome)
networkDetailsButton = Action("Network Details", self)
networkDetailsButton.triggered.connect(self.fetchNetworkDetails)
ipConfigButton = Action("IP Config", self)
ipConfigButton.triggered.connect(self.fetchIpConfig)
navbar.addActions([
backButton,
forwardButton,
reloadButton,
homeButton,
networkDetailsButton,
ipConfigButton,
])
self.urlBar = LineEdit()
self.urlBar.returnPressed.connect(self.navigateToUrl)
navbar.addWidget(self.urlBar)
def __init__(self, page, parent=None):
super(HelpForm, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setAttribute(Qt.WA_GroupLeader)
backAction = QAction(qtawesome.icon("fa.backward"), "&Back", self)
backAction.setShortcut(QKeySequence.Back)
homeAction = QAction(qtawesome.icon("fa.home"), "&Home", self)
homeAction.setShortcut("Home")
self.pageLabel = QLabel()
toolBar = QToolBar()
toolBar.addAction(backAction)
toolBar.addAction(homeAction)
toolBar.addWidget(self.pageLabel)
self.textBrowser = QTextBrowser()
layout = QVBoxLayout()
layout.addWidget(toolBar)
layout.addWidget(self.textBrowser, 1)
self.setLayout(layout)
backAction.triggered.connect(self.tbackward)
homeAction.triggered.connect(self.thome)
self.textBrowser.sourceChanged.connect(self.updatePageTitle)
self.textBrowser.setSearchPaths([":/help"])
self.textBrowser.setSource(QUrl(page))
self.resize(400, 600)
self.setWindowTitle("{0} Help".format(QApplication.applicationName()))
def __init__(self):
QWidget.__init__(self)
self.win_list=windows()
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"doping.png")))
self.setWindowTitle(_("Doping profile editor (www.gpvdm.com)"))
self.win_list.set_window(self,"doping")
self.main_vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save"), self)
self.save.triggered.connect(self.callback_save)
toolbar.addAction(self.save)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), _("Help"), self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.fig = Figure(figsize=(5,4), dpi=100)
self.ax1=None
self.show_key=True
canvas = FigureCanvas(self.fig)
#canvas.set_background('white')
#canvas.set_facecolor('white')
canvas.figure.patch.set_facecolor('white')
canvas.show()
self.main_vbox.addWidget(canvas)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(4)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.build_mesh()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.draw_graph()
self.setLayout(self.main_vbox)
return
def __init__(self):
QWidget.__init__(self)
self.setMinimumSize(1000,500)
self.html = QWebView()
vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
back = QAction(icon_get("go-previous.png"), _("back"), self)
back.triggered.connect(self.html.back)
toolbar.addAction(back)
home = QAction(icon_get("user-home.png"), _("home"), self)
home.triggered.connect(self.home)
toolbar.addAction(home)
self.tb_url=QLineEdit()
self.tb_url.returnPressed.connect(self.browse)
toolbar.addWidget(self.tb_url)
vbox.addWidget(toolbar)
self.default_url = "http://www.gpvdm.com/welcome.html"
self.tb_url.setText(self.default_url)
self.browse()
vbox.addWidget(self.html)
self.setLayout(vbox)
return
def _update_row(self,
pkg: PackageView,
update_check_enabled: bool = True,
change_update_col: bool = True):
self._set_col_name(0, pkg)
self._set_col_version(1, pkg)
self._set_col_description(2, pkg)
self._set_col_publisher(3, pkg)
self._set_col_type(4, pkg)
self._set_col_installed(5, pkg)
self._set_col_actions(6, pkg)
if change_update_col:
col_update = None
if update_check_enabled and pkg.model.update:
col_update = QToolBar()
col_update.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Preferred)
col_update.addWidget(
UpdateToggleButton(pkg=pkg,
root=self.window,
i18n=self.i18n,
checked=pkg.update_checked if
pkg.model.can_be_updated() else False,
clickable=pkg.model.can_be_updated()))
self.setCellWidget(pkg.table_index, 7, col_update)
def file_toolbar(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.import_image = QAction_lock("import_image",
wrap_text(_("Load new image"),
7), self,
"ribbon_shape_import_import_image")
toolbar.addAction(self.import_image)
self.save_data = QAction_lock("document-save-as",
wrap_text(_("Import data"), 4), self,
"ribbon_shape_import_save")
toolbar.addAction(self.save_data)
#self.xy_triangles= QAction_lock("shape", wrap_text(_("xy triangles"),2), self,"ribbon_shape_xy_tri")
#toolbar.addAction(self.xy_triangles)
self.tb_script = QAction_lock("script",
wrap_text(_("Generate\nImage"), 2), self,
"ribbon_shape_script")
toolbar.addAction(self.tb_script)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.tb_help = QAction(icon_get("help"), _("Help"), self)
self.tb_help.setStatusTip(_("Help"))
toolbar.addAction(self.tb_help)
return toolbar
def _set_col_installed(self, col: int, pkg: PackageView):
toolbar = QToolBar()
toolbar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
if pkg.model.installed:
if pkg.model.can_be_uninstalled():
def uninstall():
self._uninstall_app(pkg)
item = self._gen_row_button(
self.i18n['uninstall'].capitalize(),
INSTALL_BT_STYLE.format(back='#ff1a1a'), uninstall)
else:
item = QLabel()
item.setPixmap((QPixmap(resource.get_path('img/checked.svg'))))
item.setAlignment(Qt.AlignCenter)
item.setToolTip(self.i18n['installed'])
elif pkg.model.can_be_installed():
def install():
self._install_app(pkg)
item = self._gen_row_button(
self.i18n['install'].capitalize(),
INSTALL_BT_STYLE.format(back='#088A08'), install)
else:
item = None
toolbar.addWidget(item)
self.setCellWidget(pkg.table_index, col, toolbar)
def __init__(self, *args, **kwargs):
super(MainWindow01, self).__init__(*args, **kwargs)
self.setWindowTitle("My Awesome App")
label = QLabel("THIS IS AWESOME!!!")
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar("My main toolbar")
self.addToolBar(toolbar)
button_action = QAction(QIcon("rocket.png"), "Your button", self)
button_action.setStatusTip("This is your button")
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction("Your button2", self)
button_action2.setStatusTip("This is your button2")
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action2)
toolbar.addWidget(QLabel("Hello"))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def setupToolBar(self):
toolBar = QToolBar()
self.toolbar = self.addToolBar(toolBar)
logProcessingView = QToolButton()
logProcessingView.setText("Log Processing View")
logProcessingView.setCheckable(True)
logProcessingView.clicked.connect(lambda: self.updateView(1))
analysisView = QToolButton()
analysisView.setText("Analysis View")
analysisView.setCheckable(True)
analysisView.clicked.connect(lambda: self.updateView(0))
actionreportView = QToolButton()
actionreportView.setText("Action Report")
actionreportView.setCheckable(True)
actionreportView.clicked.connect(lambda: self.updateView(2))
group = QButtonGroup(self)
group.exclusive()
for button in (analysisView, logProcessingView, actionreportView):
toolBar.addWidget(button)
group.addButton(button)
def __init__(self, name="", parent_dataset=None, ax=None):
"""**Constructor**"""
super().__init__(name, parent_dataset, ax)
# add widgets specific to the theory
tb = QToolBar()
tb.setIconSize(QSize(24, 24))
self.spinbox = QSpinBox()
self.spinbox.setRange(self.NBIN_MIN,
self.NBIN_MAX) # min and max number of modes
self.spinbox.setSuffix(" bins")
self.spinbox.setValue(self.parameters["nbin"].value) # initial value
tb.addWidget(self.spinbox)
self.thToolsLayout.insertWidget(0, tb)
# view bins button
self.view_bins_button = tb.addAction(
QIcon(":/Icon8/Images/new_icons/icons8-visible.png"), "View modes")
self.view_bins_button.setCheckable(True)
self.view_bins_button.setChecked(True)
self.thToolsLayout.insertWidget(0, tb)
self.thToolsLayout.insertWidget(0, tb)
# connections signal and slots
connection_id = self.view_bins_button.triggered.connect(
self.handle_view_bins_button_triggered)
connection_id = self.spinbox.valueChanged.connect(
self.handle_spinboxValueChanged)
# disable useless buttons for this theory
self.parent_dataset.actionMinimize_Error.setDisabled(True)
self.parent_dataset.actionShow_Limits.setDisabled(True)
self.parent_dataset.actionVertical_Limits.setDisabled(True)
self.parent_dataset.actionHorizontal_Limits.setDisabled(True)
def measurement(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.order_widget = order_widget()
self.order_widget.new_text = _("New measurement")
self.order_widget.delete_text = _("Delete measurement")
self.order_widget.clone_text = _("Clone measurement")
self.order_widget.rename_text = _("Rename measurement")
self.order_widget.new_dlg_text = _("New measurement name")
self.order_widget.base_file_name = "measure"
self.order_widget.new_tab_name = _("measurement")
self.order_widget.clone_dlg_text = _(
"Clone the current measurement to a new measurement called:")
self.order_widget.rename_dlg_text = _(
"Rename the measurement to be called")
self.order_widget.delete_dlg_text = _(
"Should I remove the measurment file ")
self.order_widget.init()
toolbar.addWidget(self.order_widget)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.home_help = QAction(icon_get("internet-web-browser"), _("Help"),
self)
toolbar.addAction(self.home_help)
return toolbar
def __init__(self, name="", parent_dataset=None, ax=None):
"""
**Constructor**
Keyword Arguments:
- name {[type]} -- [description] (default: {""})
- parent_dataset {[type]} -- [description] (default: {None})
- ax {[type]} -- [description] (default: {None})
"""
super().__init__(name, parent_dataset, ax)
# add widgets specific to the theory
tb = QToolBar()
tb.setIconSize(QSize(24, 24))
self.linkMeGeaction = tb.addAction(
QIcon(':/Icon8/Images/new_icons/linkGeMe.png'), 'Link Me-Ge')
self.linkMeGeaction.setCheckable(True)
self.linkMeGeaction.setChecked(False)
lbl = QLabel("<P><b>rho</b> (g/cm<sup>3</sup>)</P></br>", self)
tb.addWidget(lbl)
self.txtrho = QLineEdit("%.4g"%self.parameters["rho0"].value)
self.txtrho.setReadOnly(True)
self.txtrho.setDisabled(True)
dvalidator = QDoubleValidator() #prevent letters etc.
dvalidator.setBottom(0) #minimum allowed value
dvalidator.setTop(10) #maximum allowed value
self.txtrho.setValidator(dvalidator)
tb.addWidget(self.txtrho)
self.thToolsLayout.insertWidget(0, tb)
connection_id = self.linkMeGeaction.triggered.connect(self.linkMeGeaction_change)
connection_id = self.txtrho.textEdited.connect(self.handle_txtrho_edited)
def __init__(self, page, parent=None):
super(HelpForm, self).__init__(parent)
self.setWindowTitle("CellSim Help")
self.setAttribute(Qt.WA_DeleteOnClose)
# actions
backAction = QAction(QIcon(":/back.png"), "&Back", self)
backAction.setShortcut(QKeySequence.Back)
homeAction = QAction(QIcon(":/home.png"), "&Home", self)
homeAction.setShortcut("Home")
self.pageLabel = QLabel()
#toolbar
toolBar = QToolBar()
toolBar.addAction(backAction)
toolBar.addAction(homeAction)
toolBar.addWidget(self.pageLabel)
self.pageLabel.setFont(QFont("Roman times", 12, QFont.Bold))
self.textBrowser = QTextBrowser()
# layout
layout = QVBoxLayout()
layout.addWidget(toolBar)
layout.addWidget(self.textBrowser, 1)
self.setLayout(layout)
# signals and slots
backAction.triggered.connect(self.textBrowser.backward)
homeAction.triggered.connect(self.textBrowser.home)
self.textBrowser.sourceChanged.connect(self.updatePageTitle)
self.textBrowser.setSearchPaths([":/help"])
self.textBrowser.setSource(QUrl(page))
self.resize(400, 600)
def __init__(self, page, parent=None):
super(HelpForm, self).__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowModality(Qt.WindowModal)
# actions
backAction = QAction(QIcon(":/back.png"), "&Back", self)
backAction.setShortcut(QKeySequence.Back)
homeAction = QAction(QIcon(":/home.png"), "&Home", self)
homeAction.setShortcut("Home")
self.pageLabel = QLabel()
#toolbar
toolBar = QToolBar()
toolBar.addAction(backAction)
toolBar.addAction(homeAction)
toolBar.addWidget(self.pageLabel)
self.textBrowser = QTextBrowser()
# layout
layout = QVBoxLayout()
layout.addWidget(toolBar)
layout.addWidget(self.textBrowser, 1)
self.setLayout(layout)
# signals and slots
backAction.triggered.connect(self.textBrowser.backward)
homeAction.triggered.connect(self.textBrowser.home)
self.textBrowser.sourceChanged.connect(self.updatePageTitle)
self.textBrowser.setSearchPaths([":/help"])
self.textBrowser.setSource(QUrl(page))
self.resize(400, 600)
self.setWindowTitle("{0} Help".format(
QApplication.applicationName()))
def file(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.home_new = QAction(QIcon_load("document-new"),
_("New simulation").replace(" ", "\n"), self)
#self.home_new.setText(_("New\nsimulation"))
toolbar.addAction(self.home_new)
self.home_open = QAction(QIcon_load("document-open"),
_("Open\nsimulation"), self)
toolbar.addAction(self.home_open)
self.home_export = QAction(QIcon_load("document-export"),
_("Export\ndata"), self)
toolbar.addAction(self.home_export)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.home_help = QAction(QIcon_load("internet-web-browser"), _("Help"),
self)
toolbar.addAction(self.home_help)
return toolbar
def __init__(self):
QWidgetSavePos.__init__(self, "electrical")
self.setFixedSize(1000, 600)
self.setWindowIcon(icon_get("preferences-system"))
self.setWindowTitle(
_("Electrical parameter editor") + " (https://www.gpvdm.com)")
self.main_vbox = QVBoxLayout()
toolbar = QToolBar()
toolbar.setIconSize(QSize(48, 48))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.undo = QAction(icon_get("help"), _("Help"), self)
self.undo.setStatusTip(_("Help"))
self.undo.triggered.connect(self.callback_help)
toolbar.addAction(self.undo)
self.main_vbox.addWidget(toolbar)
self.notebook = QTabWidget()
self.notebook.setMovable(True)
self.main_vbox.addWidget(self.notebook)
widget = tab_class("device.inp")
self.notebook.addTab(widget, _("Device"))
self.setLayout(self.main_vbox)
def experiment(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle( Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.order_widget=order_widget()
self.order_widget.new_text=_("New experiment")
self.order_widget.delete_text=_("Delete experiment")
self.order_widget.clone_text=_("Clone experiment")
self.order_widget.rename_text=_("Rename experiment")
self.order_widget.new_dlg_text=_("New experiment name:")
self.order_widget.base_file_name=["is","is_fxdomain_data","fxmesh"]
self.order_widget.new_tab_name=_("experiment ")
self.order_widget.clone_dlg_text=_("Clone the current experiment to a new experiment called:")
self.order_widget.rename_dlg_text=_("Rename the experiment to be called:")
self.order_widget.delete_dlg_text=_("Should I remove the experiment file ")
self.order_widget.postfix="@is"
self.order_widget.name_token="#sim_menu_name"
self.order_widget.init()
toolbar.addWidget(self.order_widget)
self.tb_save = QAction(icon_get(("document-save")), wrap_text(_("Save image"),3), self)
toolbar.addAction(self.tb_save)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.home_help = QAction(icon_get("internet-web-browser"), _("Help"), self)
toolbar.addAction(self.home_help)
return toolbar
def _set_col_publisher(self, col: int, pkg: PackageView):
item = QToolBar()
publisher = pkg.model.get_publisher()
full_publisher = None
if publisher:
publisher = publisher.strip()
full_publisher = publisher
if len(publisher) > PUBLISHER_MAX_SIZE:
publisher = full_publisher[0: PUBLISHER_MAX_SIZE - 3] + '...'
if not publisher:
if not pkg.model.installed:
item.setStyleSheet('QLabel { color: red; }')
publisher = self.i18n['unknown']
lb_name = QLabel(' {}'.format(publisher))
item.addWidget(lb_name)
if publisher and full_publisher:
lb_name.setToolTip(self.i18n['publisher'].capitalize() + ((': ' + full_publisher) if full_publisher else ''))
if pkg.model.is_trustable():
lb_verified = QLabel()
lb_verified.setPixmap(self.pixmap_verified)
lb_verified.setToolTip(self.i18n['publisher.verified'].capitalize())
item.addWidget(lb_verified)
else:
lb_name.setText(lb_name.text() + " ")
self.setCellWidget(pkg.table_index, col, item)
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.setWindowTitle("Jayone's Awesome App")
label = QLabel('THIS IS AWESOME!!!')
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar('My main toolbar')
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon('bug.png'), 'Your button', self)
button_action.setStatusTip('This is your button')
button_action.triggered.connect(self.onMyToolBarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon('bug.png'), 'Your button2', self)
button_action2.setStatusTip('This is your button2')
button_action2.triggered.connect(self.onMyToolBarButtonClick)
button_action2.setCheckable(False)
toolbar.addAction(button_action2)
toolbar.addSeparator()
toolbar.addWidget(QLabel('Hello'))
toolbar.addSeparator()
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def scan(self):
toolbar = QToolBar()
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(42, 42))
self.tb_new = QAction(icon_get("document-new"),
wrap_text(_("New scan"), 2), self)
toolbar.addAction(self.tb_new)
self.tb_delete = QAction(icon_get("edit-delete"),
wrap_text(_("Delete scan"), 3), self)
toolbar.addAction(self.tb_delete)
self.tb_clone = QAction(icon_get("clone"),
wrap_text(_("Clone scan"), 3), self)
toolbar.addAction(self.tb_clone)
self.tb_rename = QAction(icon_get("rename"),
wrap_text(_("Rename scan"), 3), self)
toolbar.addAction(self.tb_rename)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.home_help = QAction(icon_get("internet-web-browser"), _("Help"),
self)
toolbar.addAction(self.home_help)
return toolbar
def __init__(self, index):
QWidget.__init__(self)
vbox = QVBoxLayout()
self.index = index
toolbar = QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.load_type = tb_pulse_load_type(self.index)
#self.load_type.connect("changed", self.draw_callback)
toolbar.addWidget(self.load_type)
vbox.addWidget(toolbar)
self.diode = QPixmap(os.path.join(get_image_file_path(), "diode.png"))
self.ideal_diode = QPixmap(
os.path.join(get_image_file_path(), "ideal_diode.png"))
self.load = QPixmap(os.path.join(get_image_file_path(), "load.png"))
self.ideal_load = QPixmap(
os.path.join(get_image_file_path(), "ideal_load.png"))
self.voc = QPixmap(os.path.join(get_image_file_path(), "voc.png"))
self.darea = QWidget()
vbox.addWidget(self.darea)
self.setLayout(vbox)
self.load_type.changed.connect(self.repaint)
return
class ribbon_shape(ribbon_base):
def main_toolbar(self):
self.main_toolbar = QToolBar()
self.main_toolbar.setToolButtonStyle( Qt.ToolButtonTextUnderIcon)
self.main_toolbar.setIconSize(QSize(42, 42))
self.tb_import = QAction(icon_get("import_image"), wrap_text("Import image",3), self)
self.main_toolbar.addAction(self.tb_import)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.main_toolbar.addWidget(spacer)
self.help = QAction(icon_get("internet-web-browser"), _("Help"), self)
self.main_toolbar.addAction(self.help)
return self.main_toolbar
def __init__(self):
ribbon_base.__init__(self)
w=self.main_toolbar()
self.addTab(w,_("File"))
#w=self.import_toolbar()
#self.addTab(w,_("Import data"))
sheet=self.readStyleSheet(os.path.join(get_css_path(),"style.css"))
if sheet!=None:
sheet=str(sheet,'utf-8')
self.setStyleSheet(sheet)
def _set_col_installed(self, col: int, pkg: PackageView):
toolbar = QToolBar()
toolbar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
if pkg.model.installed:
if pkg.model.can_be_uninstalled():
def uninstall():
self._uninstall_app(pkg)
style = 'color: {c}; font-size: 10px; font-weight: bold;'.format(
c=BROWN)
item = self._gen_row_button(
self.i18n['uninstall'].capitalize(), style, uninstall)
else:
item = QLabel()
item.setPixmap((QPixmap(resource.get_path('img/checked.svg'))))
item.setAlignment(Qt.AlignCenter)
item.setToolTip(self.i18n['installed'])
elif pkg.model.can_be_installed():
def install():
self._install_app(pkg)
style = 'background: {b}; color: white; font-size: 10px; font-weight: bold'.format(
b=GREEN)
item = self._gen_row_button(self.i18n['install'].capitalize(),
style, install)
else:
item = None
toolbar.addWidget(item)
self.setCellWidget(pkg.table_index, col, toolbar)
def __init__(self, *args, **kwargs):
super(MainWindow, self).__init__(*args, **kwargs)
self.setWindowTitle('My Awesome App !!!!!!')
label = QLabel('This is a PyQt5 window !')
label.setAlignment(Qt.AlignCenter)
self.setCentralWidget(label)
toolbar = QToolBar('My main toolbar')
toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
toolbar.setIconSize(QSize(16, 16))
self.addToolBar(toolbar)
button_action = QAction(QIcon('.\\bug.png'), "Your button", self)
button_action.setStatusTip('This is your button')
button_action.triggered.connect(self.onMyToolbarButtonClick)
button_action.setCheckable(True)
toolbar.addAction(button_action)
toolbar.addSeparator()
button_action2 = QAction(QIcon('.\\bug.png'), "Your button 2", self)
button_action2.setStatusTip('This is your button 2')
button_action2.triggered.connect(self.onMyToolbarButtonClick)
button_action2.setCheckable(True)
toolbar.addAction(button_action2)
toolbar.addWidget(QLabel('Hello'))
toolbar.addWidget(QCheckBox())
self.setStatusBar(QStatusBar(self))
def __init__(self):
QWidgetSavePos.__init__(self, "cost")
self.setFixedSize(900, 600)
self.setWindowIcon(icon_get("jv"))
self.setWindowTitle(_("Cost and energy payback calculator"))
self.main_vbox = QVBoxLayout()
toolbar = QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.play = QAction(icon_get("media-playback-start"),
_("Re-calcualte"), self)
self.play.triggered.connect(self.update)
toolbar.addAction(self.play)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(icon_get("help"), _("Help"), self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.update()
def invoke(self):
"""
the real setup function to show someting.
"""
self.setupUi(self)
# make sure the first col show full
self.yeahdoclisttree.header().setResizeMode(0, QHeaderView.ResizeToContents)
self.__initAction()
# toolbar .
classToolbar = QToolBar()
classToolbar.setIconSize(QSize(16, 16))
classToolbar.setMovable(False)
self.rightsplitter.insertWidget(0, classToolbar)
classToolbar.addAction(self.__actions["__yeahdoc_c_new__"])
classToolbar.addAction(self.__actions["__yeahdoc_c_edit__"])
classToolbar.addAction(self.__actions["__yeahdoc_c_rename__"])
classToolbar.addAction(self.__actions["__yeahdoc_c_delete__"])
classToolbar.addWidget(self.__evt_category_view())
# More useful gadgets
self.togglebtn.setIcon(QIcon(getPath("iconDir", "yeahdoc/right.png")))
# read datas from db .
self.__setupYeahdocCategoryDatas()
self.__setupyeahdoclisttreeDatas()
class BufferSelectToolbar(object):
def __init__(self, selectTool):
super(BufferSelectToolbar, self).__init__()
# references
self.selectTool = selectTool
self.result = None
self.debug = self.selectTool.debug
self.id = id
self.config = self.selectTool.config
self.info = Info(self)
try:
self.gtomain = self.selectTool.gtomain
self.helper = self.gtomain.helper
self.metadata = self.gtomain.metadata
self.iface = self.gtomain.iface
self.canvas = self.iface.mapCanvas()
# tool data
self.toolbar_dock = self.config.get("toolbar_dock", 4)
self.toolbar_height = self.gtomain.toolbar_height
# widget
self.toolbar = None
# load toolbar
objName = "gtoTB_" + __name__ + str(id)
self.toolbar = self.gtomain.helper.findToolbar(self.iface, objName)
if self.toolbar is None:
if self.debug: self.info.log("load", objName)
self.toolbar = QToolBar()
self.toolbar.setObjectName(objName)
self.toolbar.setWindowTitle(u'GTO Buffer Selection')
self.toolbar.setAllowedAreas(Qt.BottomToolBarArea
| Qt.TopToolBarArea)
self.iface.mainWindow().addToolBarBreak(self.toolbar_dock)
self.iface.addToolBar(self.toolbar, self.toolbar_dock)
# set the iconsize=> changed when self.iface.addToolBar :S
if self.toolbar_height is not None:
self.toolbar.setMaximumHeight(self.gtomain.toolbar_height)
self.toolbar.setMinimumHeight(self.gtomain.toolbar_height)
else:
self.toolbar.clear()
self.wid = Widget(self)
self.toolbar.addWidget(self.wid)
self.wid.setIconSizes(self.iface.iconSize(False))
self.wid.geometry_changed.connect(self.getGeometry)
self.toolbar.setHidden(False)
except Exception as e:
self.info.err(e)
# from mActionbufferselectxy
def setHidden(self, a0):
self.toolbar.setHidden(a0)
def setGeometry(self, geo, isValid, isCircle=False, isRectangle=False):
self.toolbar.setHidden(False)
if self.debug:
self.info.log("setGeometry", geo.isEmpty(), isValid, isCircle,
isRectangle)
self.wid.setOriginalGeometry(geo, isValid, isCircle, isRectangle)
def getGeometry(self, geo):
self.selectTool.setGeometryToMapTool(geo)
def __init__(self,index):
QWidget.__init__(self)
vbox=QVBoxLayout()
self.index=index
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.load_type=tb_pulse_load_type(self.index)
#self.load_type.connect("changed", self.draw_callback)
toolbar.addWidget(self.load_type)
vbox.addWidget(toolbar)
self.diode = QPixmap(os.path.join(get_image_file_path(),"diode.png"))
self.ideal_diode = QPixmap(os.path.join(get_image_file_path(),"ideal_diode.png"))
self.load = QPixmap(os.path.join(get_image_file_path(),"load.png"))
self.ideal_load = QPixmap(os.path.join(get_image_file_path(),"ideal_load.png"))
self.voc = QPixmap(os.path.join(get_image_file_path(),"voc.png"))
self.darea = QWidget()
vbox.addWidget(self.darea)
self.setLayout(vbox)
self.load_type.changed.connect(self.repaint)
return
def ToolBar(*action_list):
toolbar = QToolBar()
for action in action_list:
if action is None:
toolbar.addSeparator()
else:
toolbar.addWidget(ToolButton(action))
return toolbar
def init_chrome(self):
# Set up the browser window chrome:
self.setWindowTitle("Quickbrowse")
toolbar = QToolBar("Toolbar")
self.addToolBar(toolbar)
btn_act = QAction("Back", self)
# for an icon: QAction(QIcon("bug.png"), "Your button", self)
btn_act.setStatusTip("Go back")
btn_act.triggered.connect(self.go_back)
toolbar.addAction(btn_act)
btn_act = QAction("Forward", self)
btn_act.setStatusTip("Go forward")
btn_act.triggered.connect(self.go_forward)
toolbar.addAction(btn_act)
btn_act = QAction("Reload", self)
btn_act.setStatusTip("Reload")
btn_act.triggered.connect(self.reload)
toolbar.addAction(btn_act)
self.urlbar = ReadlineEdit()
self.urlbar.setPlaceholderText("URL goes here")
self.urlbar.returnPressed.connect(self.urlbar_load)
toolbar.addWidget(self.urlbar)
self.tabwidget = QTabWidget()
self.tabwidget.setTabBarAutoHide(True)
self.setCentralWidget(self.tabwidget)
self.tabwidget.tabBar().installEventFilter(self)
self.prev_middle = -1
self.active_tab = 0
self.setStatusBar(QStatusBar(self))
self.progress = QProgressBar()
self.statusBar().addPermanentWidget(self.progress)
# Key bindings
# For keys like function keys, use QtGui.QKeySequence("F12")
QShortcut("Ctrl+Q", self, activated=self.close)
QShortcut("Ctrl+L", self, activated=self.select_urlbar)
QShortcut("Ctrl+T", self, activated=self.new_tab)
QShortcut("Ctrl+R", self, activated=self.reload)
QShortcut("Ctrl++", self, activated=self.zoom)
QShortcut("Ctrl+=", self, activated=self.zoom)
QShortcut("Ctrl+-", self, activated=self.unzoom)
QShortcut("Alt+Left", self, activated=self.go_back)
QShortcut("Alt+Right", self, activated=self.go_forward)
QShortcut("Esc", self, activated=self.unfullscreen)
def __init__(self):
super(MainWindow, self).__init__()
self.start_logo()
self.setupUi(self)
self.sysencoding =sys.stdout.encoding
#self.centralWidget = PyPreviewer(self)
#self.setCentralWidget(self.centralWidget)
self.setupEditor()
self.setWindowIcon(QIcon('PyPreviewer.ico'))
#메뉴 이벤트 생성
self.createEvent()
self.dirty = False
self.plainTextEdit_2.textChanged.connect(self.setDirty)
self.fileName = None
self.plainTextEdit_2.setTabStopWidth(35)
self.plainTextEdit_2.setPlainText("# -*- coding: utf-8 -*-\n# 반갑습니다~\n# #은 파이썬에서 주석입니다.\nprint(\"이 부분은 출력창입니다.\")\nprint(\"구구단 예제\")\nfor i in range(2,10):\n\tprint(i,\"단\")\n\tfor j in range(2,10):\n\t\tprint(i,\"X\", j, \"=\", i*j)\n# 파이썬 실행은 아래 실행버튼을 눌러주세요.\n# 파이썬 학습 관련 및 예제는 왼쪽 화면을 이용하시기 바랍니다.")
#web view
#self.exampleView.load(QUrl("http://www.google.com"))
self.startfilepath=os.getcwd() +"/PyStudy_web/Main.html"
self.exampleView.load(QUrl.fromLocalFile(self.startfilepath))
self.locationEdit = QLineEdit(self)
self.locationEdit.setSizePolicy(QSizePolicy.Expanding,
self.locationEdit.sizePolicy().verticalPolicy())
self.locationEdit.returnPressed.connect(self.changeLocation)
toolBar = QToolBar()
self.addToolBar(toolBar)
self.insertToolBarBreak(toolBar)
toolBar.addAction(self.exampleView.pageAction(QWebPage.Back))
toolBar.addAction(self.exampleView.pageAction(QWebPage.Forward))
toolBar.addAction(self.action_myHome)
toolBar.addAction(self.exampleView.pageAction(QWebPage.Reload))
#toolBar.addAction(self.exampleView.pageAction(QWebPage.Stop))
toolBar.addWidget(self.locationEdit)
#사용자 입력 파이썬 파일 실행
print ('Connecting process')
self.process = QProcess(self)
self.process.setProcessChannelMode(QProcess.SeparateChannels)
self.process.setInputChannelMode(QProcess.ManagedInputChannel)
self.process.readyReadStandardOutput.connect(self.stdoutReady)
self.process.readyReadStandardError.connect(self.stderrReady)
self.process.started.connect(lambda: print('ExampleProgramStarted!'))
self.process.finished.connect(lambda:print('ExampleProgramFinished!'))
print('Starting process')
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(600, 400)
self.win_list=windows()
self.win_list.set_window(self,"contacts")
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"contact.png")))
self.setWindowTitle(_("Edit contacts (www.gpvdm.com)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add contact"), self)
add.triggered.connect(self.on_add_clicked)
toolbar.addAction(add)
remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Remove contacts"), self)
remove.triggered.connect(self.on_remove_clicked)
toolbar.addAction(remove)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.help.setStatusTip(_("Close"))
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(5)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
def __init__(self, parent = None):
super().__init__(parent)
self.mOpacityLabel = QLabel()
self.mOpacitySlider = QSlider(Qt.Horizontal)
self.mLayerView = LayerView()
self.mMapDocument = None
self.mUpdatingSlider = False
self.mChangingLayerOpacity = False
self.mUpdatingSlider = False
self.setObjectName("layerDock")
widget = QWidget(self)
layout = QVBoxLayout(widget)
layout.setContentsMargins(5, 5, 5, 5)
opacityLayout = QHBoxLayout()
self.mOpacitySlider.setRange(0, 100)
self.mOpacitySlider.setEnabled(False)
opacityLayout.addWidget(self.mOpacityLabel)
opacityLayout.addWidget(self.mOpacitySlider)
self.mOpacityLabel.setBuddy(self.mOpacitySlider)
handler = MapDocumentActionHandler.instance()
newLayerMenu = QMenu(self)
newLayerMenu.addAction(handler.actionAddTileLayer())
newLayerMenu.addAction(handler.actionAddObjectGroup())
newLayerMenu.addAction(handler.actionAddImageLayer())
newIcon = QIcon(":/images/16x16/document-new.png")
newLayerButton = QToolButton()
newLayerButton.setPopupMode(QToolButton.InstantPopup)
newLayerButton.setMenu(newLayerMenu)
newLayerButton.setIcon(newIcon)
Utils.setThemeIcon(newLayerButton, "document-new")
buttonContainer = QToolBar()
buttonContainer.setFloatable(False)
buttonContainer.setMovable(False)
buttonContainer.setIconSize(QSize(16, 16))
buttonContainer.addWidget(newLayerButton)
buttonContainer.addAction(handler.actionMoveLayerUp())
buttonContainer.addAction(handler.actionMoveLayerDown())
buttonContainer.addAction(handler.actionDuplicateLayer())
buttonContainer.addAction(handler.actionRemoveLayer())
buttonContainer.addSeparator()
buttonContainer.addAction(handler.actionToggleOtherLayers())
listAndToolBar = QVBoxLayout()
listAndToolBar.setSpacing(0)
listAndToolBar.addWidget(self.mLayerView)
listAndToolBar.addWidget(buttonContainer)
layout.addLayout(opacityLayout)
layout.addLayout(listAndToolBar)
self.setWidget(widget)
self.retranslateUi()
self.mOpacitySlider.valueChanged.connect(self.sliderValueChanged)
self.updateOpacitySlider()
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"jv.png")))
self.setWindowTitle(_("Steady state simulation (www.gpvdm.com)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.help.setStatusTip(_("Close"))
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.notebook = QTabWidget()
self.notebook.setTabsClosable(True)
self.notebook.setMovable(True)
self.main_vbox.addWidget(self.notebook)
files=["jv.inp","jv_simple.inp","sun_voc.inp"]
description=["JV simulation","Diode equation","Suns v.s. Voc"]
for i in range(0,len(files)):
tab=tab_class()
tab.init(files[i],description[i])
self.notebook.addTab(tab,description[i])
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"jv_window")
self.notebook.currentChanged.connect(self.changed_click)
def __init__(self,file_name):
QWidget.__init__(self)
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"jv.png")))
self.setWindowTitle(_("Simulation information (www.gpvdm.com)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.help.setStatusTip(_("Close"))
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.notebook = QTabWidget()
self.notebook.setMovable(True)
self.main_vbox.addWidget(self.notebook)
files=[file_name]
description=["Simulation Information"]
for i in range(0,len(files)):
tab=tab_class()
tab.set_edit(False)
tab.init(files[i],description[i])
self.notebook.addTab(tab,description[i])
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"sim_info_window")
class SessionManager(QMainWindow):
def __init__(self, parent=None):
QListWidget.__init__(self, parent)
self.setWindowTitle(tr("Saved Sessions"))
self.setWindowFlags(Qt.Dialog)
hideAction = QAction(self)
hideAction.setShortcuts(["Esc", "Ctrl+W"])
hideAction.triggered.connect(self.hide)
self.addAction(hideAction)
self.sessionList = QListWidget(self)
self.sessionList.itemActivated.connect(self.loadSession)
self.setCentralWidget(self.sessionList)
self.toolBar = QToolBar(self)
self.toolBar.setMovable(False)
self.toolBar.setContextMenuPolicy(Qt.CustomContextMenu)
self.addToolBar(Qt.BottomToolBarArea, self.toolBar)
self.loadButton = QPushButton(tr("&Load"), self)
self.loadButton.clicked.connect(lambda: self.loadSession(self.sessionList.currentItem()))
self.toolBar.addWidget(self.loadButton)
self.saveButton = QPushButton(tr("&Save"), self)
self.saveButton.clicked.connect(saveSessionManually)
self.saveButton.clicked.connect(self.refresh)
self.toolBar.addWidget(self.saveButton)
deleteAction = QAction(self)
deleteAction.setShortcut("Del")
deleteAction.triggered.connect(self.delete)
self.addAction(deleteAction)
def refresh(self):
self.sessionList.clear()
if os.path.exists(settings.session_folder):
sessions = os.listdir(settings.session_folder)
for session in sessions:
self.sessionList.addItem(session)
def delete(self):
if self.sessionList.hasFocus():
try: os.remove(os.path.join(settings.session_folder, self.sessionList.currentItem().text()))
except: pass
self.refresh()
def show(self):
self.refresh()
QMainWindow.show(self)
def loadSession(self, item):
if os.path.exists(settings.session_folder):
loadSession(os.path.join(settings.session_folder, item.text()))
self.hide()
def init(self):
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"cog.png")))
self.setWindowTitle(_("Configure (www.gpvdm.com)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.undo = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.undo.setStatusTip(_("Close"))
self.undo.triggered.connect(self.callback_help)
toolbar.addAction(self.undo)
self.main_vbox.addWidget(toolbar)
self.notebook = QTabWidget()
self.notebook.setMovable(True)
self.main_vbox.addWidget(self.notebook)
files=["math.inp","dump.inp","thermal.inp","led.inp","config.inp"]
description=["Math","Dump","Thermal","LED","GUI config"]
for i in range(0,len(files)):
tab=tab_class()
tab.init(files[i],description[i])
self.notebook.addTab(tab,description[i])
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"config_window")
class ToolBarAction(QWidgetAction):
def __init__(self, *args, **kwargs):
super(ToolBarAction, self).__init__(*args, **kwargs)
self._toolBar = QToolBar(styleSheet="QToolBar {background: transparent; border: 0;}")
self._toolBar.setIconSize(QSize(16, 16))
self.setDefaultWidget(self._toolBar)
def toolBar(self):
return self._toolBar
def addAction(self, action):
self._toolBar.addAction(action)
if action.shortcut().toString() > "":
action.setToolTip(action.text().replace("&", "") + "<br>" + action.shortcut().toString())
def widgetForAction(self, *args, **kwargs):
return self._toolBar.widgetForAction(*args, **kwargs)
def addWidget(self, *args, **kwargs):
self._toolBar.addWidget(*args, **kwargs)
def addSeparator(self):
self._toolBar.addSeparator()
def make_tool_box1(self):
toolbar=QToolBar()
toolbar.setIconSize(QSize(42, 42))
if enable_betafeatures()==True:
self.qe_button = QAction(QIcon(os.path.join(get_image_file_path(),"qe.png")), _("Quantum efficiency"), self)
self.qe_button.triggered.connect(self.callback_qe_window)
toolbar.addAction(self.qe_button)
self.qe_button.setEnabled(False)
self.sim_mode_button=tb_item_sim_mode()
toolbar.addWidget(self.sim_mode_button)
self.sim_mode_button.setEnabled(False)
self.light_button=tb_item_sun()
toolbar.addWidget(self.light_button)
self.light_button.setEnabled(False)
return toolbar
def __init__(self,index):
QWidget.__init__(self)
self.index=index
self.fig = Figure(figsize=(5,4), dpi=100)
self.ax1=None
self.show_key=True
self.hbox=QVBoxLayout()
self.edit_list=[]
self.line_number=[]
self.list=[]
print("index=",index)
canvas = FigureCanvas(self.fig) # a gtk.DrawingArea
#canvas.set_background('white')
#canvas.set_facecolor('white')
canvas.figure.patch.set_facecolor('white')
#canvas.set_size_request(500, 150)
#canvas.set_size_request(700,400)
self.draw_graph()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save graph"), self)
self.tb_save.triggered.connect(self.callback_save)
toolbar.addAction(self.tb_save)
nav_bar=NavigationToolbar(canvas,self)
toolbar.addWidget(nav_bar)
self.hbox.addWidget(toolbar)
self.hbox.addWidget(canvas)
self.setLayout(self.hbox)
def __init__(self):
QWidget.__init__(self)
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"jv.png")))
self.setWindowTitle(_("Cost and energy payback calculator (BETA - missing realistic data at the moment!!!)"))
self.main_vbox = QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.play = QAction(QIcon(os.path.join(get_image_file_path(),"play.png")), "Re-calcualte", self)
self.play.triggered.connect(self.update)
toolbar.addAction(self.play)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), "Help", self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.tab= QTableWidget()
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"costs_window")
self.update()
def __init__(self):
QWidget.__init__(self)
self.setWindowTitle("Quantum Efficiency calculator - (www.gpvdm.com)")
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"qe.jpg")))
self.fig = Figure(figsize=(5,4), dpi=100)
self.ax1=None
self.show_key=True
self.draw_graph()
canvas = FigureCanvas(self.fig)
#canvas.set_background('white')
#canvas.set_facecolor('white')
canvas.figure.patch.set_facecolor('white')
#canvas.set_size_request(500, 150)
#canvas.show()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save graph"), self)
self.tb_save.triggered.connect(self.callback_save)
toolbar.addAction(self.tb_save)
self.tb_refresh = QAction(QIcon(os.path.join(get_image_file_path(),"play.png")), _("Run"), self)
self.tb_refresh .triggered.connect(self.callback_refresh)
toolbar.addAction(self.tb_refresh )
nav_bar=NavigationToolbar(canvas,self)
toolbar.addWidget(nav_bar)
window_main_vbox=QVBoxLayout()
window_main_vbox.addWidget(toolbar)
window_main_vbox.addWidget(canvas)
self.setLayout(window_main_vbox)
def toolbarWidget(self):
self.brushSizeWidget = BrushSizeWidget(self.brush_size, max_size=70)
self.clearAction = QAction(QIcon("assets/clear.png"), "Clear", self)
self.saveAction = QAction(QIcon("assets/save.png"), "Save", self)
self.removeAction = QAction(QIcon("assets/remove.png"), "Remove", self)
self.previewAction = QAction(QIcon("assets/preview.png"), "Preview", self)
toolbar = QToolBar()
toolbar.setIconSize(QSize(30, 30))
toolbar.addWidget(self.brushSizeWidget)
toolbar.addSeparator()
toolbar.addAction(self.clearAction)
toolbar.addAction(self.saveAction)
toolbar.addAction(self.removeAction)
toolbar.addAction(self.removeAction)
toolbar.addAction(self.previewAction)
toolbar.addSeparator()
toolbar.addWidget(self.sizeWidget())
toolbar.addWidget(self.prefixWidget())
toolbar.addWidget(self.toolbarSpacer())
return toolbar
class ReTextWindow(QMainWindow):
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.resize(950, 700)
screenRect = QDesktopWidget().screenGeometry()
if globalSettings.windowGeometry:
self.restoreGeometry(globalSettings.windowGeometry)
else:
self.move((screenRect.width()-self.width())/2, (screenRect.height()-self.height())/2)
if not screenRect.contains(self.geometry()):
self.showMaximized()
if globalSettings.iconTheme:
QIcon.setThemeName(globalSettings.iconTheme)
if QIcon.themeName() in ('hicolor', ''):
if not QFile.exists(icon_path + 'document-new.png'):
QIcon.setThemeName(get_icon_theme())
if QFile.exists(icon_path+'retext.png'):
self.setWindowIcon(QIcon(icon_path+'retext.png'))
elif QFile.exists('/usr/share/pixmaps/retext.png'):
self.setWindowIcon(QIcon('/usr/share/pixmaps/retext.png'))
else:
self.setWindowIcon(QIcon.fromTheme('retext',
QIcon.fromTheme('accessories-text-editor')))
self.tabWidget = QTabWidget(self)
self.initTabWidget()
self.setCentralWidget(self.tabWidget)
self.tabWidget.currentChanged.connect(self.changeIndex)
self.tabWidget.tabCloseRequested.connect(self.closeTab)
toolBar = QToolBar(self.tr('File toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, toolBar)
self.editBar = QToolBar(self.tr('Edit toolbar'), self)
self.addToolBar(Qt.TopToolBarArea, self.editBar)
self.searchBar = QToolBar(self.tr('Search toolbar'), self)
self.addToolBar(Qt.BottomToolBarArea, self.searchBar)
toolBar.setVisible(not globalSettings.hideToolBar)
self.editBar.setVisible(not globalSettings.hideToolBar)
self.actionNew = self.act(self.tr('New'), 'document-new',
self.createNew, shct=QKeySequence.New)
self.actionNew.setPriority(QAction.LowPriority)
self.actionOpen = self.act(self.tr('Open'), 'document-open',
self.openFile, shct=QKeySequence.Open)
self.actionOpen.setPriority(QAction.LowPriority)
self.actionSetEncoding = self.act(self.tr('Set encoding'),
trig=self.showEncodingDialog)
self.actionSetEncoding.setEnabled(False)
self.actionReload = self.act(self.tr('Reload'), 'view-refresh',
lambda: self.currentTab.readTextFromFile())
self.actionReload.setEnabled(False)
self.actionSave = self.act(self.tr('Save'), 'document-save',
self.saveFile, shct=QKeySequence.Save)
self.actionSave.setEnabled(False)
self.actionSave.setPriority(QAction.LowPriority)
self.actionSaveAs = self.act(self.tr('Save as'), 'document-save-as',
self.saveFileAs, shct=QKeySequence.SaveAs)
self.actionNextTab = self.act(self.tr('Next tab'), 'go-next',
lambda: self.switchTab(1), shct=Qt.CTRL+Qt.Key_PageDown)
self.actionPrevTab = self.act(self.tr('Previous tab'), 'go-previous',
lambda: self.switchTab(-1), shct=Qt.CTRL+Qt.Key_PageUp)
self.actionPrint = self.act(self.tr('Print'), 'document-print',
self.printFile, shct=QKeySequence.Print)
self.actionPrint.setPriority(QAction.LowPriority)
self.actionPrintPreview = self.act(self.tr('Print preview'), 'document-print-preview',
self.printPreview)
self.actionViewHtml = self.act(self.tr('View HTML code'), 'text-html', self.viewHtml)
self.actionChangeEditorFont = self.act(self.tr('Change editor font'),
trig=self.changeEditorFont)
self.actionChangePreviewFont = self.act(self.tr('Change preview font'),
trig=self.changePreviewFont)
self.actionSearch = self.act(self.tr('Find text'), 'edit-find', shct=QKeySequence.Find)
self.actionSearch.setCheckable(True)
self.actionSearch.triggered[bool].connect(self.searchBar.setVisible)
self.searchBar.visibilityChanged.connect(self.searchBarVisibilityChanged)
self.actionPreview = self.act(self.tr('Preview'), shct=Qt.CTRL+Qt.Key_E,
trigbool=self.preview)
if QIcon.hasThemeIcon('document-preview'):
self.actionPreview.setIcon(QIcon.fromTheme('document-preview'))
elif QIcon.hasThemeIcon('preview-file'):
self.actionPreview.setIcon(QIcon.fromTheme('preview-file'))
elif QIcon.hasThemeIcon('x-office-document'):
self.actionPreview.setIcon(QIcon.fromTheme('x-office-document'))
else:
self.actionPreview.setIcon(QIcon(icon_path+'document-preview.png'))
self.actionLivePreview = self.act(self.tr('Live preview'), shct=Qt.CTRL+Qt.Key_L,
trigbool=self.enableLivePreview)
menuPreview = QMenu()
menuPreview.addAction(self.actionLivePreview)
self.actionPreview.setMenu(menuPreview)
self.actionTableMode = self.act(self.tr('Table mode'), shct=Qt.CTRL+Qt.Key_T,
trigbool=lambda x: self.currentTab.editBox.enableTableMode(x))
if ReTextFakeVimHandler:
self.actionFakeVimMode = self.act(self.tr('FakeVim mode'),
shct=Qt.CTRL+Qt.ALT+Qt.Key_V, trigbool=self.enableFakeVimMode)
if globalSettings.useFakeVim:
self.actionFakeVimMode.setChecked(True)
self.enableFakeVimMode(True)
self.actionFullScreen = self.act(self.tr('Fullscreen mode'), 'view-fullscreen',
shct=Qt.Key_F11, trigbool=self.enableFullScreen)
self.actionFullScreen.setPriority(QAction.LowPriority)
self.actionConfig = self.act(self.tr('Preferences'), icon='preferences-system',
trig=self.openConfigDialog)
self.actionConfig.setMenuRole(QAction.PreferencesRole)
self.actionSaveHtml = self.act('HTML', 'text-html', self.saveFileHtml)
self.actionPdf = self.act('PDF', 'application-pdf', self.savePdf)
self.actionOdf = self.act('ODT', 'x-office-document', self.saveOdf)
self.getExportExtensionsList()
self.actionQuit = self.act(self.tr('Quit'), 'application-exit', shct=QKeySequence.Quit)
self.actionQuit.setMenuRole(QAction.QuitRole)
self.actionQuit.triggered.connect(self.close)
self.actionUndo = self.act(self.tr('Undo'), 'edit-undo',
lambda: self.currentTab.editBox.undo(), shct=QKeySequence.Undo)
self.actionRedo = self.act(self.tr('Redo'), 'edit-redo',
lambda: self.currentTab.editBox.redo(), shct=QKeySequence.Redo)
self.actionCopy = self.act(self.tr('Copy'), 'edit-copy',
lambda: self.currentTab.editBox.copy(), shct=QKeySequence.Copy)
self.actionCut = self.act(self.tr('Cut'), 'edit-cut',
lambda: self.currentTab.editBox.cut(), shct=QKeySequence.Cut)
self.actionPaste = self.act(self.tr('Paste'), 'edit-paste',
lambda: self.currentTab.editBox.paste(), shct=QKeySequence.Paste)
self.actionUndo.setEnabled(False)
self.actionRedo.setEnabled(False)
self.actionCopy.setEnabled(False)
self.actionCut.setEnabled(False)
qApp = QApplication.instance()
qApp.clipboard().dataChanged.connect(self.clipboardDataChanged)
self.clipboardDataChanged()
if enchant_available:
self.actionEnableSC = self.act(self.tr('Enable'), trigbool=self.enableSpellCheck)
self.actionSetLocale = self.act(self.tr('Set locale'), trig=self.changeLocale)
self.actionWebKit = self.act(self.tr('Use WebKit renderer'), trigbool=self.enableWebKit)
self.actionWebKit.setChecked(globalSettings.useWebKit)
self.actionShow = self.act(self.tr('Show directory'), 'system-file-manager', self.showInDir)
self.actionFind = self.act(self.tr('Next'), 'go-next', self.find,
shct=QKeySequence.FindNext)
self.actionFindPrev = self.act(self.tr('Previous'), 'go-previous',
lambda: self.find(back=True), shct=QKeySequence.FindPrevious)
self.actionCloseSearch = self.act(self.tr('Close'), 'window-close',
lambda: self.searchBar.setVisible(False))
self.actionCloseSearch.setPriority(QAction.LowPriority)
self.actionHelp = self.act(self.tr('Get help online'), 'help-contents', self.openHelp)
self.aboutWindowTitle = self.tr('About ReText')
self.actionAbout = self.act(self.aboutWindowTitle, 'help-about', self.aboutDialog)
self.actionAbout.setMenuRole(QAction.AboutRole)
self.actionAboutQt = self.act(self.tr('About Qt'))
self.actionAboutQt.setMenuRole(QAction.AboutQtRole)
self.actionAboutQt.triggered.connect(qApp.aboutQt)
availableMarkups = markups.get_available_markups()
if not availableMarkups:
print('Warning: no markups are available!')
self.defaultMarkup = availableMarkups[0] if availableMarkups else None
if globalSettings.defaultMarkup:
mc = markups.find_markup_class_by_name(globalSettings.defaultMarkup)
if mc and mc.available():
self.defaultMarkup = mc
if len(availableMarkups) > 1:
self.chooseGroup = QActionGroup(self)
markupActions = []
for markup in availableMarkups:
markupAction = self.act(markup.name, trigbool=self.markupFunction(markup))
if markup == self.defaultMarkup:
markupAction.setChecked(True)
self.chooseGroup.addAction(markupAction)
markupActions.append(markupAction)
self.actionBold = self.act(self.tr('Bold'), shct=QKeySequence.Bold,
trig=lambda: self.insertFormatting('bold'))
self.actionItalic = self.act(self.tr('Italic'), shct=QKeySequence.Italic,
trig=lambda: self.insertFormatting('italic'))
self.actionUnderline = self.act(self.tr('Underline'), shct=QKeySequence.Underline,
trig=lambda: self.insertFormatting('underline'))
self.usefulTags = ('header', 'italic', 'bold', 'underline', 'numbering',
'bullets', 'image', 'link', 'inline code', 'code block', 'blockquote')
self.usefulChars = ('deg', 'divide', 'dollar', 'hellip', 'laquo', 'larr',
'lsquo', 'mdash', 'middot', 'minus', 'nbsp', 'ndash', 'raquo',
'rarr', 'rsquo', 'times')
self.formattingBox = QComboBox(self.editBar)
self.formattingBox.addItem(self.tr('Formatting'))
self.formattingBox.addItems(self.usefulTags)
self.formattingBox.activated[str].connect(self.insertFormatting)
self.symbolBox = QComboBox(self.editBar)
self.symbolBox.addItem(self.tr('Symbols'))
self.symbolBox.addItems(self.usefulChars)
self.symbolBox.activated.connect(self.insertSymbol)
self.updateStyleSheet()
menubar = self.menuBar()
menuFile = menubar.addMenu(self.tr('File'))
menuEdit = menubar.addMenu(self.tr('Edit'))
menuHelp = menubar.addMenu(self.tr('Help'))
menuFile.addAction(self.actionNew)
menuFile.addAction(self.actionOpen)
self.menuRecentFiles = menuFile.addMenu(self.tr('Open recent'))
self.menuRecentFiles.aboutToShow.connect(self.updateRecentFiles)
menuFile.addAction(self.actionShow)
menuFile.addAction(self.actionSetEncoding)
menuFile.addAction(self.actionReload)
menuFile.addSeparator()
menuFile.addAction(self.actionSave)
menuFile.addAction(self.actionSaveAs)
menuFile.addSeparator()
menuFile.addAction(self.actionNextTab)
menuFile.addAction(self.actionPrevTab)
menuFile.addSeparator()
menuExport = menuFile.addMenu(self.tr('Export'))
menuExport.addAction(self.actionSaveHtml)
menuExport.addAction(self.actionOdf)
menuExport.addAction(self.actionPdf)
if self.extensionActions:
menuExport.addSeparator()
for action, mimetype in self.extensionActions:
menuExport.addAction(action)
menuExport.aboutToShow.connect(self.updateExtensionsVisibility)
menuFile.addAction(self.actionPrint)
menuFile.addAction(self.actionPrintPreview)
menuFile.addSeparator()
menuFile.addAction(self.actionQuit)
menuEdit.addAction(self.actionUndo)
menuEdit.addAction(self.actionRedo)
menuEdit.addSeparator()
menuEdit.addAction(self.actionCut)
menuEdit.addAction(self.actionCopy)
menuEdit.addAction(self.actionPaste)
menuEdit.addSeparator()
if enchant_available:
menuSC = menuEdit.addMenu(self.tr('Spell check'))
menuSC.addAction(self.actionEnableSC)
menuSC.addAction(self.actionSetLocale)
menuEdit.addAction(self.actionSearch)
menuEdit.addAction(self.actionChangeEditorFont)
menuEdit.addAction(self.actionChangePreviewFont)
menuEdit.addSeparator()
if len(availableMarkups) > 1:
self.menuMode = menuEdit.addMenu(self.tr('Default markup'))
for markupAction in markupActions:
self.menuMode.addAction(markupAction)
menuFormat = menuEdit.addMenu(self.tr('Formatting'))
menuFormat.addAction(self.actionBold)
menuFormat.addAction(self.actionItalic)
menuFormat.addAction(self.actionUnderline)
menuEdit.addAction(self.actionWebKit)
menuEdit.addSeparator()
menuEdit.addAction(self.actionViewHtml)
menuEdit.addAction(self.actionPreview)
menuEdit.addAction(self.actionTableMode)
if ReTextFakeVimHandler:
menuEdit.addAction(self.actionFakeVimMode)
menuEdit.addSeparator()
menuEdit.addAction(self.actionFullScreen)
menuEdit.addAction(self.actionConfig)
menuHelp.addAction(self.actionHelp)
menuHelp.addSeparator()
menuHelp.addAction(self.actionAbout)
menuHelp.addAction(self.actionAboutQt)
toolBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
toolBar.addAction(self.actionNew)
toolBar.addSeparator()
toolBar.addAction(self.actionOpen)
toolBar.addAction(self.actionSave)
toolBar.addAction(self.actionPrint)
toolBar.addSeparator()
toolBar.addAction(self.actionPreview)
toolBar.addAction(self.actionFullScreen)
self.editBar.addAction(self.actionUndo)
self.editBar.addAction(self.actionRedo)
self.editBar.addSeparator()
self.editBar.addAction(self.actionCut)
self.editBar.addAction(self.actionCopy)
self.editBar.addAction(self.actionPaste)
self.editBar.addSeparator()
self.editBar.addWidget(self.formattingBox)
self.editBar.addWidget(self.symbolBox)
self.searchEdit = QLineEdit(self.searchBar)
self.searchEdit.setPlaceholderText(self.tr('Search'))
self.searchEdit.returnPressed.connect(self.find)
self.csBox = QCheckBox(self.tr('Case sensitively'), self.searchBar)
self.searchBar.addWidget(self.searchEdit)
self.searchBar.addSeparator()
self.searchBar.addWidget(self.csBox)
self.searchBar.addAction(self.actionFindPrev)
self.searchBar.addAction(self.actionFind)
self.searchBar.addAction(self.actionCloseSearch)
self.searchBar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.searchBar.setVisible(False)
self.autoSaveEnabled = globalSettings.autoSave
if self.autoSaveEnabled:
timer = QTimer(self)
timer.start(60000)
timer.timeout.connect(self.saveAll)
self.ind = None
if enchant_available:
self.sl = globalSettings.spellCheckLocale
if self.sl:
try:
enchant.Dict(self.sl)
except Exception as e:
print(e, file=sys.stderr)
self.sl = None
if globalSettings.spellCheck:
self.actionEnableSC.setChecked(True)
self.fileSystemWatcher = QFileSystemWatcher()
self.fileSystemWatcher.fileChanged.connect(self.fileChanged)
def iterateTabs(self):
for i in range(self.tabWidget.count()):
yield self.tabWidget.widget(i).tab
def updateStyleSheet(self):
if globalSettings.styleSheet:
sheetfile = QFile(globalSettings.styleSheet)
sheetfile.open(QIODevice.ReadOnly)
self.ss = QTextStream(sheetfile).readAll()
sheetfile.close()
else:
palette = QApplication.palette()
self.ss = 'html { color: %s; }\n' % palette.color(QPalette.WindowText).name()
self.ss += 'td, th { border: 1px solid #c3c3c3; padding: 0 3px 0 3px; }\n'
self.ss += 'table { border-collapse: collapse; }\n'
def initTabWidget(self):
def dragEnterEvent(e):
e.acceptProposedAction()
def dropEvent(e):
fn = bytes(e.mimeData().data('text/plain')).decode().rstrip()
if fn.startswith('file:'):
fn = QUrl(fn).toLocalFile()
self.openFileWrapper(fn)
self.tabWidget.setTabsClosable(True)
self.tabWidget.setAcceptDrops(True)
self.tabWidget.setMovable(True)
self.tabWidget.dragEnterEvent = dragEnterEvent
self.tabWidget.dropEvent = dropEvent
def act(self, name, icon=None, trig=None, trigbool=None, shct=None):
if not isinstance(shct, QKeySequence):
shct = QKeySequence(shct)
if icon:
action = QAction(self.actIcon(icon), name, self)
else:
action = QAction(name, self)
if trig:
action.triggered.connect(trig)
elif trigbool:
action.setCheckable(True)
action.triggered[bool].connect(trigbool)
if shct:
action.setShortcut(shct)
return action
def actIcon(self, name):
return QIcon.fromTheme(name, QIcon(icon_path+name+'.png'))
def printError(self):
import traceback
print('Exception occured while parsing document:', file=sys.stderr)
traceback.print_exc()
def createTab(self, fileName):
self.currentTab = ReTextTab(self, fileName,
previewState=int(globalSettings.livePreviewByDefault))
self.tabWidget.addTab(self.currentTab.getSplitter(), self.tr("New document"))
def closeTab(self, ind):
if self.maybeSave(ind):
if self.tabWidget.count() == 1:
self.createTab("")
currentWidget = self.tabWidget.widget(ind)
if currentWidget.tab.fileName:
self.fileSystemWatcher.removePath(currentWidget.tab.fileName)
del currentWidget.tab
self.tabWidget.removeTab(ind)
def docTypeChanged(self):
markupClass = self.currentTab.getMarkupClass()
if type(self.currentTab.markup) != markupClass:
self.currentTab.setMarkupClass(markupClass)
self.currentTab.updatePreviewBox()
dtMarkdown = (markupClass == markups.MarkdownMarkup)
dtMkdOrReST = dtMarkdown or (markupClass == markups.ReStructuredTextMarkup)
self.formattingBox.setEnabled(dtMarkdown)
self.symbolBox.setEnabled(dtMarkdown)
self.actionUnderline.setEnabled(dtMarkdown)
self.actionBold.setEnabled(dtMkdOrReST)
self.actionItalic.setEnabled(dtMkdOrReST)
canReload = bool(self.currentTab.fileName) and not self.autoSaveActive()
self.actionSetEncoding.setEnabled(canReload)
self.actionReload.setEnabled(canReload)
def changeIndex(self, ind):
self.currentTab = self.tabWidget.currentWidget().tab
editBox = self.currentTab.editBox
previewState = self.currentTab.previewState
self.actionUndo.setEnabled(editBox.document().isUndoAvailable())
self.actionRedo.setEnabled(editBox.document().isRedoAvailable())
self.actionCopy.setEnabled(editBox.textCursor().hasSelection())
self.actionCut.setEnabled(editBox.textCursor().hasSelection())
self.actionPreview.setChecked(previewState >= PreviewLive)
self.actionLivePreview.setChecked(previewState == PreviewLive)
self.actionTableMode.setChecked(editBox.tableModeEnabled)
self.editBar.setEnabled(previewState < PreviewNormal)
self.ind = ind
if self.currentTab.fileName:
self.setCurrentFile()
else:
self.setWindowTitle(self.tr('New document') + '[*]')
self.docTypeChanged()
self.modificationChanged(editBox.document().isModified())
editBox.setFocus(Qt.OtherFocusReason)
def changeEditorFont(self):
font, ok = QFontDialog.getFont(globalSettings.editorFont, self)
if ok:
globalSettings.editorFont = font
for tab in self.iterateTabs():
tab.editBox.updateFont()
def changePreviewFont(self):
font, ok = QFontDialog.getFont(globalSettings.font, self)
if ok:
globalSettings.font = font
for tab in self.iterateTabs():
tab.updatePreviewBox()
def preview(self, viewmode):
self.currentTab.previewState = viewmode * 2
self.actionLivePreview.setChecked(False)
self.editBar.setDisabled(viewmode)
self.currentTab.updateBoxesVisibility()
if viewmode:
self.currentTab.updatePreviewBox()
def enableLivePreview(self, livemode):
self.currentTab.previewState = int(livemode)
self.actionPreview.setChecked(livemode)
self.editBar.setEnabled(True)
self.currentTab.updateBoxesVisibility()
if livemode:
self.currentTab.updatePreviewBox()
def enableWebKit(self, enable):
globalSettings.useWebKit = enable
for i in range(self.tabWidget.count()):
splitter = self.tabWidget.widget(i)
tab = splitter.tab
tab.previewBox.disconnectExternalSignals()
tab.previewBox.setParent(None)
tab.previewBox.deleteLater()
tab.previewBox = tab.createPreviewBox(tab.editBox)
tab.previewBox.setMinimumWidth(125)
splitter.addWidget(tab.previewBox)
splitter.setSizes((50, 50))
tab.updatePreviewBox()
tab.updateBoxesVisibility()
def enableCopy(self, copymode):
self.actionCopy.setEnabled(copymode)
self.actionCut.setEnabled(copymode)
def enableFullScreen(self, yes):
if yes:
self.showFullScreen()
else:
self.showNormal()
def openConfigDialog(self):
dlg = ConfigDialog(self)
dlg.setWindowTitle(self.tr('Preferences'))
dlg.show()
def enableFakeVimMode(self, yes):
globalSettings.useFakeVim = yes
if yes:
FakeVimMode.init(self)
for tab in self.iterateTabs():
tab.installFakeVimHandler()
else:
FakeVimMode.exit(self)
def enableSpellCheck(self, yes):
if yes:
self.setAllDictionaries(enchant.Dict(self.sl or None))
else:
self.setAllDictionaries(None)
globalSettings.spellCheck = yes
def setAllDictionaries(self, dictionary):
for tab in self.iterateTabs():
hl = tab.highlighter
hl.dictionary = dictionary
hl.rehighlight()
def changeLocale(self):
if self.sl:
localedlg = LocaleDialog(self, defaultText=self.sl)
else:
localedlg = LocaleDialog(self)
if localedlg.exec() != QDialog.Accepted:
return
sl = localedlg.localeEdit.text()
setdefault = localedlg.checkBox.isChecked()
if sl:
try:
sl = str(sl)
enchant.Dict(sl)
except Exception as e:
QMessageBox.warning(self, '', str(e))
else:
self.sl = sl
self.enableSpellCheck(self.actionEnableSC.isChecked())
else:
self.sl = None
self.enableSpellCheck(self.actionEnableSC.isChecked())
if setdefault:
globalSettings.spellCheckLocale = sl
def searchBarVisibilityChanged(self, visible):
self.actionSearch.setChecked(visible)
if visible:
self.searchEdit.setFocus(Qt.ShortcutFocusReason)
def find(self, back=False):
flags = QTextDocument.FindFlags()
if back:
flags |= QTextDocument.FindBackward
if self.csBox.isChecked():
flags |= QTextDocument.FindCaseSensitively
text = self.searchEdit.text()
editBox = self.currentTab.editBox
cursor = editBox.textCursor()
newCursor = editBox.document().find(text, cursor, flags)
if not newCursor.isNull():
editBox.setTextCursor(newCursor)
return self.setSearchEditColor(True)
cursor.movePosition(QTextCursor.End if back else QTextCursor.Start)
newCursor = editBox.document().find(text, cursor, flags)
if not newCursor.isNull():
editBox.setTextCursor(newCursor)
return self.setSearchEditColor(True)
self.setSearchEditColor(False)
def setSearchEditColor(self, found):
palette = self.searchEdit.palette()
palette.setColor(QPalette.Active, QPalette.Base,
Qt.white if found else QColor(255, 102, 102))
self.searchEdit.setPalette(palette)
def showInDir(self):
if self.currentTab.fileName:
path = QFileInfo(self.currentTab.fileName).path()
QDesktopServices.openUrl(QUrl.fromLocalFile(path))
else:
QMessageBox.warning(self, '', self.tr("Please, save the file somewhere."))
def setCurrentFile(self):
self.setWindowTitle("")
self.tabWidget.setTabText(self.ind, self.currentTab.getDocumentTitle(baseName=True))
self.tabWidget.setTabToolTip(self.ind, self.currentTab.fileName or '')
self.setWindowFilePath(self.currentTab.fileName)
files = readListFromSettings("recentFileList")
while self.currentTab.fileName in files:
files.remove(self.currentTab.fileName)
files.insert(0, self.currentTab.fileName)
if len(files) > 10:
del files[10:]
writeListToSettings("recentFileList", files)
QDir.setCurrent(QFileInfo(self.currentTab.fileName).dir().path())
self.docTypeChanged()
def createNew(self, text=None):
self.createTab("")
self.ind = self.tabWidget.count()-1
self.tabWidget.setCurrentIndex(self.ind)
if text:
self.currentTab.editBox.textCursor().insertText(text)
def switchTab(self, shift=1):
self.tabWidget.setCurrentIndex((self.ind + shift) % self.tabWidget.count())
def updateRecentFiles(self):
self.menuRecentFiles.clear()
self.recentFilesActions = []
filesOld = readListFromSettings("recentFileList")
files = []
for f in filesOld:
if QFile.exists(f):
files.append(f)
self.recentFilesActions.append(self.act(f, trig=self.openFunction(f)))
writeListToSettings("recentFileList", files)
for action in self.recentFilesActions:
self.menuRecentFiles.addAction(action)
def markupFunction(self, markup):
return lambda: self.setDefaultMarkup(markup)
def openFunction(self, fileName):
return lambda: self.openFileWrapper(fileName)
def extensionFunction(self, data):
return lambda: \
self.runExtensionCommand(data['Exec'], data['FileFilter'], data['DefaultExtension'])
def getExportExtensionsList(self):
extensions = []
for extsprefix in datadirs:
extsdir = QDir(extsprefix+'/export-extensions/')
if extsdir.exists():
for fileInfo in extsdir.entryInfoList(['*.desktop', '*.ini'],
QDir.Files | QDir.Readable):
extensions.append(self.readExtension(fileInfo.filePath()))
locale = QLocale.system().name()
self.extensionActions = []
for extension in extensions:
try:
if ('Name[%s]' % locale) in extension:
name = extension['Name[%s]' % locale]
elif ('Name[%s]' % locale.split('_')[0]) in extension:
name = extension['Name[%s]' % locale.split('_')[0]]
else:
name = extension['Name']
data = {}
for prop in ('FileFilter', 'DefaultExtension', 'Exec'):
if 'X-ReText-'+prop in extension:
data[prop] = extension['X-ReText-'+prop]
elif prop in extension:
data[prop] = extension[prop]
else:
data[prop] = ''
action = self.act(name, trig=self.extensionFunction(data))
if 'Icon' in extension:
action.setIcon(self.actIcon(extension['Icon']))
mimetype = extension['MimeType'] if 'MimeType' in extension else None
except KeyError:
print('Failed to parse extension: Name is required', file=sys.stderr)
else:
self.extensionActions.append((action, mimetype))
def updateExtensionsVisibility(self):
markupClass = self.currentTab.getMarkupClass()
for action in self.extensionActions:
if markupClass is None:
action[0].setEnabled(False)
continue
mimetype = action[1]
if mimetype == None:
enabled = True
elif markupClass == markups.MarkdownMarkup:
enabled = (mimetype in ("text/x-retext-markdown", "text/x-markdown"))
elif markupClass == markups.ReStructuredTextMarkup:
enabled = (mimetype in ("text/x-retext-rst", "text/x-rst"))
else:
enabled = False
action[0].setEnabled(enabled)
def readExtension(self, fileName):
extFile = QFile(fileName)
extFile.open(QIODevice.ReadOnly)
extension = {}
stream = QTextStream(extFile)
while not stream.atEnd():
line = stream.readLine()
if '=' in line:
index = line.index('=')
extension[line[:index].rstrip()] = line[index+1:].lstrip()
extFile.close()
return extension
def openFile(self):
supportedExtensions = ['.txt']
for markup in markups.get_all_markups():
supportedExtensions += markup.file_extensions
fileFilter = ' (' + str.join(' ', ['*'+ext for ext in supportedExtensions]) + ');;'
fileNames = QFileDialog.getOpenFileNames(self,
self.tr("Select one or several files to open"), "",
self.tr("Supported files") + fileFilter + self.tr("All files (*)"))
for fileName in fileNames[0]:
self.openFileWrapper(fileName)
def openFileWrapper(self, fileName):
if not fileName:
return
fileName = QFileInfo(fileName).canonicalFilePath()
exists = False
for i, tab in enumerate(self.iterateTabs()):
if tab.fileName == fileName:
exists = True
ex = i
if exists:
self.tabWidget.setCurrentIndex(ex)
elif QFile.exists(fileName):
noEmptyTab = (
(self.ind is None) or
self.currentTab.fileName or
self.currentTab.editBox.toPlainText() or
self.currentTab.editBox.document().isModified()
)
if noEmptyTab:
self.createTab(fileName)
self.ind = self.tabWidget.count()-1
self.tabWidget.setCurrentIndex(self.ind)
if fileName:
self.fileSystemWatcher.addPath(fileName)
self.currentTab.fileName = fileName
self.currentTab.readTextFromFile()
editBox = self.currentTab.editBox
self.setCurrentFile()
self.setWindowModified(editBox.document().isModified())
def showEncodingDialog(self):
if not self.maybeSave(self.ind):
return
encoding, ok = QInputDialog.getItem(self, '',
self.tr('Select file encoding from the list:'),
[bytes(b).decode() for b in QTextCodec.availableCodecs()],
0, False)
if ok:
self.currentTab.readTextFromFile(encoding)
def saveFile(self):
self.saveFileMain(dlg=False)
def saveFileAs(self):
self.saveFileMain(dlg=True)
def saveAll(self):
for tab in self.iterateTabs():
if tab.fileName and QFileInfo(tab.fileName).isWritable():
tab.saveTextToFile()
tab.editBox.document().setModified(False)
def saveFileMain(self, dlg):
if (not self.currentTab.fileName) or dlg:
markupClass = self.currentTab.getMarkupClass()
if (markupClass is None) or not hasattr(markupClass, 'default_extension'):
defaultExt = self.tr("Plain text (*.txt)")
ext = ".txt"
else:
defaultExt = self.tr('%s files',
'Example of final string: Markdown files') \
% markupClass.name + ' (' + str.join(' ',
('*'+extension for extension in markupClass.file_extensions)) + ')'
if markupClass == markups.MarkdownMarkup:
ext = globalSettings.markdownDefaultFileExtension
elif markupClass == markups.ReStructuredTextMarkup:
ext = globalSettings.restDefaultFileExtension
else:
ext = markupClass.default_extension
newFileName = QFileDialog.getSaveFileName(self,
self.tr("Save file"), "", defaultExt)[0]
if newFileName:
if not QFileInfo(newFileName).suffix():
newFileName += ext
if self.currentTab.fileName:
self.fileSystemWatcher.removePath(self.currentTab.fileName)
self.currentTab.fileName = newFileName
self.actionSetEncoding.setDisabled(self.autoSaveActive())
if self.currentTab.fileName:
if self.currentTab.saveTextToFile():
self.setCurrentFile()
self.currentTab.editBox.document().setModified(False)
self.setWindowModified(False)
return True
else:
QMessageBox.warning(self, '',
self.tr("Cannot save to file because it is read-only!"))
return False
def saveHtml(self, fileName):
if not QFileInfo(fileName).suffix():
fileName += ".html"
try:
htmltext = self.currentTab.getHtml(includeStyleSheet=False,
webenv=True)
except Exception:
return self.printError()
htmlFile = QFile(fileName)
htmlFile.open(QIODevice.WriteOnly)
html = QTextStream(htmlFile)
if globalSettings.defaultCodec:
html.setCodec(globalSettings.defaultCodec)
html << htmltext
htmlFile.close()
def textDocument(self):
td = QTextDocument()
td.setMetaInformation(QTextDocument.DocumentTitle,
self.currentTab.getDocumentTitle())
if self.ss:
td.setDefaultStyleSheet(self.ss)
td.setHtml(self.currentTab.getHtml())
td.setDefaultFont(globalSettings.font)
return td
def saveOdf(self):
try:
document = self.textDocument()
except Exception:
return self.printError()
fileName = QFileDialog.getSaveFileName(self,
self.tr("Export document to ODT"), "",
self.tr("OpenDocument text files (*.odt)"))[0]
if not QFileInfo(fileName).suffix():
fileName += ".odt"
writer = QTextDocumentWriter(fileName)
writer.setFormat(b"odf")
writer.write(document)
def saveFileHtml(self):
fileName = QFileDialog.getSaveFileName(self,
self.tr("Save file"), "",
self.tr("HTML files (*.html *.htm)"))[0]
if fileName:
self.saveHtml(fileName)
def getDocumentForPrint(self):
if globalSettings.useWebKit:
return self.currentTab.previewBox
try:
return self.textDocument()
except Exception:
self.printError()
def standardPrinter(self):
printer = QPrinter(QPrinter.HighResolution)
printer.setDocName(self.currentTab.getDocumentTitle())
printer.setCreator('ReText %s' % app_version)
return printer
def savePdf(self):
self.currentTab.updatePreviewBox()
fileName = QFileDialog.getSaveFileName(self,
self.tr("Export document to PDF"),
"", self.tr("PDF files (*.pdf)"))[0]
if fileName:
if not QFileInfo(fileName).suffix():
fileName += ".pdf"
printer = self.standardPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOutputFileName(fileName)
document = self.getDocumentForPrint()
if document != None:
document.print(printer)
def printFile(self):
self.currentTab.updatePreviewBox()
printer = self.standardPrinter()
dlg = QPrintDialog(printer, self)
dlg.setWindowTitle(self.tr("Print document"))
if (dlg.exec() == QDialog.Accepted):
document = self.getDocumentForPrint()
if document != None:
document.print(printer)
def printPreview(self):
document = self.getDocumentForPrint()
if document == None:
return
printer = self.standardPrinter()
preview = QPrintPreviewDialog(printer, self)
preview.paintRequested.connect(document.print)
preview.exec()
def runExtensionCommand(self, command, filefilter, defaultext):
of = ('%of' in command)
html = ('%html' in command)
if of:
if defaultext and not filefilter:
filefilter = '*'+defaultext
fileName = QFileDialog.getSaveFileName(self,
self.tr('Export document'), '', filefilter)[0]
if not fileName:
return
if defaultext and not QFileInfo(fileName).suffix():
fileName += defaultext
basename = '.%s.retext-temp' % self.currentTab.getDocumentTitle(baseName=True)
if html:
tmpname = basename+'.html'
self.saveHtml(tmpname)
else:
tmpname = basename + self.currentTab.getMarkupClass().default_extension
self.currentTab.saveTextToFile(fileName=tmpname, addToWatcher=False)
command = command.replace('%of', '"out'+defaultext+'"')
command = command.replace('%html' if html else '%if', '"'+tmpname+'"')
try:
Popen(str(command), shell=True).wait()
except Exception as error:
errorstr = str(error)
QMessageBox.warning(self, '', self.tr('Failed to execute the command:')
+ '\n' + errorstr)
QFile(tmpname).remove()
if of:
QFile('out'+defaultext).rename(fileName)
def autoSaveActive(self, ind=None):
tab = self.currentTab if ind is None else self.tabWidget.widget(ind).tab
return (self.autoSaveEnabled and tab.fileName and
QFileInfo(tab.fileName).isWritable())
def modificationChanged(self, changed):
if self.autoSaveActive():
changed = False
self.actionSave.setEnabled(changed)
self.setWindowModified(changed)
def clipboardDataChanged(self):
mimeData = QApplication.instance().clipboard().mimeData()
if mimeData is not None:
self.actionPaste.setEnabled(mimeData.hasText())
def insertFormatting(self, formatting):
cursor = self.currentTab.editBox.textCursor()
text = cursor.selectedText()
moveCursorTo = None
def c(cursor):
nonlocal moveCursorTo
moveCursorTo = cursor.position()
def ensurenl(cursor):
if not cursor.atBlockStart():
cursor.insertText('\n\n')
toinsert = {
'header': (ensurenl, '# ', text),
'italic': ('*', text, c, '*'),
'bold': ('**', text, c, '**'),
'underline': ('<u>', text, c, '</u>'),
'numbering': (ensurenl, ' 1. ', text),
'bullets': (ensurenl, ' * ', text),
'image': (', ')'),
'link': ('[', text or self.tr('Link text'), c, '](', self.tr('URL'), ')'),
'inline code': ('`', text, c, '`'),
'code block': (ensurenl, ' ', text),
'blockquote': (ensurenl, '> ', text),
}
if formatting not in toinsert:
return
cursor.beginEditBlock()
for token in toinsert[formatting]:
if callable(token):
token(cursor)
else:
cursor.insertText(token)
cursor.endEditBlock()
self.formattingBox.setCurrentIndex(0)
# Bring back the focus on the editor
self.currentTab.editBox.setFocus(Qt.OtherFocusReason)
if moveCursorTo:
cursor.setPosition(moveCursorTo)
self.currentTab.editBox.setTextCursor(cursor)
def insertSymbol(self, num):
if num:
self.currentTab.editBox.insertPlainText('&'+self.usefulChars[num-1]+';')
self.symbolBox.setCurrentIndex(0)
def fileChanged(self, fileName):
ind = None
for testind, tab in enumerate(self.iterateTabs()):
if tab.fileName == fileName:
ind = testind
if ind is None:
self.fileSystemWatcher.removePath(fileName)
self.tabWidget.setCurrentIndex(ind)
if not QFile.exists(fileName):
self.currentTab.editBox.document().setModified(True)
QMessageBox.warning(self, '', self.tr(
'This file has been deleted by other application.\n'
'Please make sure you save the file before exit.'))
elif not self.currentTab.editBox.document().isModified():
# File was not modified in ReText, reload silently
self.currentTab.readTextFromFile()
self.currentTab.updatePreviewBox()
else:
text = self.tr(
'This document has been modified by other application.\n'
'Do you want to reload the file (this will discard all '
'your changes)?\n')
if self.autoSaveEnabled:
text += self.tr(
'If you choose to not reload the file, auto save mode will '
'be disabled for this session to prevent data loss.')
messageBox = QMessageBox(QMessageBox.Warning, '', text)
reloadButton = messageBox.addButton(self.tr('Reload'), QMessageBox.YesRole)
messageBox.addButton(QMessageBox.Cancel)
messageBox.exec()
if messageBox.clickedButton() is reloadButton:
self.currentTab.readTextFromFile()
self.currentTab.updatePreviewBox()
else:
self.autoSaveEnabled = False
self.currentTab.editBox.document().setModified(True)
if fileName not in self.fileSystemWatcher.files():
# https://github.com/retext-project/retext/issues/137
self.fileSystemWatcher.addPath(fileName)
def maybeSave(self, ind):
tab = self.tabWidget.widget(ind).tab
if self.autoSaveActive(ind):
tab.saveTextToFile()
return True
if not tab.editBox.document().isModified():
return True
self.tabWidget.setCurrentIndex(ind)
ret = QMessageBox.warning(self, '',
self.tr("The document has been modified.\nDo you want to save your changes?"),
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel)
if ret == QMessageBox.Save:
return self.saveFileMain(False)
elif ret == QMessageBox.Cancel:
return False
return True
def closeEvent(self, closeevent):
for ind in range(self.tabWidget.count()):
if not self.maybeSave(ind):
return closeevent.ignore()
if globalSettings.saveWindowGeometry and not self.isMaximized():
globalSettings.windowGeometry = self.saveGeometry()
closeevent.accept()
def viewHtml(self):
htmlDlg = HtmlDialog(self)
try:
htmltext = self.currentTab.getHtml(includeStyleSheet=False)
except Exception:
return self.printError()
winTitle = self.currentTab.getDocumentTitle(baseName=True)
htmlDlg.setWindowTitle(winTitle+" ("+self.tr("HTML code")+")")
htmlDlg.textEdit.setPlainText(htmltext.rstrip())
htmlDlg.hl.rehighlight()
htmlDlg.show()
htmlDlg.raise_()
htmlDlg.activateWindow()
def openHelp(self):
QDesktopServices.openUrl(QUrl('https://github.com/retext-project/retext/wiki'))
def aboutDialog(self):
QMessageBox.about(self, self.aboutWindowTitle,
'<p><b>' + (self.tr('ReText %s (using PyMarkups %s)') % (app_version, markups.__version__))
+'</b></p>' + self.tr('Simple but powerful editor'
' for Markdown and reStructuredText')
+'</p><p>'+self.tr('Author: Dmitry Shachnev, 2011').replace('2011', '2011–2016')
+'<br><a href="https://github.com/retext-project/retext">'+self.tr('Website')
+'</a> | <a href="http://daringfireball.net/projects/markdown/syntax">'
+self.tr('Markdown syntax')
+'</a> | <a href="http://docutils.sourceforge.net/docs/user/rst/quickref.html">'
+self.tr('reStructuredText syntax')+'</a></p>')
def setDefaultMarkup(self, markupClass):
self.defaultMarkup = markupClass
defaultName = markups.get_available_markups()[0].name
writeToSettings('defaultMarkup', markupClass.name, defaultName)
for tab in self.iterateTabs():
if not tab.fileName:
tab.setMarkupClass(markupClass)
tab.updatePreviewBox()
self.docTypeChanged()
class AppWindow(QMainWindow):
"The application's main window"
def __init__(self):
super().__init__()
self.center = QWidget()
self.display = QStackedLayout()
self.center.setLayout(self.display)
# init the manga view variables
self.manga_display()
# init the chapter view variables
self.chapter_display()
# init toolbar
self.init_toolbar()
# init status bar
self.init_stat_bar()
self.display.addWidget(self.manga_main)
self.display.addWidget(self.chapter_main)
self.setCentralWidget(self.center)
self.setWindowTitle("Happypanda")
self.resize(1029, 650)
self.show()
def init_stat_bar(self):
self.status_bar = self.statusBar()
self.status_bar.setMaximumHeight(20)
self.status_bar.setSizeGripEnabled(False)
self.stat_info = QLabel()
self.stat_info.setIndent(5)
self.sort_main = QAction("Asc", self)
sort_menu = QMenu()
self.sort_main.setMenu(sort_menu)
s_by_title = QAction("Title", sort_menu)
s_by_artist = QAction("Artist", sort_menu)
sort_menu.addAction(s_by_title)
sort_menu.addAction(s_by_artist)
self.status_bar.addPermanentWidget(self.stat_info)
#self.status_bar.addAction(self.sort_main)
self.temp_msg = QLabel()
self.temp_timer = QTimer()
self.manga_list_view.series_model.ROWCOUNT_CHANGE.connect(self.stat_row_info)
self.manga_list_view.series_model.STATUSBAR_MSG.connect(self.stat_temp_msg)
def stat_temp_msg(self, msg):
self.temp_timer.stop()
self.temp_msg.setText(msg)
self.status_bar.addWidget(self.temp_msg)
self.temp_timer.timeout.connect(self.temp_msg.clear)
self.temp_timer.setSingleShot(True)
self.temp_timer.start(5000)
def stat_row_info(self):
r = self.manga_list_view.series_model.rowCount()
t = len(self.manga_list_view.series_model._data)
self.stat_info.setText("<b>Showing {} of {} </b>".format(r, t))
def manga_display(self):
"initiates the manga view"
self.manga_main = QWidget()
self.manga_main.setContentsMargins(-10, -12, -10, -10)
self.manga_view = QHBoxLayout()
self.manga_main.setLayout(self.manga_view)
manga_delegate = series.CustomDelegate()
manga_delegate.BUTTON_CLICKED.connect(self.setCurrentIndex)
self.manga_list_view = series.MangaView()
self.manga_list_view.setItemDelegate(manga_delegate)
self.manga_view.addWidget(self.manga_list_view)
def favourite_display(self):
"initiates favourite display"
pass
def chapter_display(self):
"Initiates chapter view"
self.chapter_main = QWidget()
self.chapter_main.setObjectName("chapter_main") # to allow styling this object
self.chapter_layout = QHBoxLayout()
self.chapter_main.setLayout(self.chapter_layout)
#self.chapter_info.setContentsMargins(-8,-7,-7,-7)
#self.chapter_info.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
self.chapter_info_view = series.ChapterInfo()
self.chapter_layout.addWidget(self.chapter_info_view)
chapter_list_view = series.ChapterView()
self.chapter_layout.addWidget(chapter_list_view)
#self.chapter.setCollapsible(0, True)
#self.chapter.setCollapsible(1, False)
def init_toolbar(self):
self.toolbar = QToolBar()
self.toolbar.setFixedHeight(30)
self.toolbar.setWindowTitle("Show") # text for the contextmenu
#self.toolbar.setStyleSheet("QToolBar {border:0px}") # make it user defined?
self.toolbar.setMovable(False)
self.toolbar.setFloatable(False)
#self.toolbar.setIconSize(QSize(20,20))
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
spacer_start = QWidget() # aligns the first actions properly
spacer_start.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_start)
favourite_view_icon = QIcon(gui_constants.STAR_BTN_PATH)
favourite_view_action = QAction(favourite_view_icon, "Favourite", self)
#favourite_view_action.setText("Manga View")
favourite_view_action.triggered.connect(lambda: self.setCurrentIndex(1)) #need lambda to pass extra args
self.toolbar.addAction(favourite_view_action)
catalog_view_icon = QIcon(gui_constants.HOME_BTN_PATH)
catalog_view_action = QAction(catalog_view_icon, "Library", self)
#catalog_view_action.setText("Catalog")
catalog_view_action.triggered.connect(lambda: self.setCurrentIndex(0)) #need lambda to pass extra args
self.toolbar.addAction(catalog_view_action)
self.toolbar.addSeparator()
series_icon = QIcon(gui_constants.PLUS_PATH)
series_action = QAction(series_icon, "Add series...", self)
series_action.triggered.connect(self.manga_list_view.SERIES_DIALOG.emit)
series_menu = QMenu()
series_menu.addSeparator()
populate_action = QAction("Populate from folder...", self)
populate_action.triggered.connect(self.populate)
series_menu.addAction(populate_action)
series_action.setMenu(series_menu)
self.toolbar.addAction(series_action)
spacer_middle = QWidget() # aligns buttons to the right
spacer_middle.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer_middle)
self.search_bar = QLineEdit()
self.search_bar.setPlaceholderText("Search title, artist, genres")
self.search_bar.setMaximumWidth(200)
self.toolbar.addWidget(self.search_bar)
self.toolbar.addSeparator()
settings_icon = QIcon(gui_constants.SETTINGS_PATH)
settings_action = QAction(settings_icon, "Set&tings", self)
self.toolbar.addAction(settings_action)
self.addToolBar(self.toolbar)
spacer_end = QWidget() # aligns About action properly
spacer_end.setFixedSize(QSize(10, 1))
self.toolbar.addWidget(spacer_end)
def setCurrentIndex(self, number, index=None):
"""Changes the current display view.
Params:
number <- int (0 for manga view, 1 for chapter view
Optional:
index <- QModelIndex for chapter view
Note: 0-based indexing
"""
if index is not None:
self.chapter_info_view.display_manga(index)
self.display.setCurrentIndex(number)
else:
self.display.setCurrentIndex(number)
# TODO: Improve this so that it adds to the series dialog,
# so user can edit data before inserting (make it a choice)
def populate(self):
"Populates the database with series from local drive'"
msgbox = QMessageBox()
msgbox.setText("<font color='red'><b>Use with care.</b></font> Choose a folder containing all your series'.")
msgbox.setInformativeText("Oniichan, are you sure you want to do this?")
msgbox.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
msgbox.setDefaultButton(QMessageBox.No)
if msgbox.exec() == QMessageBox.Yes:
path = QFileDialog.getExistingDirectory(None, "Choose a folder containing your series'")
if len(path) is not 0:
data_thread = QThread()
loading_thread = QThread()
loading = misc.Loading()
if not loading.ON:
misc.Loading.ON = True
fetch_instance = fetch.Fetch()
fetch_instance.series_path = path
loading.show()
def finished(status):
if status:
self.manga_list_view.series_model.populate_data()
# TODO: make it spawn a dialog instead (from utils.py or misc.py)
if loading.progress.maximum() == loading.progress.value():
misc.Loading.ON = False
loading.hide()
data_thread.quit
else:
loading.setText("<font color=red>An error occured. Try restarting..</font>")
loading.progress.setStyleSheet("background-color:red")
data_thread.quit
def fetch_deleteLater():
try:
fetch_instance.deleteLater
except NameError:
pass
def thread_deleteLater(): #NOTE: Isn't this bad?
data_thread.deleteLater
def a_progress(prog):
loading.progress.setValue(prog)
loading.setText("Searching on local disk...\n(Will take a while on first time)")
fetch_instance.moveToThread(data_thread)
fetch_instance.DATA_COUNT.connect(loading.progress.setMaximum)
fetch_instance.PROGRESS.connect(a_progress)
data_thread.started.connect(fetch_instance.local)
fetch_instance.FINISHED.connect(finished)
fetch_instance.FINISHED.connect(fetch_deleteLater)
fetch_instance.FINISHED.connect(thread_deleteLater)
data_thread.start()
def __init__(self,index):
self.index=index
print("index=",index)
QWidget.__init__(self)
self.main_vbox = QVBoxLayout()
self.time=[]
self.voltage=[]
self.sun=[]
self.laser=[]
self.edit_list=[]
self.line_number=[]
self.list=[]
self.fig = Figure(figsize=(5,4), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.figure.patch.set_facecolor('white')
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(),"32_save.png")), _("Save image"), self)
self.tb_save.triggered.connect(self.callback_save)
toolbar.addAction(self.tb_save)
self.tb_laser = QAction(QIcon(os.path.join(get_image_file_path(),"laser.png")), _("Laser start time"), self)
self.tb_laser.triggered.connect(self.callback_laser)
toolbar.addAction(self.tb_laser)
self.lasers=tb_lasers("pulse"+str(self.index)+".inp")
toolbar.addWidget(self.lasers)
self.tb_start = QAction(QIcon(os.path.join(get_image_file_path(),"start.png")), _("Simulation start time"), self)
self.tb_start.triggered.connect(self.callback_start_time)
toolbar.addAction(self.tb_start)
nav_bar=NavigationToolbar(self.canvas,self)
toolbar.addWidget(nav_bar)
self.main_vbox.addWidget(toolbar)
gui_pos=0
#canvas.set_size_request(500, 150)
self.ax1=None
self.show_key=True
self.main_vbox.addWidget(self.canvas)
#self.canvas.show()
#toolbar 2
toolbar2=QToolBar()
toolbar2.setIconSize(QSize(48, 48))
self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add section"), self)
self.tb_add.triggered.connect(self.callback_add_section)
toolbar2.addAction(self.tb_add)
self.tb_remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Delete section"), self)
self.tb_remove.triggered.connect(self.callback_remove_item)
toolbar2.addAction(self.tb_remove)
self.tb_move = QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Move down"), self)
self.tb_move.triggered.connect(self.callback_move_down)
toolbar2.addAction(self.tb_move)
self.main_vbox.addWidget(toolbar2)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.load_data()
self.update_scan_tokens()
self.build_mesh()
self.draw_graph()
self.tab.cellChanged.connect(self.on_cell_edited)
self.main_vbox.addWidget(self.tab)
w=self.width()
#self.canvas.setMinimumSize(w, 400)
self.tab.setMinimumSize(w, 120)
self.setLayout(self.main_vbox)
return
class GlyphWindow(BaseMainWindow):
def __init__(self, glyph, parent=None):
super().__init__(parent)
self.setAttribute(Qt.WA_DeleteOnClose, False)
self.setUnifiedTitleAndToolBarOnMac(True)
self.view = GlyphCanvasView(self)
# create tools and buttons toolBars
self._tools = []
self._toolsToolBar = QToolBar(self.tr("Tools"), self)
self._toolsToolBar.setMovable(False)
self._buttons = []
self._buttonsToolBar = QToolBar(self.tr("Buttons"), self)
self._buttonsToolBar.setMovable(False)
self.addToolBar(self._toolsToolBar)
self.addToolBar(self._buttonsToolBar)
# http://www.setnode.com/blog/right-aligning-a-button-in-a-qtoolbar/
self._layersToolBar = QToolBar(self.tr("Layers"), self)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._currentLayerBox = QComboBox(self)
self._currentLayerBox.currentIndexChanged.connect(
self._layerChanged)
self._layersToolBar.addWidget(spacer)
self._layersToolBar.addWidget(self._currentLayerBox)
self._layersToolBar.setContentsMargins(0, 0, 2, 0)
self._layersToolBar.setMovable(False)
self.addToolBar(self._layersToolBar)
self.setGlyph(glyph)
app = QApplication.instance()
tools = app.drawingTools()
for index, tool in enumerate(tools):
action = self.installTool(tool)
if not index:
action.trigger()
app.dispatcher.addObserver(
self, "_drawingToolRegistered", "drawingToolRegistered")
# TODO: drawingToolUnregistered
self.installButton(RemoveOverlapButton)
self.setCentralWidget(self.view)
self.view.setFocus(True)
self.readSettings()
def readSettings(self):
geometry = settings.glyphWindowGeometry()
if geometry:
self.restoreGeometry(geometry)
def writeSettings(self):
# TODO: save current tool?
settings.setGlyphWindowGeometry(self.saveGeometry())
def setupMenu(self, menuBar):
fileMenu = menuBar.fetchMenu(Entries.File)
fontWindow = self.parent()
if fontWindow is not None:
fileMenu.fetchAction(Entries.File_Save, fontWindow.saveFile)
fileMenu.fetchAction(Entries.File_Save_As, fontWindow.saveFileAs)
fileMenu.fetchAction(Entries.File_Close, self.close)
if fontWindow is not None:
fileMenu.fetchAction(Entries.File_Reload, fontWindow.reloadFile)
editMenu = menuBar.fetchMenu(Entries.Edit)
self._undoAction = editMenu.fetchAction(Entries.Edit_Undo, self.undo)
self._redoAction = editMenu.fetchAction(Entries.Edit_Redo, self.redo)
editMenu.addSeparator()
cutAction = editMenu.fetchAction(Entries.Edit_Cut, self.cutOutlines)
copyAction = editMenu.fetchAction(Entries.Edit_Copy, self.copyOutlines)
self._selectActions = (cutAction, copyAction)
editMenu.fetchAction(Entries.Edit_Paste, self.pasteOutlines)
editMenu.fetchAction(Entries.Edit_Select_All, self.selectAll)
editMenu.fetchAction(Entries.Edit_Find, self.changeGlyph)
# TODO: sort this out
# editMenu.fetchAction(self.tr("&Deselect"), self.deselect, "Ctrl+D")
# glyphMenu = menuBar.fetchMenu(self.tr("&Glyph"))
# self._layerAction = glyphMenu.fetchAction(
# self.tr("&Layer Actions…"), self.layerActions, "L")
viewMenu = menuBar.fetchMenu(Entries.View)
viewMenu.fetchAction(Entries.View_Zoom_In, lambda: self.view.zoom(1))
viewMenu.fetchAction(Entries.View_Zoom_Out, lambda: self.view.zoom(-1))
viewMenu.fetchAction(Entries.View_Reset_Zoom, self.view.fitScaleBBox)
viewMenu.addSeparator()
viewMenu.fetchAction(
Entries.View_Next_Glyph, lambda: self.glyphOffset(1))
viewMenu.fetchAction(
Entries.View_Previous_Glyph, lambda: self.glyphOffset(-1))
self._updateUndoRedo()
# ----------
# Menu items
# ----------
def saveFile(self):
glyph = self.view.glyph()
font = glyph.font
if None not in (font, font.path):
font.save()
def glyphOffset(self, offset):
currentGlyph = self.view.glyph()
font = currentGlyph.font
glyphOrder = font.glyphOrder
# should be enforced in fontView already
if not (glyphOrder and len(glyphOrder)):
return
index = glyphOrder.index(currentGlyph.name)
newIndex = (index + offset) % len(glyphOrder)
glyph = font[glyphOrder[newIndex]]
self.setGlyph(glyph)
def changeGlyph(self):
glyph = self.view.glyph()
newGlyph, ok = FindDialog.getNewGlyph(self, glyph)
if ok and newGlyph is not None:
self.setGlyph(newGlyph)
def layerActions(self):
glyph = self.view.glyph()
newLayer, action, ok = LayerActionsDialog.getLayerAndAction(
self, glyph)
if ok and newLayer is not None:
# TODO: whole glyph for now, but consider selection too
if glyph.name not in newLayer:
newLayer.newGlyph(glyph.name)
otherGlyph = newLayer[glyph.name]
otherGlyph.holdNotifications()
if action == "Swap":
tempGlyph = glyph.__class__()
otherGlyph.drawPoints(tempGlyph.getPointPen())
tempGlyph.width = otherGlyph.width
otherGlyph.clearContours()
glyph.drawPoints(otherGlyph.getPointPen())
otherGlyph.width = glyph.width
if action != "Copy":
glyph.holdNotifications()
glyph.clearContours()
if action == "Swap":
tempGlyph.drawPoints(glyph.getPointPen())
glyph.width = tempGlyph.width
glyph.releaseHeldNotifications()
otherGlyph.releaseHeldNotifications()
def undo(self):
glyph = self.view.glyph()
glyph.undo()
def redo(self):
glyph = self.view.glyph()
glyph.redo()
def cutOutlines(self):
glyph = self.view.glyph()
self.copyOutlines()
deleteUISelection(glyph)
def copyOutlines(self):
glyph = self.view.glyph()
clipboard = QApplication.clipboard()
mimeData = QMimeData()
copyGlyph = glyph.getRepresentation("TruFont.FilterSelection")
mimeData.setData("application/x-trufont-glyph-data",
pickle.dumps([copyGlyph.serialize(
blacklist=("name", "unicode")
)]))
clipboard.setMimeData(mimeData)
def pasteOutlines(self):
glyph = self.view.glyph()
clipboard = QApplication.clipboard()
mimeData = clipboard.mimeData()
if mimeData.hasFormat("application/x-trufont-glyph-data"):
data = pickle.loads(mimeData.data(
"application/x-trufont-glyph-data"))
if len(data) == 1:
pen = glyph.getPointPen()
pasteGlyph = glyph.__class__()
pasteGlyph.deserialize(data[0])
# TODO: if we serialize selected state, we don't need to do
# this
pasteGlyph.selected = True
if len(pasteGlyph) or len(pasteGlyph.components) or \
len(pasteGlyph.anchors):
glyph.prepareUndo()
pasteGlyph.drawPoints(pen)
def selectAll(self):
glyph = self.view.glyph()
if glyph.selected:
for anchor in glyph.anchors:
anchor.selected = True
for component in glyph.components:
component.selected = True
else:
glyph.selected = True
def deselect(self):
glyph = self.view.glyph()
for anchor in glyph.anchors:
anchor.selected = False
for component in glyph.components:
component.selected = False
glyph.selected = False
def lockToolBars(self):
action = self.sender()
movable = not action.isChecked()
for toolBar in (
self._toolsToolBar, self._buttonsToolBar, self._layersToolBar):
toolBar.setMovable(movable)
# --------------------------
# Tools & buttons management
# --------------------------
def installTool(self, tool):
action = self._toolsToolBar.addAction(
QIcon(tool.iconPath), tool.name, self._setViewTool)
action.setCheckable(True)
num = len(self._tools)
action.setData(num)
action.setShortcut(QKeySequence(str(num + 1)))
self._tools.append(tool(parent=self.view.widget()))
return action
def uninstallTool(self, tool):
pass # XXX
def _setViewTool(self):
action = self.sender()
index = action.data()
newTool = self._tools[index]
if newTool == self.view.currentTool():
action.setChecked(True)
return
ok = self.view.setCurrentTool(newTool)
# if view did change tool, disable them all and enable the one we want
# otherwise, just disable the tool that was clicked.
# previously we used QActionGroup to have exclusive buttons, but doing
# it manually allows us to NAK a button change.
if ok:
for act in self._toolsToolBar.actions():
act.setChecked(False)
action.setChecked(ok)
def installButton(self, button):
action = self._buttonsToolBar.addAction(
QIcon(button.iconPath), button.name, self._buttonAction)
action.setData(len(self._buttons))
self._buttons.append(button(parent=self.view))
return action
def uninstallButton(self, button):
pass # XXX
def _buttonAction(self):
action = self.sender()
index = action.data()
button = self._buttons[index]
button.clicked()
# -------------
# Notifications
# -------------
# app
def _drawingToolRegistered(self, notification):
tool = notification.data["tool"]
self.installTool(tool)
# glyph
def _subscribeToGlyph(self, glyph):
if glyph is not None:
glyph.addObserver(self, "_glyphNameChanged", "Glyph.NameChanged")
glyph.addObserver(
self, "_glyphSelectionChanged", "Glyph.SelectionChanged")
undoManager = glyph.undoManager
undoManager.canUndoChanged.connect(self._setUndoEnabled)
undoManager.canRedoChanged.connect(self._setRedoEnabled)
self._subscribeToFontAndLayerSet(glyph.font)
def _unsubscribeFromGlyph(self, glyph):
if glyph is not None:
glyph.removeObserver(self, "Glyph.NameChanged")
glyph.removeObserver(self, "Glyph.SelectionChanged")
undoManager = glyph.undoManager
undoManager.canUndoChanged.disconnect(self._setUndoEnabled)
undoManager.canRedoChanged.disconnect(self._setRedoEnabled)
self._unsubscribeFromFontAndLayerSet(glyph.font)
def _glyphNameChanged(self, notification):
glyph = self.view.glyph()
self.setWindowTitle(glyph.name, glyph.font)
def _glyphSelectionChanged(self, notification):
self._updateSelection()
# layers & font
def _subscribeToFontAndLayerSet(self, font):
"""Note: called by _subscribeToGlyph."""
if font is None:
return
font.info.addObserver(self, "_fontInfoChanged", "Info.Changed")
layerSet = font.layers
if layerSet is None:
return
layerSet.addObserver(
self, '_layerSetLayerDeleted', 'LayerSet.LayerDeleted')
for event in ('LayerSet.LayerAdded', 'LayerSet.LayerChanged',
'LayerSet.LayerOrderChanged'):
layerSet.addObserver(self, '_layerSetEvents', event)
def _unsubscribeFromFontAndLayerSet(self, font):
"""Note: called by _unsubscribeFromGlyph."""
if font is None:
return
font.info.removeObserver(self, "Info.Changed")
layerSet = font.layers
if layerSet is None:
return
for event in ('LayerSet.LayerAdded', 'LayerSet.LayerChanged',
'LayerSet.LayerOrderChanged', 'LayerSet.LayerDeleted'):
layerSet.removeObserver(self, event)
def _fontInfoChanged(self, notification):
glyph = self.view.glyph()
self.setWindowTitle(glyph.name, glyph.font)
def _layerSetEvents(self, notification):
self._updateLayerControls()
def _layerSetLayerDeleted(self, notification):
self._layerSetEvents(notification)
self._currentLayerBox.setCurrentIndex(0)
# other updaters
def _updateSelection(self):
def hasSelection():
glyph = self.view.glyph()
for contour in glyph:
if len(contour.selection):
return True
for anchor in glyph.anchors:
if anchor.selected:
return True
for component in glyph.components:
if component.selected:
return True
return False
if not hasattr(self, "_selectActions"):
return
hasSelection = hasSelection()
for action in self._selectActions:
action.setEnabled(hasSelection)
def _updateUndoRedo(self):
glyph = self.view.glyph()
self._setUndoEnabled(glyph.canUndo())
self._setRedoEnabled(glyph.canRedo())
def _setUndoEnabled(self, value):
if not hasattr(self, "_undoAction"):
return
self._undoAction.setEnabled(value)
def _setRedoEnabled(self, value):
if not hasattr(self, "_redoAction"):
return
self._redoAction.setEnabled(value)
# --------------
# Public Methods
# --------------
def setGlyph(self, glyph):
currentGlyph = self.view.glyph()
self._unsubscribeFromGlyph(currentGlyph)
self.view.setGlyph(glyph)
self._subscribeToGlyph(glyph)
self._updateLayerControls()
self._updateUndoRedo()
self._updateSelection()
self.setWindowTitle(glyph.name, glyph.font)
# setting the layer-glyph here
app = QApplication.instance()
app.setCurrentGlyph(glyph)
# -----------------
# Layers management
# -----------------
def _layerChanged(self, newLayerIndex):
glyph = self.view.glyph()
layer = self._currentLayerBox.itemData(newLayerIndex)
if layer is None:
layer = self._makeLayer()
if layer is None:
# restore comboBox to active index
layerSet = glyph.layerSet
index = layerSet.layerOrder.index(glyph.layer.name)
self._setLayerBoxIndex(index)
return
if glyph.name in layer:
newGlyph = layer[glyph.name]
else:
# TODO: make sure we mimic defcon ufo3 APIs for that
newGlyph = self._makeLayerGlyph(layer, glyph)
self.setGlyph(newGlyph)
def _makeLayer(self):
# TODO: what with duplicate names?
glyph = self.view.glyph()
newLayerName, color, ok = AddLayerDialog.getNewLayerNameAndColor(self)
if ok:
layerSet = glyph.layerSet
layer = layerSet.newLayer(newLayerName)
layer.color = color
return layer
return None
def _makeLayerGlyph(self, layer, currentGlyph):
glyph = layer.newGlyph(currentGlyph.name)
glyph.width = currentGlyph.width
glyph.template = True
return glyph
def _updateLayerControls(self):
comboBox = self._currentLayerBox
glyph = self.view.glyph()
comboBox.blockSignals(True)
comboBox.clear()
for layer in glyph.layerSet:
comboBox.addItem(layer.name, layer)
comboBox.setCurrentText(glyph.layer.name)
comboBox.addItem(self.tr("New layer…"), None)
comboBox.blockSignals(False)
if not hasattr(self, "_layerAction"):
return
self._layerAction.setEnabled(len(glyph.layerSet) > 1)
def _setLayerBoxIndex(self, index):
comboBox = self._currentLayerBox
comboBox.blockSignals(True)
comboBox.setCurrentIndex(index)
comboBox.blockSignals(False)
# ---------------------
# QMainWindow functions
# ---------------------
def sizeHint(self):
return QSize(1100, 750)
def moveEvent(self, event):
self.writeSettings()
resizeEvent = moveEvent
def event(self, event):
if event.type() == QEvent.WindowActivate:
app = QApplication.instance()
app.setCurrentGlyph(self.view.glyph())
return super().event(event)
def showEvent(self, event):
app = QApplication.instance()
data = dict(window=self)
app.postNotification("glyphWindowWillOpen", data)
super().showEvent(event)
app.postNotification("glyphWindowOpened", data)
def closeEvent(self, event):
super().closeEvent(event)
if event.isAccepted():
app = QApplication.instance()
app.dispatcher.removeObserver(self, "drawingToolRegistered")
data = dict(window=self)
app.postNotification("glyphWindowWillClose", data)
glyph = self.view.glyph()
self._unsubscribeFromGlyph(glyph)
self.view.closeEvent(event)
def setWindowTitle(self, title, font=None):
if font is not None:
title = "%s – %s %s" % (
title, font.info.familyName, font.info.styleName)
super().setWindowTitle(title)
class PostProcessor(QMainWindow):
sim_results_changed = pyqtSignal()
post_results_changed = pyqtSignal()
figures_changed = pyqtSignal(list, str)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self._settings = QSettings()
self._logger = logging.getLogger(self.__class__.__name__)
self.setWindowTitle("Processing")
self.setWindowIcon(QIcon(get_resource("processing.png")))
self.mainFrame = QWidget(self)
self.resize(1000, 600)
# toolbar
self.toolBar = QToolBar("file control")
self.toolBar.setIconSize(QSize(24, 24))
self.addToolBar(self.toolBar)
self.actLoad = QAction(self)
self.actLoad.setText("load result file")
self.actLoad.setIcon(QIcon(get_resource("load.png")))
self.actLoad.setDisabled(False)
self.actLoad.triggered.connect(self.load_result_files)
self.actPostLoad = QAction(self)
self.actPostLoad.setText("load post-result file")
self.actPostLoad.setIcon(QIcon(get_resource("load.png")))
self.actPostLoad.setDisabled(False)
self.actPostLoad.triggered.connect(self.load_post_result_files)
self.actSwitch = QAction(self)
self.actSwitch.setText("switch display mode")
self.actSwitch.setIcon(QIcon(get_resource("left_mode.png")))
self.actSwitch.setDisabled(False)
self.actSwitch.triggered.connect(self.switch_sides)
self.displayLeft = True
self.spacer1 = QWidget()
self.spacer2 = QWidget()
self.spacer1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.actReloadMethods = QAction(self)
self.actReloadMethods.setText("reload methods")
self.actReloadMethods.setIcon(QIcon(get_resource("reload.png")))
self.actReloadMethods.setDisabled(False)
self.actReloadMethods.triggered.connect(self.update_post_method_list)
self.actReloadMetaMethods = QAction(self)
self.actReloadMetaMethods.setText("reload meta methods")
self.actReloadMetaMethods.setIcon(QIcon(get_resource("reload.png")))
self.actReloadMetaMethods.setDisabled(False)
self.actReloadMetaMethods.triggered.connect(
self.update_meta_method_list)
self.toolBar.addAction(self.actLoad)
self.toolBar.addAction(self.actReloadMethods)
self.toolBar.addWidget(self.spacer1)
self.toolBar.addAction(self.actSwitch)
self.toolBar.addWidget(self.spacer2)
self.toolBar.addAction(self.actReloadMetaMethods)
self.toolBar.addAction(self.actPostLoad)
# main window
self.grid = QGridLayout(self.mainFrame)
self.grid.setColumnMinimumWidth(0, 70)
self.grid.setColumnStretch(0, 0)
self.grid.setColumnStretch(1, 1)
self.methodList = QListWidget(self)
self.methodList.itemDoubleClicked.connect(
self.post_processor_clicked)
self.update_post_method_list()
self.metaMethodList = QListWidget(self)
self.metaMethodList.itemDoubleClicked.connect(
self.meta_processor_clicked)
self.update_meta_method_list()
self.sim_result_list = QListWidget(self)
self.sim_results_changed.connect(self.update_result_list)
self.results = []
self.delShort = QShortcut(QKeySequence(Qt.Key_Delete),
self.sim_result_list)
self.delShort.activated.connect(self.remove_result_item)
# figures
self._figure_dict = {}
self.figures_changed.connect(self.update_figure_lists)
self.post_figure_list = QListWidget(self)
self.post_figure_list.currentItemChanged.connect(
self.current_figure_changed)
self.meta_figure_list = QListWidget(self)
self.meta_figure_list.currentItemChanged.connect(
self.current_figure_changed)
self.plotView = QWidget()
self.lastFigure = None
self.post_result_list = QListWidget(self)
self.post_results_changed.connect(self.update_post_result_list)
self.post_results = []
self.delShortPost = QShortcut(QKeySequence(Qt.Key_Backspace),
self.post_result_list)
self.delShortPost.activated.connect(self.remove_post_result_item)
# log dock
self.logBox = QPlainTextEdit(self)
self.logBox.setReadOnly(True)
# init logger for logging box
self.textLogger = PlainTextLogger(logging.INFO)
self.textLogger.set_target_cb(self.logBox.appendPlainText)
logging.getLogger().addHandler(self.textLogger)
self.grid.addWidget(QLabel("Result Files:"), 0, 0)
self.grid.addWidget(self.sim_result_list, 1, 0)
self.grid.addWidget(QLabel("Postprocessors:"), 2, 0)
self.grid.addWidget(self.methodList, 3, 0)
self.grid.addWidget(QLabel("Figures:"), 4, 0)
self.grid.addWidget(self.post_figure_list, 5, 0)
self.grid.addWidget(QLabel("Selected Figure:"), 0, 1)
self.grid.addWidget(QLabel("Postprocessor Files:"), 0, 2)
self.grid.addWidget(self.post_result_list, 1, 2)
self.grid.addWidget(QLabel("Metaprocessors:"), 2, 2)
self.grid.addWidget(self.metaMethodList, 3, 2)
self.grid.addWidget(QLabel("Figures:"), 4, 2)
self.grid.addWidget(self.meta_figure_list, 5, 2)
self.grid.addWidget(self.logBox, 6, 0, 1, 3)
self.mainFrame.setLayout(self.grid)
self.setCentralWidget(self.mainFrame)
# status bar
self.statusBar = QStatusBar(self)
self.setStatusBar(self.statusBar)
def load_result_files(self):
path = self._settings.value("path/simulation_results")
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setDirectory(path)
dialog.setNameFilter("PyMoskito Result files (*.pmr)")
if dialog.exec_():
files = dialog.selectedFiles()
for single_file in files:
if single_file:
self._load_result_file(single_file)
def _load_result_file(self, file_name):
"""
loads a result file
"""
self._logger.info("loading result file {}".format(file_name))
with open(file_name.encode(), "rb") as f:
self.results.append(pickle.load(f))
self.sim_results_changed.emit()
def update_result_list(self):
self.sim_result_list.clear()
for res in self.results:
name = res["regime name"]
self.sim_result_list.addItem(name)
def remove_result_item(self):
if self.sim_result_list.currentRow() >= 0:
del self.results[self.sim_result_list.currentRow()]
self.sim_result_list.takeItem(self.sim_result_list.currentRow())
def load_post_result_files(self):
path = self._settings.value("path/processing_results")
dialog = QFileDialog(self)
dialog.setFileMode(QFileDialog.ExistingFiles)
dialog.setDirectory(path)
dialog.setNameFilter("Postprocessing Output files (*.pof)")
if dialog.exec_():
files = dialog.selectedFiles()
for single_file in files:
if single_file:
self._load_post_result_file(single_file)
def _load_post_result_file(self, file_name):
"""
loads a post-result file (.pof)
"""
name = os.path.split(file_name)[-1][:-4]
self._logger.info("loading result file {}".format(file_name))
with open(file_name.encode(), "rb") as f:
results = pickle.load(f)
results.update({"name": name})
self.post_results.append(results)
self.post_results_changed.emit()
def update_post_result_list(self):
self.post_result_list.clear()
for res in self.post_results:
name = res["name"]
self.post_result_list.addItem(name)
def remove_post_result_item(self):
if self.post_result_list.currentRow() >= 0:
del self.post_results[self.post_result_list.currentRow()]
self.post_result_list.takeItem(self.post_result_list.currentRow())
def update_post_method_list(self):
self.methodList.clear()
modules = pm.get_registered_processing_modules(PostProcessingModule)
for mod in modules:
self.methodList.addItem(mod[1])
def update_meta_method_list(self):
self.metaMethodList.clear()
modules = pm.get_registered_processing_modules(MetaProcessingModule)
for mod in modules:
self.metaMethodList.addItem(mod[1])
def post_processor_clicked(self, item):
self.run_processor(str(item.text()), "post")
def meta_processor_clicked(self, item):
self.run_processor(str(item.text()), "meta")
def run_processor(self, name, processor_type):
if processor_type == "post":
result_files = self.results
base_cls = PostProcessingModule
elif processor_type == "meta":
result_files = self.post_results
base_cls = MetaProcessingModule
else:
self._logger.error("unknown processor type {0}".format(
processor_type))
raise ValueError("unknown processor type {0}".format(
processor_type))
if not result_files:
self._logger.warning("run_processor() Error: no result file loaded")
return
processor_cls = pm.get_processing_module_class_by_name(base_cls, name)
processor = processor_cls()
figs = []
try:
self._logger.info("executing processor '{0}'".format(name))
figs = processor.process(result_files)
except Exception as err:
self._logger.exception("Error in processor")
self.figures_changed.emit(figs, processor_type)
self._logger.info("finished postprocessing")
def update_figure_lists(self, figures, target_type):
# remove no longer needed elements
for item, fig in [(key, val[0])
for key, val in self._figure_dict.items()
if val[1] == target_type]:
if fig not in [new_fig["figure"] for new_fig in figures]:
if target_type == "post":
old_item = self.post_figure_list.takeItem(
self.post_figure_list.row(item))
del old_item
elif target_type == "meta":
old_item = self.meta_figure_list.takeItem(
self.meta_figure_list.row(item))
del old_item
del self._figure_dict[item]
# add new ones to internal storage
for fig in figures:
if fig["figure"] not in self._figure_dict.values():
new_entry = [(fig["name"],
(QListWidgetItem(fig["name"]),
fig["figure"], target_type)
)]
self._figure_dict.update(new_entry)
# add to display
for key, val in self._figure_dict.items():
if val[2] == "post":
self.post_figure_list.addItem(val[0])
elif val[2] == "meta":
self.meta_figure_list.addItem(val[0])
self.post_figure_list.setCurrentItem(self.post_figure_list.item(0))
self.meta_figure_list.setCurrentItem(self.meta_figure_list.item(0))
def current_figure_changed(self, current_item, last_item=None):
if current_item is None:
return
figures = self._figure_dict
if self.lastFigure:
self.grid.removeWidget(self.lastFigure)
self.lastFigure.setVisible(False)
if current_item.text() in figures:
figure_widget = figures[current_item.text()][1]
self.grid.addWidget(figure_widget, 1, 1, 5, 1)
figure_widget.setVisible(True)
self.lastFigure = figure_widget
def switch_sides(self):
self.displayLeft = not self.displayLeft
if self.displayLeft:
self.actSwitch.setIcon(QIcon(get_resource("left_mode.png")))
self.post_figure_list.setFocus()
self.current_figure_changed(self.post_figure_list.currentItem())
else:
self.actSwitch.setIcon(QIcon(get_resource("right_mode.png")))
self.meta_figure_list.setFocus()
self.current_figure_changed(self.meta_figure_list.currentItem())
class ClearHistoryDialog(QDialog):
def __init__(self, parent=None):
super(ClearHistoryDialog, self).__init__(parent)
self.setWindowFlags(Qt.Dialog)
self.setWindowTitle(tr("Clear Data"))
closeWindowAction = QAction(self)
closeWindowAction.setShortcuts(["Esc", "Ctrl+W", "Ctrl+Shift+Del"])
closeWindowAction.triggered.connect(self.close)
self.addAction(closeWindowAction)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
label = QLabel(tr("What to clear:"), self)
self.layout.addWidget(label)
self.dataType = QComboBox(self)
self.dataType.addItem(tr("History"))
self.dataType.addItem(tr("Cookies"))
self.dataType.addItem(tr("Memory Caches"))
self.dataType.addItem(tr("Persistent Storage"))
self.dataType.addItem(tr("Everything"))
self.layout.addWidget(self.dataType)
self.toolBar = QToolBar(self)
self.toolBar.setStyleSheet(common.blank_toolbar)
self.toolBar.setMovable(False)
self.toolBar.setContextMenuPolicy(Qt.CustomContextMenu)
self.layout.addWidget(self.toolBar)
self.clearHistoryButton = QPushButton(tr("Clear"), self)
self.clearHistoryButton.clicked.connect(self.clearHistory)
self.toolBar.addWidget(self.clearHistoryButton)
self.closeButton = QPushButton(tr("Close"), self)
self.closeButton.clicked.connect(self.close)
self.toolBar.addWidget(self.closeButton)
def display(self):
self.show()
self.activateWindow()
def clearHistory(self):
clear_everything = (self.dataType.currentIndex() == self.dataType.count()-1)
if self.dataType.currentIndex() == 0 or clear_everything:
data.clearHistory()
if self.dataType.currentIndex() == 1 or clear_everything:
data.clearCookies()
if self.dataType.currentIndex() == 2 or clear_everything:
QWebSettings.globalSettings().clearMemoryCaches()
if self.dataType.currentIndex() == 3 or clear_everything:
QWebSettings.globalSettings().setIconDatabasePath("")
QWebSettings.globalSettings().setLocalStoragePath("")
QWebSettings.globalSettings().setOfflineStoragePath("")
QWebSettings.globalSettings().setOfflineWebApplicationCachePath("")
for subpath in ("WebpageIcons.db", "LocalStorage", "Databases",):
path = os.path.abspath(os.path.join(settings.settings_folder, subpath))
if os.path.isfile(path):
try: os.remove(path)
except: pass
elif os.path.isdir(path):
if sys.platform.startswith("win"):
args = ["rmdir", "/s", "/q", "\"" + path + "\""]
try: os.system(" ".join(args))
except: pass
else:
try: subprocess.Popen(["rm", "-rf", path])
except: pass
QWebSettings.globalSettings().enablePersistentStorage(settings.settings_folder)
class MainWindow(QMainWindow):
def __init__(self, autoTradingSystem):
super(MainWindow, self).__init__()
self.ATM = autoTradingSystem
self.initUI()
def initUI(self):
self.setStyle()
self.setWindowTitle('Auto Trading System')
self.initToolBar()
self.initMenuBar()
self.initMainBoard()
self.techAnPage()
#self.pairTrPage()
# make window in center point
self.setFixedSize(1000, 700)
qr = self.frameGeometry()
qr.moveCenter(QDesktopWidget().availableGeometry().center())
self.move(qr.topLeft())
self.show()
def initMainBoard(self):
self.mainBoard = QWidget()
self.setCentralWidget(self.mainBoard)
self.pagesStatus = [0]*5
self.pages = [QWidget(self.mainBoard) for i in self.pagesStatus]
self.toolButtons
self.mainBoard.setStyleSheet(self.mainBoardQSS)
for page in self.pages: page.setStyleSheet(self.pagesQSS)
def initToolBar(self):
self.toolBar = QToolBar("Tools")
self.toolBar.setMovable(False)
self.addToolBar(Qt.LeftToolBarArea, self.toolBar)
self.toolBar.setIconSize(QSize(20, 20))
self.techAnButton = QToolButton()
self.techAnButton.setText("Technical analysis")
self.techAnButton.setFixedSize(130, 25)
self.pairTrButton = QToolButton()
self.pairTrButton.setText("Pair Trading")
self.pairTrButton.setFixedSize(130, 25)
self.atoTrdButton = QToolButton()
self.atoTrdButton.setText("Monitor")
self.atoTrdButton.setFixedSize(130, 25)
self.trdPnlButton = QToolButton()
self.trdPnlButton.setText("PnL Report")
self.trdPnlButton.setFixedSize(130, 25)
self.trdHisButton = QToolButton()
self.trdHisButton.setText("Trade History")
self.trdHisButton.setFixedSize(130, 25)
self.techAnButton.clicked.connect(self.techAnPage)
self.pairTrButton.clicked.connect(self.pairTrPage)
self.atoTrdButton.clicked.connect(self.atoTrdPage)
self.trdPnlButton.clicked.connect(self.trdPnlPage)
self.trdHisButton.clicked.connect(self.trdHisPage)
self.toolBar.addWidget(self.techAnButton)
self.toolBar.addWidget(self.pairTrButton)
self.toolBar.addWidget(self.atoTrdButton)
self.toolBar.addWidget(self.trdPnlButton)
self.toolBar.addWidget(self.trdHisButton)
self.toolButtons = [self.techAnButton, self.pairTrButton, self.atoTrdButton, self.trdPnlButton, self.trdHisButton]
def initMenuBar(self):
exitAction = QAction('&Exit', self)
exitAction.setShortcut('Ctrl+Q')
exitAction.triggered.connect(qApp.quit)
techAnAction = QAction('&Technical Analysis', self)
techAnAction.setShortcut('Ctrl+T')
techAnAction.triggered.connect(self.techAnPage)
pairTrAction = QAction('&Pair Trading', self)
pairTrAction.setShortcut('Ctrl+P')
pairTrAction.triggered.connect(self.pairTrPage)
atoTrdAction = QAction('&Monitor', self)
atoTrdAction.setShortcut('Ctrl+M')
atoTrdAction.triggered.connect(self.atoTrdPage)
trdPnlAction = QAction('&Profit And Loss Report', self)
trdPnlAction.setShortcut('Ctrl+R')
trdPnlAction.triggered.connect(self.trdPnlPage)
trdHisAction = QAction('&Trade History', self)
trdHisAction.setShortcut('Ctrl+H')
trdHisAction.triggered.connect(self.trdHisPage)
menubar = self.menuBar()
menubar.setNativeMenuBar(False)
fannsMenu = menubar.addMenu('&App')
fannsMenu.addAction(exitAction)
naviMenu = menubar.addMenu('&Navigate')
naviMenu.addAction(techAnAction)
naviMenu.addAction(pairTrAction)
naviMenu.addAction(atoTrdAction)
naviMenu.addAction(trdPnlAction)
naviMenu.addAction(trdHisAction)
# The technical analysis page
def techAnPage(self):
# hide all pages to show self page
for pi in range(0,len(self.pages)):
self.toolButtons[pi].setStyleSheet(self.toolButtonHideQSS)
self.pages[pi].hide()
print "in technical analysis page"
ci = 0
page = self.pages[ci]
self.toolButtons[ci].setStyleSheet(self.toolButtonFocusQSS)
if self.pagesStatus[ci] == 0:
self.pageTechAnConfigWidget = QWidget(page)
self.pageTechAnConfigWidget.setFixedSize(860, 700)
pageMainVerticalBox = QVBoxLayout()
pageMainVerticalBox.setContentsMargins(0, 5, 0, 0)
self.pageTechAnTitleLabel = QLabel("Technical Analysis", page)
self.pageTechAnTitleLabel.setFixedSize(860, 25)
self.pageTechAnTitleLabel.setStyleSheet(self.pageTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnTitleLabel)
# capital config components
self.pageTechAnCapitalLabel = QLabel("Capital Config", page)
self.pageTechAnCapitalLabel.setFixedSize(860, 25)
self.pageTechAnCapitalLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnCapitalLabel)
capitalHbox = QHBoxLayout()
capitalHbox.setContentsMargins(30, 10, 0, 10)
self.pageTechAnCapitalInputLabel = QLabel("Capital: ", page)
self.pageTechAnCapitalInputLabel.setFont(self.contentFont)
self.pageTechAnCapitalInputLabel.setFixedSize(100, 25)
self.pageTechAnCapitalInputLabel.setStyleSheet(self.itemNameQSS)
capitalHbox.addWidget(self.pageTechAnCapitalInputLabel)
self.pageTechAnCapitalEdit = QLineEdit("$ 100,000,000")
self.pageTechAnCapitalEdit.setStyleSheet(self.lineEditQSS)
self.pageTechAnCapitalEdit.setFixedSize(300, 25)
self.pageTechAnCapitalEdit.setEnabled(False)
capitalHbox.addWidget(self.pageTechAnCapitalEdit)
capitalHbox.addStretch(1)
pageMainVerticalBox.addLayout(capitalHbox)
# security code select components
self.pageTechAnSecurityLabel = QLabel("Security Select", page)
self.pageTechAnSecurityLabel.setFixedSize(860, 25)
self.pageTechAnSecurityLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnSecurityLabel)
securityHbox = QHBoxLayout()
securityHbox.setContentsMargins(30, 10, 0, 10)
self.pageTechAnSecurityCode= QLabel("Security Code: ", page)
self.pageTechAnSecurityCode.setFont(self.contentFont)
self.pageTechAnSecurityCode.setFixedSize(100, 25)
self.pageTechAnSecurityCode.setStyleSheet(self.itemNameQSS)
securityHbox.addWidget(self.pageTechAnSecurityCode)
self.pageTechAnSecurityCombo = QComboBox(page)
self.pageTechAnSecurityCombo.setFixedSize(300, 25)
self.pageTechAnSecurityCombo.setStyleSheet(self.comboQSS)
self.pageTechAnSecurityCombo.addItem("hsi_futures_jan")
for item in self.ATM.data.getAssetList("./dataManager/data/hsi_futures"): self.pageTechAnSecurityCombo.addItem(item)
securityHbox.addWidget(self.pageTechAnSecurityCombo)
securityHbox.addStretch(1)
pageMainVerticalBox.addLayout(securityHbox)
# investment strategies select components
self.pageTechAnStrategiesLabel = QLabel("Investment Strategies Select", page)
self.pageTechAnStrategiesLabel.setFixedSize(860, 25)
self.pageTechAnStrategiesLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnStrategiesLabel)
self.pageTechAnStrategiesWidget = QWidget(page)
self.pageTechAnStrategiesWidget.setFixedSize(700, 80)
strategiesGrid = QGridLayout()
strategiesGrid.setContentsMargins(30, 10, 0, 10)
self.pageTechAnStrategyCheckBoxACOscillator = QCheckBox(" ACOscillator")
self.pageTechAnStrategyCheckBoxCCICorrection= QCheckBox(" CCI Correction")
self.pageTechAnStrategyCheckBoxDMRSIADX = QCheckBox(" DM RSI ADX")
self.pageTechAnStrategyCheckBoxMACD = QCheckBox(" MACD")
self.pageTechAnStrategyCheckBoxBreakoutsSwing=QCheckBox(" Breakouts Swing")
self.pageTechAnStrategyCheckBoxOscillator313= QCheckBox(" Oscillator3 13")
self.pageTechAnStrategyCheckBoxACOscillator.setChecked(False)
self.pageTechAnStrategyCheckBoxCCICorrection.setChecked(False)
self.pageTechAnStrategyCheckBoxDMRSIADX.setChecked(False)
self.pageTechAnStrategyCheckBoxMACD.setChecked(True)
self.pageTechAnStrategyCheckBoxBreakoutsSwing.setChecked(False)
self.pageTechAnStrategyCheckBoxOscillator313.setChecked(False)
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxACOscillator, *(1, 1))
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxCCICorrection, *(1, 2))
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxDMRSIADX, *(1, 3))
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxMACD, *(2,1))
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxBreakoutsSwing, *(2,2))
strategiesGrid.addWidget(self.pageTechAnStrategyCheckBoxOscillator313, *(2,3))
self.pageTechAnStrategiesWidget.setLayout(strategiesGrid)
pageMainVerticalBox.addWidget(self.pageTechAnStrategiesWidget)
# trading time config components
self.pageTechAnTimeSpanLabel = QLabel("Trading Time Config", page)
self.pageTechAnTimeSpanLabel.setFixedSize(860, 25)
self.pageTechAnTimeSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnTimeSpanLabel)
timeVbox = QVBoxLayout()
timeVbox.setContentsMargins(30, 10, 0, 10)
startTimeHbox = QHBoxLayout()
self.pageTechAnStartTimeName = QLabel("Start Time: ", page)
self.pageTechAnStartTimeName.setFont(self.contentFont)
self.pageTechAnStartTimeName.setFixedSize(100, 25)
self.pageTechAnStartTimeName.setStyleSheet(self.itemNameQSS)
startTimeHbox.addWidget(self.pageTechAnStartTimeName)
self.pageTechAnStartTimeEdit = QLineEdit("2016-02-10 16:00:00")
self.pageTechAnStartTimeEdit.setEnabled(False)
self.pageTechAnStartTimeEdit.setStyleSheet(self.lineEditQSS)
self.pageTechAnStartTimeEdit.setFixedSize(300, 25)
startTimeHbox.addWidget(self.pageTechAnStartTimeEdit)
startTimeHbox.addStretch(1)
timeVbox.addLayout(startTimeHbox)
endTimeHbox = QHBoxLayout()
self.pageTechAnEndTimeName = QLabel("End Time: ", page)
self.pageTechAnEndTimeName.setFont(self.contentFont)
self.pageTechAnEndTimeName.setFixedSize(100, 25)
self.pageTechAnEndTimeName.setStyleSheet(self.itemNameQSS)
endTimeHbox.addWidget(self.pageTechAnEndTimeName)
self.pageTechAnEndTimeEdit = QLineEdit("2016-02-26 16:00:00")
self.pageTechAnEndTimeEdit.setEnabled(False)
self.pageTechAnEndTimeEdit.setStyleSheet(self.lineEditQSS)
self.pageTechAnEndTimeEdit.setFixedSize(300, 25)
endTimeHbox.addWidget(self.pageTechAnEndTimeEdit)
endTimeHbox.addStretch(1)
timeVbox.addLayout(endTimeHbox)
pageMainVerticalBox.addLayout(timeVbox)
# trading strategies select components
self.pageTechAnTStrSpanLabel = QLabel("Trading Strategies Select", page)
self.pageTechAnTStrSpanLabel.setFixedSize(860, 25)
self.pageTechAnTStrSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnTStrSpanLabel)
self.pageTechAnTradeStrateWidget = QWidget(page)
self.pageTechAnTradeStrateWidget.setFixedSize(700, 40)
tradeStratGrid = QGridLayout()
tradeStratGrid.setContentsMargins(30, 5, 0, 5)
self.pageTechAnTStrRadioButtonVWAP = QRadioButton(" VWAP")
self.pageTechAnTStrRadioButtonVWAP.setCheckable(False)
self.pageTechAnTStrRadioButtonTWAP = QRadioButton(" TWAP")
self.pageTechAnTStrRadioButtonTWAP.setChecked(True)
self.pageTechAnTStrRadioButtonNONE = QRadioButton(" NONE")
tradeStratGrid.addWidget(self.pageTechAnTStrRadioButtonVWAP, *(1, 1))
tradeStratGrid.addWidget(self.pageTechAnTStrRadioButtonTWAP, *(1, 2))
tradeStratGrid.addWidget(self.pageTechAnTStrRadioButtonNONE, *(1, 3))
tradeStratGrid.addWidget(QLabel(), *(1, 4))
tradeStratGrid.addWidget(QLabel(), *(1, 5))
self.pageTechAnTradeStrateWidget.setLayout(tradeStratGrid)
pageMainVerticalBox.addWidget(self.pageTechAnTradeStrateWidget)
# position management method select components
self.pageTechAnPManSpanLabel = QLabel("Position Management Method Select", page)
self.pageTechAnPManSpanLabel.setFixedSize(860, 25)
self.pageTechAnPManSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pageTechAnPManSpanLabel)
self.pageTechAnPManageMthdWidget = QWidget(page)
self.pageTechAnPManageMthdWidget.setFixedSize(700, 40)
pManageMtdGrid = QGridLayout()
pManageMtdGrid.setContentsMargins(30, 10, 0, 10)
self.pageTechAnPMtdRadioButtonFixedFraction = QRadioButton(" Fixed Fraction")
self.pageTechAnPMtdRadioButtonFixedFraction.setChecked(True)
self.pageTechAnPMtdRadioButtonMaximDrawDown = QRadioButton(" Max Draw Down")
pManageMtdGrid.addWidget(self.pageTechAnPMtdRadioButtonFixedFraction, *(1, 1))
pManageMtdGrid.addWidget(self.pageTechAnPMtdRadioButtonMaximDrawDown, *(1, 2))
pManageMtdGrid.addWidget(QLabel(), *(1, 3))
pManageMtdGrid.addWidget(QLabel(), *(1, 4))
pManageMtdGrid.addWidget(QLabel(), *(1, 5))
self.pageTechAnPManageMthdWidget.setLayout(pManageMtdGrid)
pageMainVerticalBox.addWidget(self.pageTechAnPManageMthdWidget)
space = QWidget()
space.setFixedSize(0, 0)
pageMainVerticalBox.addWidget(space)
self.pageTechAnLaunchButton = QPushButton("Launch")
self.pageTechAnLaunchButton.setFont(self.contentFont)
self.pageTechAnLaunchButton.setFixedSize(860, 40)
self.pageTechAnLaunchButton.setStyleSheet(self.launchWdgtReadyQSS)
self.pageTechAnLaunchButton.clicked.connect(self.pageTechAnLaunch)
pageMainVerticalBox.addWidget(self.pageTechAnLaunchButton)
page.setLayout(pageMainVerticalBox)
self.pagesStatus[ci] = 1
page.show()
def pageTechAnLaunch(self):
capital = int("".join(re.split("\$| |,", self.pageTechAnCapitalEdit.text())))
securityCode = self.pageTechAnSecurityCombo.currentText()
investmentStrategies = []
if self.pageTechAnStrategyCheckBoxACOscillator.isChecked() : investmentStrategies.append("ACOscillator")
if self.pageTechAnStrategyCheckBoxCCICorrection.isChecked() : investmentStrategies.append("CCI_Correction")
if self.pageTechAnStrategyCheckBoxDMRSIADX.isChecked() : investmentStrategies.append("DM_RSI_ADX")
if self.pageTechAnStrategyCheckBoxMACD.isChecked() : investmentStrategies.append("MACD")
if self.pageTechAnStrategyCheckBoxBreakoutsSwing.isChecked(): investmentStrategies.append("breakouts_swing")
if self.pageTechAnStrategyCheckBoxOscillator313.isChecked() : investmentStrategies.append("oscillator3_13")
startTime = self.pageTechAnStartTimeEdit.text()
endTime = self.pageTechAnEndTimeEdit.text()
tradeStrategy = None
if self.pageTechAnTStrRadioButtonVWAP.isChecked() : tradeStrategy = "VWAP"
if self.pageTechAnTStrRadioButtonTWAP.isChecked() : tradeStrategy = "TWAP"
# if self.pageTechAnTStrRadioButtonPOV.isChecked() : tradeStrategy = "POV"
# if self.pageTechAnTStrRadioButtonSimple.isChecked() : tradeStrategy = "Simple"
if self.pageTechAnTStrRadioButtonNONE.isChecked() : tradeStrategy = "Default"
positionManagement = None
if self.pageTechAnPMtdRadioButtonFixedFraction.isChecked() : positionManagement = "FixedFraction"
if self.pageTechAnPMtdRadioButtonMaximDrawDown.isChecked() : positionManagement = "MaximumDrawDown"
thread.start_new_thread(self.ATM.launchTechnicalAnalysis, (capital, securityCode, investmentStrategies, startTime, endTime, tradeStrategy, positionManagement))
def pageTechAnLaunchProcess(self):
self.pageTechAnLaunchButton.setStyleSheet(self.launchWdgtProcesQSS)
self.pageTechAnLaunchButton.setText("Processing")
def pageTechAnLaunchFinish(self):
self.pageTechAnLaunchButton.setStyleSheet(self.launchWdgtReadyQSS)
self.pageTechAnLaunchButton.setText("Re-Launch")
# The pair trading page
def pairTrPage(self):
# hide all pages to show self page
for pi in range(0, len(self.pages)):
self.toolButtons[pi].setStyleSheet(self.toolButtonHideQSS)
self.pages[pi].hide()
print "in pair trading page"
ci = 1
page = self.pages[ci]
self.toolButtons[ci].setStyleSheet(self.toolButtonFocusQSS)
if self.pagesStatus[ci] == 0:
self.pagePairTrConfigWidget = QWidget(page)
self.pagePairTrConfigWidget.setFixedSize(860, 700)
pageMainVerticalBox = QVBoxLayout()
pageMainVerticalBox.setContentsMargins(0, 5, 0, 0)
self.pagePairTrTitleLabel = QLabel("Pair Trading")
self.pagePairTrTitleLabel.setFixedSize(860, 25)
self.pagePairTrTitleLabel.setStyleSheet(self.pageTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrTitleLabel)
self.pagePairTrCapitalLabel = QLabel("Capital Config", page)
self.pagePairTrCapitalLabel.setFixedSize(860, 25)
self.pagePairTrCapitalLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrCapitalLabel)
capitalHbox = QHBoxLayout()
capitalHbox.setContentsMargins(30, 10, 0, 10)
self.pagePairTrCapitalInputLabel = QLabel("Capital: ", page)
self.pagePairTrCapitalInputLabel.setFont(self.contentFont)
self.pagePairTrCapitalInputLabel.setFixedSize(100, 25)
self.pagePairTrCapitalInputLabel.setStyleSheet(self.itemNameQSS)
capitalHbox.addWidget(self.pagePairTrCapitalInputLabel)
self.pagePairTrCapitalEdit = QLineEdit("$ 100,000,000")
self.pagePairTrCapitalEdit.setStyleSheet(self.lineEditQSS)
self.pagePairTrCapitalEdit.setFixedSize(300, 25)
self.pagePairTrCapitalEdit.setEnabled(False)
capitalHbox.addWidget(self.pagePairTrCapitalEdit)
capitalHbox.addStretch(1)
pageMainVerticalBox.addLayout(capitalHbox)
self.pagePairTrSecurityLabel = QLabel("Security Select", page)
self.pagePairTrSecurityLabel.setFixedSize(860, 25)
self.pagePairTrSecurityLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrSecurityLabel)
securityHbox = QHBoxLayout()
securityHbox.setContentsMargins(30, 10, 0, 10)
self.pagePairTrSecurityCode = QLabel("Security Basket: ", page)
self.pagePairTrSecurityCode.setFont(self.contentFont)
self.pagePairTrSecurityCode.setFixedSize(100, 25)
self.pagePairTrSecurityCode.setStyleSheet(self.itemNameQSS)
securityHbox.addWidget(self.pagePairTrSecurityCode)
self.pagePairTrSecurities = QTextEdit(page)
self.pagePairTrSecurities.setEnabled(False)
self.pagePairTrSecurities.setFixedSize(600, 148)
securities = ""
for item in self.ATM.data.getAssetList("./dataManager/data/hsi_stocks"): securities += item + ' '
self.pagePairTrSecurities.setText(securities)
securityHbox.addWidget(self.pagePairTrSecurities)
securityHbox.addStretch(1)
pageMainVerticalBox.addLayout(securityHbox)
self.pagePairTrTimeSpanLabel = QLabel("Trading Time Config", page)
self.pagePairTrTimeSpanLabel.setFixedSize(860, 25)
self.pagePairTrTimeSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrTimeSpanLabel)
timeVbox = QVBoxLayout()
timeVbox.setContentsMargins(30, 10, 0, 10)
startTimeHbox = QHBoxLayout()
self.pagePairTrStartTimeName = QLabel("Start Time: ", page)
self.pagePairTrStartTimeName.setFont(self.contentFont)
self.pagePairTrStartTimeName.setFixedSize(100, 25)
self.pagePairTrStartTimeName.setStyleSheet(self.itemNameQSS)
startTimeHbox.addWidget(self.pagePairTrStartTimeName)
self.pagePairTrStartTimeEdit = QLineEdit("2016-02-10 16:00:00")
self.pagePairTrStartTimeEdit.setEnabled(False)
self.pagePairTrStartTimeEdit.setStyleSheet(self.lineEditQSS)
self.pagePairTrStartTimeEdit.setFixedSize(300, 25)
startTimeHbox.addWidget(self.pagePairTrStartTimeEdit)
startTimeHbox.addStretch(1)
timeVbox.addLayout(startTimeHbox)
endTimeHbox = QHBoxLayout()
self.pagePairTrEndTimeName = QLabel("End Time: ", page)
self.pagePairTrEndTimeName.setFont(self.contentFont)
self.pagePairTrEndTimeName.setFixedSize(100, 25)
self.pagePairTrEndTimeName.setStyleSheet(self.itemNameQSS)
endTimeHbox.addWidget(self.pagePairTrEndTimeName)
self.pagePairTrEndTimeEdit = QLineEdit("2016-02-26 16:00:00")
self.pagePairTrEndTimeEdit.setEnabled(False)
self.pagePairTrEndTimeEdit.setStyleSheet(self.lineEditQSS)
self.pagePairTrEndTimeEdit.setFixedSize(300, 25)
endTimeHbox.addWidget(self.pagePairTrEndTimeEdit)
endTimeHbox.addStretch(1)
timeVbox.addLayout(endTimeHbox)
pageMainVerticalBox.addLayout(timeVbox)
self.pagePairTrTStrSpanLabel = QLabel("Trading Strategies Select", page)
self.pagePairTrTStrSpanLabel.setFixedSize(860, 25)
self.pagePairTrTStrSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrTStrSpanLabel)
self.pagePairTrTradeStrateWidget = QWidget(page)
self.pagePairTrTradeStrateWidget.setFixedSize(700, 40)
tradeStratGrid = QGridLayout()
tradeStratGrid.setContentsMargins(30, 5, 0, 5)
self.pagePairTrTStrRadioButtonVWAP = QRadioButton(" VWAP")
self.pagePairTrTStrRadioButtonVWAP.setCheckable(False)
self.pagePairTrTStrRadioButtonTWAP = QRadioButton(" TWAP")
self.pagePairTrTStrRadioButtonTWAP.setChecked(True)
self.pagePairTrTStrRadioButtonNONE = QRadioButton(" NONE")
tradeStratGrid.addWidget(self.pagePairTrTStrRadioButtonVWAP, *(1, 1))
tradeStratGrid.addWidget(self.pagePairTrTStrRadioButtonTWAP, *(1, 2))
tradeStratGrid.addWidget(self.pagePairTrTStrRadioButtonNONE, *(1, 3))
tradeStratGrid.addWidget(QLabel(), *(1, 4))
tradeStratGrid.addWidget(QLabel(), *(1, 5))
self.pagePairTrTradeStrateWidget.setLayout(tradeStratGrid)
pageMainVerticalBox.addWidget(self.pagePairTrTradeStrateWidget)
self.pagePairTrPManSpanLabel = QLabel("Position Management Method Select", page)
self.pagePairTrPManSpanLabel.setFixedSize(860, 25)
self.pagePairTrPManSpanLabel.setStyleSheet(self.pageSubTitleQSS)
pageMainVerticalBox.addWidget(self.pagePairTrPManSpanLabel)
self.pagePairTrPManageMthdWidget = QWidget(page)
self.pagePairTrPManageMthdWidget.setFixedSize(700, 40)
pManageMtdGrid = QGridLayout()
pManageMtdGrid.setContentsMargins(30, 10, 0, 10)
self.pagePairTrPMtdRadioButtonFixedFraction = QRadioButton(" Fixed Fraction")
self.pagePairTrPMtdRadioButtonFixedFraction.setChecked(True)
self.pagePairTrPMtdRadioButtonMaximDrawDown = QRadioButton(" Max Draw Down")
pManageMtdGrid.addWidget(self.pagePairTrPMtdRadioButtonFixedFraction, *(1, 1))
pManageMtdGrid.addWidget(self.pagePairTrPMtdRadioButtonMaximDrawDown, *(1, 2))
pManageMtdGrid.addWidget(QLabel(), *(1, 3))
pManageMtdGrid.addWidget(QLabel(), *(1, 4))
pManageMtdGrid.addWidget(QLabel(), *(1, 5))
self.pagePairTrPManageMthdWidget.setLayout(pManageMtdGrid)
pageMainVerticalBox.addWidget(self.pagePairTrPManageMthdWidget)
space = QWidget()
space.setFixedSize(0, 0)
pageMainVerticalBox.addWidget(space)
self.pagePairTrLaunchButton = QPushButton("Launch")
self.pagePairTrLaunchButton.setFont(self.contentFont)
self.pagePairTrLaunchButton.setFixedSize(860, 40)
self.pagePairTrLaunchButton.setStyleSheet(self.launchWdgtReadyQSS)
self.pagePairTrLaunchButton.clicked.connect(self.pagePairTrdLaunch)
pageMainVerticalBox.addWidget(self.pagePairTrLaunchButton)
page.setLayout(pageMainVerticalBox)
self.pagesStatus[ci] = 1
page.show()
def pagePairTrdLaunch(self):
capital = int("".join(re.split("\$| |,", self.pagePairTrCapitalEdit.text())))
investmentStrategies = ["pairstrading", ]
startTime = self.pagePairTrStartTimeEdit.text()
endTime = self.pagePairTrEndTimeEdit.text()
tradeStrategy = None
if self.pagePairTrTStrRadioButtonVWAP.isChecked(): tradeStrategy = "VWAP"
if self.pagePairTrTStrRadioButtonTWAP.isChecked(): tradeStrategy = "TWAP"
if self.pagePairTrTStrRadioButtonNONE.isChecked(): tradeStrategy = "Default"
positionManagement = None
if self.pagePairTrPMtdRadioButtonFixedFraction.isChecked(): positionManagement = "FixedFraction"
if self.pagePairTrPMtdRadioButtonMaximDrawDown.isChecked(): positionManagement = "MaximumDrawDown"
thread.start_new_thread(self.ATM.launchPairTradingAnalysis, (capital, investmentStrategies, startTime, endTime, tradeStrategy, positionManagement))
def pagePairTrdLaunchProcess(self):
self.pagePairTrLaunchButton.setStyleSheet(self.launchWdgtProcesQSS)
self.pagePairTrLaunchButton.setText("Processing")
def pagePairTrdLaunchFinish(self):
self.pagePairTrLaunchButton.setStyleSheet(self.launchWdgtReadyQSS)
self.pagePairTrLaunchButton.setText("Re-Launch")
def atoTrdPage(self):
for pi in range(0,len(self.pages)):
self.toolButtons[pi].setStyleSheet(self.toolButtonHideQSS)
self.pages[pi].hide()
print "in monitor page"
ci = 2
page = self.pages[ci]
self.toolButtons[ci].setStyleSheet(self.toolButtonFocusQSS)
if self.pagesStatus[ci] == 0:
if not page.layout() == None:
while page.layout().count() > 0:
page.layout().takeAt(0).widget().setParent(None)
if page.layout() == None:
self.pageAutoTrdPageMainVerticalBox = QVBoxLayout()
self.pageAutoTrdPageMainVerticalBox.setContentsMargins(0, 5, 0, 0)
page.setLayout(self.pageAutoTrdPageMainVerticalBox)
self.pageAutoTrdTitleLabel = QLabel("Monitor", page)
self.pageAutoTrdTitleLabel.setFixedSize(860, 25)
self.pageAutoTrdTitleLabel.setStyleSheet(self.pageTitleQSS)
self.pageAutoTrdPageMainVerticalBox.addWidget(self.pageAutoTrdTitleLabel)
pnlReport = self.ATM.report
if not len(self.ATM.strategies.strategiesPool.keys()) == 0:
self.pageAtoTrdPageScroll = QScrollArea(page)
self.pageAtoTrdPageScroll.setWidgetResizable(True)
self.pageAtoTrdPageScroll.setBackgroundRole(QPalette.NoRole)
self.pageAtoTrdPageScroll.setStyleSheet("background: transparent")
self.pageAtoTrdPageScroll.setFixedSize(860, 635)
self.pageAtoTrdScrollContentsWidget = QWidget(page)
scrollContentVBox = QVBoxLayout()
scrollContentVBox.setAlignment(Qt.AlignTop)
scrollContentVBox.setContentsMargins(0, 0, 0, 0)
self.pageAtoTrdSignalPlotLabel = QLabel("Signals Plots", page)
self.pageAtoTrdSignalPlotLabel.setFixedSize(860, 25)
self.pageAtoTrdSignalPlotLabel.setStyleSheet(self.pageSubTitleQSS)
scrollContentVBox.addWidget(self.pageAtoTrdSignalPlotLabel)
path = "./strategies/image/"
for file in os.listdir(path):
if file.endswith(".png") and file.split('.')[0] in self.ATM.strategies.strategiesPool.keys():
pageAtoTrdSignalPlotStrategyLabel = QLabel(file.split('.')[0], page)
pageAtoTrdSignalPlotStrategyLabel.setFixedSize(860, 25)
pageAtoTrdSignalPlotStrategyLabel.setStyleSheet(self.pageSubSubTitleQSS)
scrollContentVBox.addWidget(pageAtoTrdSignalPlotStrategyLabel)
widget = QWidget()
widget.setFixedHeight(300)
hbox = QHBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.setAlignment(Qt.AlignCenter)
lbl = QLabel()
pixmap = QPixmap(path + file)
scaled_pixmap = pixmap.scaled(860, 330, Qt.KeepAspectRatio)
lbl.setPixmap(scaled_pixmap)
hbox.addWidget(lbl)
widget.setLayout(hbox)
scrollContentVBox.addWidget(widget)
self.pageAtoTrdAllSignalsLabel = QLabel("All Signals", page)
self.pageAtoTrdAllSignalsLabel.setFixedSize(860, 25)
self.pageAtoTrdAllSignalsLabel.setStyleSheet(self.pageSubTitleQSS)
scrollContentVBox.addWidget(self.pageAtoTrdAllSignalsLabel)
self.pageAtoTrdAllSignalsTitle = QWidget(page)
self.pageAtoTrdAllSignalsTitle.setFixedSize(860, 25)
self.pageAtoTrdAllSignalsTitle.setStyleSheet(self.pageSubSubTitleQSS)
titlesHBox = QHBoxLayout()
titlesHBox.setContentsMargins(10, 0, 20, 0)
titlesHBox.addWidget(QLabel("Code"))
titlesHBox.addWidget(QLabel("Time"))
titlesHBox.addWidget(QLabel("Action"))
titlesHBox.addWidget(QLabel("Qnt"))
titlesHBox.addWidget(QLabel("Price"))
titlesHBox.addWidget(QLabel("Volumn"))
titlesHBox.addWidget(QLabel("Strategy"))
self.pageAtoTrdAllSignalsTitle.setLayout(titlesHBox)
scrollContentVBox.addWidget(self.pageAtoTrdAllSignalsTitle)
signals = self.ATM.strategies.signals
if not len(signals) == 0:
for i in xrange(len(signals)):
widget = QWidget(page)
widget.setFixedHeight(15)
widget.setStyleSheet("color:#ffffff")
signalHBox = QHBoxLayout()
signalHBox.setContentsMargins(20, 0, 10, 0)
signalHBox.addWidget(QLabel(signals.ix[i]["Code"]))
signalHBox.addWidget(QLabel(str(signals.ix[i]["Time"])))
signalHBox.addWidget(QLabel(signals.ix[i]["Action"]))
signalHBox.addWidget(QLabel(str(signals.ix[i]["Qnt"])))
signalHBox.addWidget(QLabel(str(signals.ix[i]["Price"])))
signalHBox.addWidget(QLabel(str(signals.ix[i]["Volume"])))
signalHBox.addWidget(QLabel(signals.ix[i]["Strategy"]))
widget.setLayout(signalHBox)
scrollContentVBox.addWidget(widget)
else:
widget = QLabel("No Data.")
widget.setFixedSize(860, 550)
widget.setStyleSheet(self.noDataLabelQSS)
widget.setAlignment(Qt.AlignCenter)
scrollContentVBox.addWidget(widget)
self.pageAtoTrdScrollContentsWidget.setLayout(scrollContentVBox)
self.pageAtoTrdPageScroll.setWidget(self.pageAtoTrdScrollContentsWidget)
self.pageAutoTrdPageMainVerticalBox.addWidget(self.pageAtoTrdPageScroll)
else:
widget = QLabel("No Data.")
widget.setFixedSize(860, 550)
widget.setStyleSheet(self.noDataLabelQSS)
widget.setAlignment(Qt.AlignCenter)
self.pageAutoTrdPageMainVerticalBox.addWidget(widget)
self.pagesStatus[ci] = 1
page.show()
def trdPnlPage(self):
for pi in range(0,len(self.pages)):
self.toolButtons[pi].setStyleSheet(self.toolButtonHideQSS)
self.pages[pi].hide()
print "in profit and loss report page"
ci = 3
page = self.pages[ci]
self.toolButtons[ci].setStyleSheet(self.toolButtonFocusQSS)
if self.pagesStatus[ci] == 0:
if not page.layout() == None:
while page.layout().count() > 0:
page.layout().takeAt(0).widget().setParent(None)
if page.layout() == None:
self.pageTrdPnlPageMainVerticalBox = QVBoxLayout()
self.pageTrdPnlPageMainVerticalBox.setContentsMargins(0, 5, 0, 0)
page.setLayout(self.pageTrdPnlPageMainVerticalBox)
self.pageTrdHisTitleLabel = QLabel("Profit And Loss Report", page)
self.pageTrdHisTitleLabel.setFixedSize(860, 25)
self.pageTrdHisTitleLabel.setStyleSheet(self.pageTitleQSS)
self.pageTrdPnlPageMainVerticalBox.addWidget(self.pageTrdHisTitleLabel)
pnlReport = self.ATM.report
if not len(pnlReport) == 0:
self.pageTrdHisBookTitles = QWidget(page)
self.pageTrdHisBookTitles.setFixedSize(860, 25)
self.pageTrdHisBookTitles.setStyleSheet(self.pageSubTitleQSS)
titlesHBox = QHBoxLayout()
titlesHBox.setContentsMargins(10, 0, 20, 0)
strategy = QLabel("Strategy")
titlesHBox.addWidget(QLabel("Strategy"))
titlesHBox.addWidget(QLabel("Realized PnL"))
titlesHBox.addWidget(QLabel("Return"))
areturn = QLabel("Annual Return")
areturn.setFixedWidth(130)
titlesHBox.addWidget(areturn)
titlesHBox.addWidget(QLabel("Volatility"))
titlesHBox.addWidget(QLabel("Sharpe Ratio"))
mdd = QLabel("Maximum Draw Down")
mdd.setFixedWidth(155)
titlesHBox.addWidget(mdd)
self.pageTrdHisBookTitles.setLayout(titlesHBox)
self.pageTrdPnlPageMainVerticalBox.addWidget(self.pageTrdHisBookTitles)
self.pageTrdHisPageScroll = QScrollArea(page)
self.pageTrdHisPageScroll.setWidgetResizable(True)
self.pageTrdHisPageScroll.setBackgroundRole(QPalette.NoRole)
self.pageTrdHisPageScroll.setStyleSheet("background: transparent")
self.pageTrdHisPageScroll.setFixedSize(860, 600)
self.pageTrdHisScrollContentsWidget = QWidget(page)
scrollContentVBox = QVBoxLayout()
scrollContentVBox.setAlignment(Qt.AlignTop)
scrollContentVBox.setContentsMargins(0, 0, 0, 0)
for i in xrange(0, len(pnlReport)):
widget = QWidget()
widget.setFixedHeight(15)
if pnlReport.ix[i]["realized PnL"] > 0: widget.setStyleSheet("color:#fa2020")
if pnlReport.ix[i]["realized PnL"] < 0: widget.setStyleSheet("color:#27AE60")
hbox = QHBoxLayout()
hbox.setContentsMargins(20, 0, 10, 0)
strategy = QLabel(pnlReport.ix[i]["Strategy"])
strategy.setFixedWidth(100)
hbox.addWidget(strategy)
hbox.addWidget(QLabel(str("{0:.2f}".format(pnlReport.ix[i]["realized PnL"]))))
hbox.addWidget(QLabel(str("{0:.4f}".format(pnlReport.ix[i]["Return"]))))
areturn = QLabel(str("{0:.4f}".format(pnlReport.ix[i]["Annualized Return"])))
# hbox.addWidget(QLabel(str("{0:.2f}".format(tradeHistory.ix[i]["QntPer"] * 100))))
areturn.setFixedWidth(130)
hbox.addWidget(areturn)
hbox.addWidget(QLabel(str("{0:.4f}".format(pnlReport.ix[i]["Volatility"]))))
hbox.addWidget(QLabel(str("{0:.4f}".format(pnlReport.ix[i]["Sharpe Ratio"]))))
mdd = QLabel(str("{0:.6f}".format(pnlReport.ix[i]["MDD"])))
mdd.setFixedWidth(155)
hbox.addWidget(mdd)
widget.setLayout(hbox)
scrollContentVBox.addWidget(widget)
self.pageTrdHisScrollContentsWidget.setLayout(scrollContentVBox)
self.pageTrdHisPageScroll.setWidget(self.pageTrdHisScrollContentsWidget)
self.pageTrdPnlPageMainVerticalBox.addWidget(self.pageTrdHisPageScroll)
else:
widget = QLabel("No Data.")
widget.setFixedSize(860, 550)
widget.setStyleSheet(self.noDataLabelQSS)
widget.setAlignment(Qt.AlignCenter)
self.pageTrdPnlPageMainVerticalBox.addWidget(widget)
self.pagesStatus[ci] = 1
page.show()
def trdHisPage(self):
for pi in range(0,len(self.pages)):
self.toolButtons[pi].setStyleSheet(self.toolButtonHideQSS)
self.pages[pi].hide()
print "in trade history page"
ci = 4
page = self.pages[ci]
self.toolButtons[ci].setStyleSheet(self.toolButtonFocusQSS)
if self.pagesStatus[ci] == 0:
if not page.layout() == None:
while page.layout().count() > 0:
page.layout().takeAt(0).widget().setParent(None)
if page.layout() == None:
self.pageTrdHisPageMainVerticalBox = QVBoxLayout()
self.pageTrdHisPageMainVerticalBox.setContentsMargins(0, 5, 0, 0)
page.setLayout(self.pageTrdHisPageMainVerticalBox)
self.pageTrdHisTitleLabel = QLabel("Trade History", page)
self.pageTrdHisTitleLabel.setFixedSize(860, 25)
self.pageTrdHisTitleLabel.setStyleSheet(self.pageTitleQSS)
self.pageTrdHisPageMainVerticalBox.addWidget(self.pageTrdHisTitleLabel)
tradeHistory = self.ATM.account.queryTradeHistory()
if not len(tradeHistory) == 0:
self.pageTrdHisBookTitles = QWidget(page)
self.pageTrdHisBookTitles.setFixedSize(860, 25)
self.pageTrdHisBookTitles.setStyleSheet(self.pageSubTitleQSS)
titlesHBox = QHBoxLayout()
titlesHBox.setContentsMargins(10, 0, 20, 0)
code = QLabel("Code")
code.setFixedWidth(100)
titlesHBox.addWidget(code)
time = QLabel("Time")
time.setFixedWidth(145)
titlesHBox.addWidget(time)
titlesHBox.addWidget(QLabel("Action"))
qnt = QLabel("Qnt")
qnt.setFixedWidth(50)
titlesHBox.addWidget(qnt)
titlesHBox.addWidget(QLabel("Occupy"))
titlesHBox.addWidget(QLabel("Price"))
titlesHBox.addWidget(QLabel("PnL"))
titlesHBox.addWidget(QLabel("Equity"))
strategy = QLabel("Strategy")
strategy.setFixedWidth(100)
titlesHBox.addWidget(strategy)
self.pageTrdHisBookTitles.setLayout(titlesHBox)
self.pageTrdHisPageMainVerticalBox.addWidget(self.pageTrdHisBookTitles)
self.pageTrdHisPageScroll = QScrollArea(page)
self.pageTrdHisPageScroll.setWidgetResizable(True)
self.pageTrdHisPageScroll.setBackgroundRole(QPalette.NoRole)
self.pageTrdHisPageScroll.setStyleSheet("background: transparent")
self.pageTrdHisPageScroll.setFixedSize(860, 600)
self.pageTrdHisScrollContentsWidget = QWidget(page)
scrollContentVBox = QVBoxLayout()
scrollContentVBox.setContentsMargins(0, 0, 0, 0)
scrollContentVBox.setAlignment(Qt.AlignTop)
for i in xrange(0, len(tradeHistory)):
widget = QWidget()
widget.setFixedHeight(15)
if tradeHistory.ix[i]["Action"] == "Short" : widget.setStyleSheet("color:#27AE60")
if tradeHistory.ix[i]["Action"] == "SellToCover" : widget.setStyleSheet("color:#27AE60")
if tradeHistory.ix[i]["Action"] == "Long" : widget.setStyleSheet("color:#fa2020")
if tradeHistory.ix[i]["Action"] == "BuyToCover" : widget.setStyleSheet("color:#fa2020")
hbox = QHBoxLayout()
hbox.setContentsMargins(20, 0, 10, 0)
code = QLabel(str(tradeHistory.ix[i]["Code"])); code.setFixedWidth(100); hbox.addWidget(code);
time = QLabel(str(tradeHistory.ix[i]["Time"])); time.setFixedWidth(145); hbox.addWidget(time);
hbox.addWidget(QLabel(tradeHistory.ix[i]["Action"]))
qnt = QLabel(str(tradeHistory.ix[i]["Qnt"])); qnt.setFixedWidth(50); hbox.addWidget(qnt);
hbox.addWidget(QLabel(str("{0:.2f}".format(tradeHistory.ix[i]["QntPer"] * 100))+"%"))
hbox.addWidget(QLabel(str(round(tradeHistory.ix[i]["Price"]))))
pnl = QLabel()
if not tradeHistory.ix[i]["PnL"] == "": pnl = QLabel(str(round(float(tradeHistory.ix[i]["PnL"]))));
hbox.addWidget(pnl)
hbox.addWidget(QLabel(str(round(tradeHistory.ix[i]["Equity"]))))
strategy = QLabel(tradeHistory.ix[i]["Strategy"]); strategy.setFixedWidth(100); hbox.addWidget(strategy);
widget.setLayout(hbox)
scrollContentVBox.addWidget(widget)
self.pageTrdHisScrollContentsWidget.setLayout(scrollContentVBox)
self.pageTrdHisPageScroll.setWidget(self.pageTrdHisScrollContentsWidget)
self.pageTrdHisPageMainVerticalBox.addWidget(self.pageTrdHisPageScroll)
else:
widget = QLabel("No Data.")
widget.setFixedSize(860, 550)
widget.setStyleSheet(self.noDataLabelQSS)
widget.setAlignment(Qt.AlignCenter)
self.pageTrdHisPageMainVerticalBox.addWidget(widget)
self.pagesStatus[ci] = 1
page.show()
def setStyle(self):
self.setStyleSheet(
"QToolBar {" +
"background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #203138, stop: 1.0 #000000);" +
"border-right: 1px solid #065279;" +
"padding: 5px}" +
"QToolBar > QToolButton {" +
"color: #ffffff;" +
"font-family:'ArialRegular';" +
"font-size: 14px}" +
"QToolBar > QToolButton:hover {" +
"background: qlineargradient(x1: 0, y1: 1, x2: 0, y2: 0, stop: 0 #ffcb06, stop: 1.0 #ff9c28);" +
"border-radius:3px}" +
"QLabel {" +
"font-family:'ArialRegular';" +
"padding: 10px;}" +
"QPushButton {" +
"height: 20px}" +
"QComboBox {" +
"border-radius: 1px; " +
"border-top-right-radius:11px;" +
"border-bottom-right-radius:11px;" +
"font-family:'ArialRegular'}" +
"QComboBox::drop-down {" +
"width:15px;" +
"background-color: #ff9c28;" +
"border-top-right-radius:10px;" +
"border-bottom-right-radius:10px;}" +
"QCheckBox {" +
"color: #ffffff;" +
"font-family:'ArialRegular'}" +
"QCheckBox::indicator {" +
"background-color:#ffffff;" +
"border-radius: 1px}" +
"QCheckBox::indicator:checked {" +
"background-color:#ff9c28}" +
"QLineEdit {" +
"background:#ff9c28;" +
"border-radius:1px}" +
"QLineEdit:focus {" +
"border-radius:1px;}" +
"QRadioButton {color: #ffffff}" +
"QScrollArea {border:0px; background:transparent}" +
"QTextEdit {padding-left: 5px; border: 0px; font-family: 'ArialRegular'; font-weight:20; font-size:14px; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #ec2f4b, stop: 1.0 #85030f);}"
)
self.mainBoardQSS = "padding:0px; background:qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #203138, stop: 1.0 #000000);"
self.pagesQSS = "background:none; padding: 0px"
self.pageTitleQSS = "padding-left:5px; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #ec2f4b, stop: 1.0 #85030f); color: #ffffff; font-family: 'ArialRegular'; font-weight:20; font-size: 16px"
self.pageSubTitleQSS = "padding-left:5px; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #495d76, stop: 1.0 #1f4e7c); color: #dddddd; font-family: 'ArialRegular'; font-weight:20; font-size: 14px"
self.pageSubSubTitleQSS = "padding-left:5px; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #646464, stop: 1.0 #838683); color: #dddddd; font-family: 'ArialRegular'; font-weight:20; font-size: 14px"
self.toolButtonHideQSS = "background:none; font-size: 14px; font-family:'ArialRegular'"
self.toolButtonFocusQSS = "background:qlineargradient(x1: 0, y1: 1, x2: 0, y2: 0, stop: 0 #ffcb06, stop: 1.0 #ff9c28);border-radius:3px; color:#000000"
self.itemNameQSS = "color: #ffffff; font-family: 'ArialRegular'"
self.comboQSS = "padding-left:5px;background:qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #eeeeee, stop: 1.0 #dddddd);"
self.lineEditQSS = "background:qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #eeeeee, stop: 1.0 #dddddd);border: 0px; padding-left:5px; font-family:'ArialRegular'; font-weight:20; font-size: 14px"
self.launchWdgtReadyQSS = "background:qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #004900, stop: 1.0 #033502);border: 0px; color:#ffffff"
self.launchWdgtProcesQSS= "background:qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #006602, stop: 1.0 #007b03);border: 0px; color:#ffffff"
self.tableTitleQSS = "padding-left:5px; background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1, stop: 0 #495d76, stop: 1.0 #1f4e7c); color: #dddddd; font-family: 'ArialRegular'; font-weight:20; font-size: 14px"
self.noDataLabelQSS = "color: #ffffff; font-family: ArialRegular; font-weight: 20; font-size: 14px"
self.pageTitleFont = QFont('ArialRegular')
self.titleFont = QFont('ArialRegular')
self.contentFont = QFont('ArialRegular')
self.pageTitleColor = "#ffffff"
self.titleColor = "#ffffff"
self.contentColor = "#ffffff"
def __init__(self):
QWidget.__init__(self)
self.setWindowTitle(_("Examine simulation results in time domain"))
self.snapshots_hbox = QHBoxLayout()
self.snapshots_label= QLabel("Snapshots")
self.snapshots_hbox.addWidget(self.snapshots_label)
self.snapshots_combobox=QComboBox()
self.snapshots_hbox.addWidget(self.snapshots_combobox)
self.snapshots_widget=QWidget()
self.snapshot_dirs=self.find_snapshots()
for i in range(0,len(self.snapshot_dirs)):
self.snapshots_combobox.addItem(self.snapshot_dirs[i])
self.snapshots_combobox.currentIndexChanged.connect(self.callback_snapshots_combobox)
self.snapshots_widget.setLayout(self.snapshots_hbox)
self.main_vbox = QVBoxLayout()
self.slider=snapshot_slider()
self.slider.set_path(os.path.join(os.getcwd(),"snapshots"))
self.slider.changed.connect(self.update)
self.plot=plot_widget()
self.plot.init()
#Toolbar
toolbar=QToolBar()
toolbar.setIconSize(QSize(42, 42))
self.tb_video = QAction(QIcon(os.path.join(get_image_file_path(),"video.png")), _("Save video"), self)
self.tb_video.triggered.connect(self.callback_save)
toolbar.addAction(self.tb_video)
#self.tb_scale = QAction(QIcon(os.path.join(get_image_file_path(),"scale.png")), _("Scale"), self)
#self.tb_scale.triggered.connect(self.callback_scale)
#toolbar.addAction(self.tb_rotate)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), 'Hide', self)
self.help.setStatusTip(_("Close"))
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
##############################################
self.main_vbox.addWidget(toolbar)
self.main_vbox.addWidget(self.plot)
self.main_vbox.addWidget(self.snapshots_widget)
self.main_vbox.addWidget(self.slider)
self.setLayout(self.main_vbox)
self.win_list=windows()
self.win_list.load()
self.win_list.set_window(self,"cmp_class")
if os.path.isfile(os.path.join(os.getcwd(),"snapshots","0","Ec.dat"))==False:
help_window().help_append(["warning.png",_("No electrical slice data has been stored in the snapshots directory. To turn this on set Simulation->Configure->Dump->Dump 1D Slices to on. This will dump a lot of data and slow down your simulations.")])
class SpreadSheet(QMainWindow):
dateFormats = ["dd/M/yyyy", "yyyy/M/dd", "dd.MM.yyyy"]
currentDateFormat = dateFormats[0]
def __init__(self, rows, cols, parent = None):
super(SpreadSheet, self).__init__(parent)
self.toolBar = QToolBar()
self.addToolBar(self.toolBar)
self.formulaInput = QLineEdit()
self.cellLabel = QLabel(self.toolBar)
self.cellLabel.setMinimumSize(80, 0)
self.toolBar.addWidget(self.cellLabel)
self.toolBar.addWidget(self.formulaInput)
self.table = QTableWidget(rows, cols, self)
for c in range(cols):
character = chr(ord('A') + c)
self.table.setHorizontalHeaderItem(c, QTableWidgetItem(character))
self.table.setItemPrototype(self.table.item(rows - 1, cols - 1))
self.table.setItemDelegate(SpreadSheetDelegate(self))
self.createActions()
self.updateColor(0)
self.setupMenuBar()
self.setupContents()
self.setupContextMenu()
self.setCentralWidget(self.table)
self.statusBar()
self.table.currentItemChanged.connect(self.updateStatus)
self.table.currentItemChanged.connect(self.updateColor)
self.table.currentItemChanged.connect(self.updateLineEdit)
self.table.itemChanged.connect(self.updateStatus)
self.formulaInput.returnPressed.connect(self.returnPressed)
self.table.itemChanged.connect(self.updateLineEdit)
self.setWindowTitle("Spreadsheet")
def createActions(self):
self.cell_sumAction = QAction("Sum", self)
self.cell_sumAction.triggered.connect(self.actionSum)
self.cell_addAction = QAction("&Add", self)
self.cell_addAction.setShortcut(Qt.CTRL | Qt.Key_Plus)
self.cell_addAction.triggered.connect(self.actionAdd)
self.cell_subAction = QAction("&Subtract", self)
self.cell_subAction.setShortcut(Qt.CTRL | Qt.Key_Minus)
self.cell_subAction.triggered.connect(self.actionSubtract)
self.cell_mulAction = QAction("&Multiply", self)
self.cell_mulAction.setShortcut(Qt.CTRL | Qt.Key_multiply)
self.cell_mulAction.triggered.connect(self.actionMultiply)
self.cell_divAction = QAction("&Divide", self)
self.cell_divAction.setShortcut(Qt.CTRL | Qt.Key_division)
self.cell_divAction.triggered.connect(self.actionDivide)
self.fontAction = QAction("Font...", self)
self.fontAction.setShortcut(Qt.CTRL | Qt.Key_F)
self.fontAction.triggered.connect(self.selectFont)
self.colorAction = QAction(QIcon(QPixmap(16, 16)), "Background &Color...", self)
self.colorAction.triggered.connect(self.selectColor)
self.clearAction = QAction("Clear", self)
self.clearAction.setShortcut(Qt.Key_Delete)
self.clearAction.triggered.connect(self.clear)
self.aboutSpreadSheet = QAction("About Spreadsheet", self)
self.aboutSpreadSheet.triggered.connect(self.showAbout)
self.exitAction = QAction("E&xit", self)
self.exitAction.setShortcut(QKeySequence.Quit)
self.exitAction.triggered.connect(QApplication.instance().quit)
self.printAction = QAction("&Print", self)
self.printAction.setShortcut(QKeySequence.Print)
self.printAction.triggered.connect(self.print_)
self.firstSeparator = QAction(self)
self.firstSeparator.setSeparator(True)
self.secondSeparator = QAction(self)
self.secondSeparator.setSeparator(True)
def setupMenuBar(self):
self.fileMenu = self.menuBar().addMenu("&File")
self.dateFormatMenu = self.fileMenu.addMenu("&Date format")
self.dateFormatGroup = QActionGroup(self)
for f in self.dateFormats:
action = QAction(f, self, checkable=True,
triggered=self.changeDateFormat)
self.dateFormatGroup.addAction(action)
self.dateFormatMenu.addAction(action)
if f == self.currentDateFormat:
action.setChecked(True)
self.fileMenu.addAction(self.printAction)
self.fileMenu.addAction(self.exitAction)
self.cellMenu = self.menuBar().addMenu("&Cell")
self.cellMenu.addAction(self.cell_addAction)
self.cellMenu.addAction(self.cell_subAction)
self.cellMenu.addAction(self.cell_mulAction)
self.cellMenu.addAction(self.cell_divAction)
self.cellMenu.addAction(self.cell_sumAction)
self.cellMenu.addSeparator()
self.cellMenu.addAction(self.colorAction)
self.cellMenu.addAction(self.fontAction)
self.menuBar().addSeparator()
self.aboutMenu = self.menuBar().addMenu("&Help")
self.aboutMenu.addAction(self.aboutSpreadSheet)
def changeDateFormat(self):
action = self.sender()
oldFormat = self.currentDateFormat
newFormat = self.currentDateFormat = action.text()
for row in range(self.table.rowCount()):
item = self.table.item(row, 1)
date = QDate.fromString(item.text(), oldFormat)
item.setText(date.toString(newFormat))
def updateStatus(self, item):
if item and item == self.table.currentItem():
self.statusBar().showMessage(item.data(Qt.StatusTipRole), 1000)
self.cellLabel.setText("Cell: (%s)" % encode_pos(self.table.row(item),
self.table.column(item)))
def updateColor(self, item):
pixmap = QPixmap(16, 16)
color = QColor()
if item:
color = item.backgroundColor()
if not color.isValid():
color = self.palette().base().color()
painter = QPainter(pixmap)
painter.fillRect(0, 0, 16, 16, color)
lighter = color.lighter()
painter.setPen(lighter)
# light frame
painter.drawPolyline(QPoint(0, 15), QPoint(0, 0), QPoint(15, 0))
painter.setPen(color.darker())
# dark frame
painter.drawPolyline(QPoint(1, 15), QPoint(15, 15), QPoint(15, 1))
painter.end()
self.colorAction.setIcon(QIcon(pixmap))
def updateLineEdit(self, item):
if item != self.table.currentItem():
return
if item:
self.formulaInput.setText(item.data(Qt.EditRole))
else:
self.formulaInput.clear()
def returnPressed(self):
text = self.formulaInput.text()
row = self.table.currentRow()
col = self.table.currentColumn()
item = self.table.item(row, col)
if not item:
self.table.setItem(row, col, SpreadSheetItem(text))
else:
item.setData(Qt.EditRole, text)
self.table.viewport().update()
def selectColor(self):
item = self.table.currentItem()
color = item and QColor(item.background()) or self.table.palette().base().color()
color = QColorDialog.getColor(color, self)
if not color.isValid():
return
selected = self.table.selectedItems()
if not selected:
return
for i in selected:
i and i.setBackground(color)
self.updateColor(self.table.currentItem())
def selectFont(self):
selected = self.table.selectedItems()
if not selected:
return
font, ok = QFontDialog.getFont(self.font(), self)
if not ok:
return
for i in selected:
i and i.setFont(font)
def runInputDialog(self, title, c1Text, c2Text, opText,
outText, cell1, cell2, outCell):
rows = []
cols = []
for r in range(self.table.rowCount()):
rows.append(str(r + 1))
for c in range(self.table.columnCount()):
cols.append(chr(ord('A') + c))
addDialog = QDialog(self)
addDialog.setWindowTitle(title)
group = QGroupBox(title, addDialog)
group.setMinimumSize(250, 100)
cell1Label = QLabel(c1Text, group)
cell1RowInput = QComboBox(group)
c1Row, c1Col = decode_pos(cell1)
cell1RowInput.addItems(rows)
cell1RowInput.setCurrentIndex(c1Row)
cell1ColInput = QComboBox(group)
cell1ColInput.addItems(cols)
cell1ColInput.setCurrentIndex(c1Col)
operatorLabel = QLabel(opText, group)
operatorLabel.setAlignment(Qt.AlignHCenter)
cell2Label = QLabel(c2Text, group)
cell2RowInput = QComboBox(group)
c2Row, c2Col = decode_pos(cell2)
cell2RowInput.addItems(rows)
cell2RowInput.setCurrentIndex(c2Row)
cell2ColInput = QComboBox(group)
cell2ColInput.addItems(cols)
cell2ColInput.setCurrentIndex(c2Col)
equalsLabel = QLabel("=", group)
equalsLabel.setAlignment(Qt.AlignHCenter)
outLabel = QLabel(outText, group)
outRowInput = QComboBox(group)
outRow, outCol = decode_pos(outCell)
outRowInput.addItems(rows)
outRowInput.setCurrentIndex(outRow)
outColInput = QComboBox(group)
outColInput.addItems(cols)
outColInput.setCurrentIndex(outCol)
cancelButton = QPushButton("Cancel", addDialog)
cancelButton.clicked.connect(addDialog.reject)
okButton = QPushButton("OK", addDialog)
okButton.setDefault(True)
okButton.clicked.connect(addDialog.accept)
buttonsLayout = QHBoxLayout()
buttonsLayout.addStretch(1)
buttonsLayout.addWidget(okButton)
buttonsLayout.addSpacing(10)
buttonsLayout.addWidget(cancelButton)
dialogLayout = QVBoxLayout(addDialog)
dialogLayout.addWidget(group)
dialogLayout.addStretch(1)
dialogLayout.addItem(buttonsLayout)
cell1Layout = QHBoxLayout()
cell1Layout.addWidget(cell1Label)
cell1Layout.addSpacing(10)
cell1Layout.addWidget(cell1ColInput)
cell1Layout.addSpacing(10)
cell1Layout.addWidget(cell1RowInput)
cell2Layout = QHBoxLayout()
cell2Layout.addWidget(cell2Label)
cell2Layout.addSpacing(10)
cell2Layout.addWidget(cell2ColInput)
cell2Layout.addSpacing(10)
cell2Layout.addWidget(cell2RowInput)
outLayout = QHBoxLayout()
outLayout.addWidget(outLabel)
outLayout.addSpacing(10)
outLayout.addWidget(outColInput)
outLayout.addSpacing(10)
outLayout.addWidget(outRowInput)
vLayout = QVBoxLayout(group)
vLayout.addItem(cell1Layout)
vLayout.addWidget(operatorLabel)
vLayout.addItem(cell2Layout)
vLayout.addWidget(equalsLabel)
vLayout.addStretch(1)
vLayout.addItem(outLayout)
if addDialog.exec_():
cell1 = cell1ColInput.currentText() + cell1RowInput.currentText()
cell2 = cell2ColInput.currentText() + cell2RowInput.currentText()
outCell = outColInput.currentText() + outRowInput.currentText()
return True, cell1, cell2, outCell
return False, None, None, None
def actionSum(self):
row_first = 0
row_last = 0
row_cur = 0
col_first = 0
col_last = 0
col_cur = 0
selected = self.table.selectedItems()
if selected:
first = selected[0]
last = selected[-1]
row_first = self.table.row(first)
row_last = self.table.row(last)
col_first = self.table.column(first)
col_last = self.table.column(last)
current = self.table.currentItem()
if current:
row_cur = self.table.row(current)
col_cur = self.table.column(current)
cell1 = encode_pos(row_first, col_first)
cell2 = encode_pos(row_last, col_last)
out = encode_pos(row_cur, col_cur)
ok, cell1, cell2, out = self.runInputDialog("Sum cells", "First cell:",
"Last cell:", u"\N{GREEK CAPITAL LETTER SIGMA}", "Output to:",
cell1, cell2, out)
if ok:
row, col = decode_pos(out)
self.table.item(row, col).setText("sum %s %s" % (cell1, cell2))
def actionMath_helper(self, title, op):
cell1 = "C1"
cell2 = "C2"
out = "C3"
current = self.table.currentItem()
if current:
out = encode_pos(self.table.currentRow(), self.table.currentColumn())
ok, cell1, cell2, out = self.runInputDialog(title, "Cell 1", "Cell 2",
op, "Output to:", cell1, cell2, out)
if ok:
row, col = decode_pos(out)
self.table.item(row, col).setText("%s %s %s" % (op, cell1, cell2))
def actionAdd(self):
self.actionMath_helper("Addition", "+")
def actionSubtract(self):
self.actionMath_helper("Subtraction", "-")
def actionMultiply(self):
self.actionMath_helper("Multiplication", "*")
def actionDivide(self):
self.actionMath_helper("Division", "/")
def clear(self):
for i in self.table.selectedItems():
i.setText("")
def setupContextMenu(self):
self.addAction(self.cell_addAction)
self.addAction(self.cell_subAction)
self.addAction(self.cell_mulAction)
self.addAction(self.cell_divAction)
self.addAction(self.cell_sumAction)
self.addAction(self.firstSeparator)
self.addAction(self.colorAction)
self.addAction(self.fontAction)
self.addAction(self.secondSeparator)
self.addAction(self.clearAction)
self.setContextMenuPolicy(Qt.ActionsContextMenu)
def setupContents(self):
titleBackground = QColor(Qt.lightGray)
titleFont = self.table.font()
titleFont.setBold(True)
# column 0
self.table.setItem(0, 0, SpreadSheetItem("Item"))
self.table.item(0, 0).setBackground(titleBackground)
self.table.item(0, 0).setToolTip("This column shows the purchased item/service")
self.table.item(0, 0).setFont(titleFont)
self.table.setItem(1, 0, SpreadSheetItem("AirportBus"))
self.table.setItem(2, 0, SpreadSheetItem("Flight (Munich)"))
self.table.setItem(3, 0, SpreadSheetItem("Lunch"))
self.table.setItem(4, 0, SpreadSheetItem("Flight (LA)"))
self.table.setItem(5, 0, SpreadSheetItem("Taxi"))
self.table.setItem(6, 0, SpreadSheetItem("Dinner"))
self.table.setItem(7, 0, SpreadSheetItem("Hotel"))
self.table.setItem(8, 0, SpreadSheetItem("Flight (Oslo)"))
self.table.setItem(9, 0, SpreadSheetItem("Total:"))
self.table.item(9, 0).setFont(titleFont)
self.table.item(9, 0).setBackground(Qt.lightGray)
# column 1
self.table.setItem(0, 1, SpreadSheetItem("Date"))
self.table.item(0, 1).setBackground(titleBackground)
self.table.item(0, 1).setToolTip("This column shows the purchase date, double click to change")
self.table.item(0, 1).setFont(titleFont)
self.table.setItem(1, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(2, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(3, 1, SpreadSheetItem("15/6/2006"))
self.table.setItem(4, 1, SpreadSheetItem("21/5/2006"))
self.table.setItem(5, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(6, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(7, 1, SpreadSheetItem("16/6/2006"))
self.table.setItem(8, 1, SpreadSheetItem("18/6/2006"))
self.table.setItem(9, 1, SpreadSheetItem())
self.table.item(9, 1).setBackground(Qt.lightGray)
# column 2
self.table.setItem(0, 2, SpreadSheetItem("Price"))
self.table.item(0, 2).setBackground(titleBackground)
self.table.item(0, 2).setToolTip("This column shows the price of the purchase")
self.table.item(0, 2).setFont(titleFont)
self.table.setItem(1, 2, SpreadSheetItem("150"))
self.table.setItem(2, 2, SpreadSheetItem("2350"))
self.table.setItem(3, 2, SpreadSheetItem("-14"))
self.table.setItem(4, 2, SpreadSheetItem("980"))
self.table.setItem(5, 2, SpreadSheetItem("5"))
self.table.setItem(6, 2, SpreadSheetItem("120"))
self.table.setItem(7, 2, SpreadSheetItem("300"))
self.table.setItem(8, 2, SpreadSheetItem("1240"))
self.table.setItem(9, 2, SpreadSheetItem())
self.table.item(9, 2).setBackground(Qt.lightGray)
# column 3
self.table.setItem(0, 3, SpreadSheetItem("Currency"))
self.table.item(0, 3).setBackgroundColor(titleBackground)
self.table.item(0, 3).setToolTip("This column shows the currency")
self.table.item(0, 3).setFont(titleFont)
self.table.setItem(1, 3, SpreadSheetItem("NOK"))
self.table.setItem(2, 3, SpreadSheetItem("NOK"))
self.table.setItem(3, 3, SpreadSheetItem("EUR"))
self.table.setItem(4, 3, SpreadSheetItem("EUR"))
self.table.setItem(5, 3, SpreadSheetItem("USD"))
self.table.setItem(6, 3, SpreadSheetItem("USD"))
self.table.setItem(7, 3, SpreadSheetItem("USD"))
self.table.setItem(8, 3, SpreadSheetItem("USD"))
self.table.setItem(9, 3, SpreadSheetItem())
self.table.item(9,3).setBackground(Qt.lightGray)
# column 4
self.table.setItem(0, 4, SpreadSheetItem("Ex. Rate"))
self.table.item(0, 4).setBackground(titleBackground)
self.table.item(0, 4).setToolTip("This column shows the exchange rate to NOK")
self.table.item(0, 4).setFont(titleFont)
self.table.setItem(1, 4, SpreadSheetItem("1"))
self.table.setItem(2, 4, SpreadSheetItem("1"))
self.table.setItem(3, 4, SpreadSheetItem("8"))
self.table.setItem(4, 4, SpreadSheetItem("8"))
self.table.setItem(5, 4, SpreadSheetItem("7"))
self.table.setItem(6, 4, SpreadSheetItem("7"))
self.table.setItem(7, 4, SpreadSheetItem("7"))
self.table.setItem(8, 4, SpreadSheetItem("7"))
self.table.setItem(9, 4, SpreadSheetItem())
self.table.item(9,4).setBackground(Qt.lightGray)
# column 5
self.table.setItem(0, 5, SpreadSheetItem("NOK"))
self.table.item(0, 5).setBackground(titleBackground)
self.table.item(0, 5).setToolTip("This column shows the expenses in NOK")
self.table.item(0, 5).setFont(titleFont)
self.table.setItem(1, 5, SpreadSheetItem("* C2 E2"))
self.table.setItem(2, 5, SpreadSheetItem("* C3 E3"))
self.table.setItem(3, 5, SpreadSheetItem("* C4 E4"))
self.table.setItem(4, 5, SpreadSheetItem("* C5 E5"))
self.table.setItem(5, 5, SpreadSheetItem("* C6 E6"))
self.table.setItem(6, 5, SpreadSheetItem("* C7 E7"))
self.table.setItem(7, 5, SpreadSheetItem("* C8 E8"))
self.table.setItem(8, 5, SpreadSheetItem("* C9 E9"))
self.table.setItem(9, 5, SpreadSheetItem("sum F2 F9"))
self.table.item(9,5).setBackground(Qt.lightGray)
def showAbout(self):
QMessageBox.about(self, "About Spreadsheet", """
<HTML>
<p><b>This demo shows use of <c>QTableWidget</c> with custom handling for
individual cells.</b></p>
<p>Using a customized table item we make it possible to have dynamic
output in different cells. The content that is implemented for this
particular demo is:
<ul>
<li>Adding two cells.</li>
<li>Subtracting one cell from another.</li>
<li>Multiplying two cells.</li>
<li>Dividing one cell with another.</li>
<li>Summing the contents of an arbitrary number of cells.</li>
</HTML>
""")
def print_(self):
printer = QPrinter(QPrinter.ScreenResolution)
dlg = QPrintPreviewDialog(printer)
view = PrintView()
view.setModel(self.table.model())
dlg.paintRequested.connect(view.print_)
dlg.exec_()
class MainGlyphWindow(QMainWindow):
def __init__(self, glyph, parent=None):
super().__init__(parent)
menuBar = self.menuBar()
fileMenu = QMenu("&File", self)
fileMenu.addAction("E&xit", self.close, QKeySequence.Quit)
menuBar.addMenu(fileMenu)
editMenu = QMenu("&Edit", self)
self._undoAction = editMenu.addAction(
"&Undo", self.undo, QKeySequence.Undo)
self._redoAction = editMenu.addAction(
"&Redo", self.redo, QKeySequence.Redo)
editMenu.addSeparator()
# XXX
action = editMenu.addAction("C&ut", self.cutOutlines, QKeySequence.Cut)
action.setEnabled(False)
self._copyAction = editMenu.addAction(
"&Copy", self.copyOutlines, QKeySequence.Copy)
editMenu.addAction("&Paste", self.pasteOutlines, QKeySequence.Paste)
editMenu.addAction(
"Select &All", self.selectAll, QKeySequence.SelectAll)
editMenu.addAction("&Deselect", self.deselect, "Ctrl+D")
menuBar.addMenu(editMenu)
glyphMenu = QMenu("&Glyph", self)
glyphMenu.addAction("&Next Glyph", lambda: self.glyphOffset(1), "End")
glyphMenu.addAction(
"&Previous Glyph", lambda: self.glyphOffset(-1), "Home")
glyphMenu.addAction("&Go To…", self.changeGlyph, "G")
glyphMenu.addSeparator()
self._layerAction = glyphMenu.addAction(
"&Layer Actions…", self.layerActions, "L")
menuBar.addMenu(glyphMenu)
# create tools and buttons toolBars
self._tools = []
self._toolsToolBar = QToolBar("Tools", self)
self._toolsToolBar.setMovable(False)
self._buttons = []
self._buttonsToolBar = QToolBar("Buttons", self)
self._buttonsToolBar.setMovable(False)
self.addToolBar(self._toolsToolBar)
self.addToolBar(self._buttonsToolBar)
# http://www.setnode.com/blog/right-aligning-a-button-in-a-qtoolbar/
self._layersToolBar = QToolBar("Layers", self)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self._currentLayerBox = QComboBox(self)
self._currentLayerBox.currentIndexChanged.connect(
self._layerChanged)
self._layersToolBar.addWidget(spacer)
self._layersToolBar.addWidget(self._currentLayerBox)
self._layersToolBar.setContentsMargins(0, 0, 2, 0)
self._layersToolBar.setMovable(False)
self.addToolBar(self._layersToolBar)
viewMenu = self.createPopupMenu()
viewMenu.setTitle("View")
viewMenu.addSeparator()
action = viewMenu.addAction("Lock Toolbars", self.lockToolBars)
action.setCheckable(True)
action.setChecked(True)
menuBar.addMenu(viewMenu)
self.view = GlyphView(self)
self.setGlyph(glyph)
selectionTool = self.installTool(SelectionTool)
selectionTool.trigger()
self.installTool(PenTool)
self.installTool(RulerTool)
self.installTool(KnifeTool)
self.installButton(RemoveOverlapButton)
self.setCentralWidget(self.view.scrollArea())
self.resize(900, 700)
self.view.setFocus(True)
# ----------
# Menu items
# ----------
def glyphOffset(self, offset):
currentGlyph = self.view.glyph()
font = currentGlyph.font
glyphOrder = font.glyphOrder
# should be enforced in fontView already
if not (glyphOrder and len(glyphOrder)):
return
index = glyphOrder.index(currentGlyph.name)
newIndex = (index + offset) % len(glyphOrder)
glyph = font[glyphOrder[newIndex]]
self.setGlyph(glyph)
def changeGlyph(self):
glyph = self.view.glyph()
newGlyph, ok = GotoDialog.getNewGlyph(self, glyph)
if ok and newGlyph is not None:
self.setGlyph(newGlyph)
def layerActions(self):
glyph = self.view.glyph()
newLayer, action, ok = LayerActionsDialog.getLayerAndAction(
self, glyph)
if ok and newLayer is not None:
# TODO: whole glyph for now, but consider selection too
if not glyph.name in newLayer:
newLayer.newGlyph(glyph.name)
otherGlyph = newLayer[glyph.name]
otherGlyph.disableNotifications()
if action == "Swap":
tempGlyph = TGlyph()
otherGlyph.drawPoints(tempGlyph.getPointPen())
tempGlyph.width = otherGlyph.width
otherGlyph.clearContours()
glyph.drawPoints(otherGlyph.getPointPen())
otherGlyph.width = glyph.width
if action != "Copy":
glyph.disableNotifications()
glyph.clearContours()
if action == "Swap":
tempGlyph.drawPoints(glyph.getPointPen())
glyph.width = tempGlyph.width
glyph.enableNotifications()
otherGlyph.enableNotifications()
def undo(self):
glyph = self.view.glyph()
glyph.undo()
def redo(self):
glyph = self.view.glyph()
glyph.redo()
def cutOutlines(self):
pass
def copyOutlines(self):
glyph = self.view.glyph()
clipboard = QApplication.clipboard()
mimeData = QMimeData()
copyGlyph = glyph.getRepresentation("defconQt.FilterSelection")
mimeData.setData("application/x-defconQt-glyph-data",
pickle.dumps([copyGlyph.serialize(
blacklist=("name", "unicode")
)]))
clipboard.setMimeData(mimeData)
def pasteOutlines(self):
glyph = self.view.glyph()
clipboard = QApplication.clipboard()
mimeData = clipboard.mimeData()
if mimeData.hasFormat("application/x-defconQt-glyph-data"):
data = pickle.loads(mimeData.data(
"application/x-defconQt-glyph-data"))
if len(data) == 1:
pen = glyph.getPointPen()
pasteGlyph = TGlyph()
pasteGlyph.deserialize(data[0])
# TODO: if we serialize selected state, we don't need to do
# this
pasteGlyph.selected = True
if len(pasteGlyph) or len(pasteGlyph.components) or \
len(pasteGlyph.anchors):
glyph.prepareUndo()
pasteGlyph.drawPoints(pen)
def selectAll(self):
glyph = self.view.glyph()
glyph.selected = True
if not len(glyph):
for component in glyph.components:
component.selected = True
def deselect(self):
glyph = self.view.glyph()
for anchor in glyph.anchors:
anchor.selected = False
for component in glyph.components:
component.selected = False
glyph.selected = False
def lockToolBars(self):
action = self.sender()
movable = not action.isChecked()
for toolBar in (
self._toolsToolBar, self._buttonsToolBar, self._layersToolBar):
toolBar.setMovable(movable)
# --------------------------
# Tools & buttons management
# --------------------------
def installTool(self, tool):
action = self._toolsToolBar.addAction(
QIcon(tool.iconPath), tool.name, self._setViewTool)
action.setCheckable(True)
num = len(self._tools)
action.setData(num)
action.setShortcut(QKeySequence(str(num + 1)))
self._tools.append(tool(parent=self.view))
return action
def uninstallTool(self, tool):
pass # XXX
def _setViewTool(self):
action = self.sender()
index = action.data()
newTool = self._tools[index]
if newTool == self.view.currentTool():
action.setChecked(True)
return
ok = self.view.setCurrentTool(newTool)
# if view did change tool, disable them all and enable the one we want
# otherwise, just disable the tool that was clicked.
# previously we used QActionGroup to have exclusive buttons, but doing
# it manually allows us to NAK a button change.
if ok:
for act in self._toolsToolBar.actions():
act.setChecked(False)
action.setChecked(ok)
def installButton(self, button):
action = self._buttonsToolBar.addAction(
QIcon(button.iconPath), button.name, self._buttonAction)
action.setData(len(self._buttons))
self._buttons.append(button(parent=self.view))
return action
def uninstallButton(self, button):
pass # XXX
def _buttonAction(self):
action = self.sender()
index = action.data()
button = self._buttons[index]
button.clicked()
# --------------------
# Notification support
# --------------------
# glyph
def _subscribeToGlyph(self, glyph):
if glyph is not None:
glyph.addObserver(self, "_glyphChanged", "Glyph.Changed")
glyph.addObserver(self, "_glyphNameChanged", "Glyph.NameChanged")
glyph.addObserver(
self, "_glyphSelectionChanged", "Glyph.SelectionChanged")
undoManager = glyph.undoManager
undoManager.canUndoChanged.connect(self._undoAction.setEnabled)
undoManager.canRedoChanged.connect(self._redoAction.setEnabled)
self._subscribeToFontAndLayerSet(glyph.font)
def _unsubscribeFromGlyph(self, glyph):
if glyph is not None:
glyph.removeObserver(self, "Glyph.Changed")
glyph.removeObserver(self, "Glyph.NameChanged")
glyph.removeObserver(self, "Glyph.SelectionChanged")
undoManager = glyph.undoManager
undoManager.canUndoChanged.disconnect(self._undoAction.setEnabled)
undoManager.canRedoChanged.disconnect(self._redoAction.setEnabled)
self._unsubscribeFromFontAndLayerSet(glyph.font)
def _glyphChanged(self, notification):
self.view.glyphChanged()
def _glyphNameChanged(self, notification):
glyph = self.view.glyph()
self.setWindowTitle(glyph.name, glyph.font)
def _glyphSelectionChanged(self, notification):
self._updateSelection()
self.view.glyphChanged()
def _fontInfoChanged(self, notification):
self.view.fontInfoChanged()
glyph = self.view.glyph()
self.setWindowTitle(glyph.name, glyph.font)
# layers & font
def _subscribeToFontAndLayerSet(self, font):
"""Note: called by _subscribeToGlyph."""
if font is None:
return
font.info.addObserver(self, "_fontInfoChanged", "Info.Changed")
layerSet = font.layers
if layerSet is None:
return
layerSet.addObserver(self, '_layerSetLayerDeleted',
'LayerSet.LayerDeleted')
for event in ('LayerSet.LayerAdded', 'LayerSet.LayerChanged',
'LayerSet.LayerOrderChanged'):
layerSet.addObserver(self, '_layerSetEvents', event)
def _unsubscribeFromFontAndLayerSet(self, font):
"""Note: called by _unsubscribeFromGlyph."""
if font is None:
return
font.info.removeObserver(self, "Info.Changed")
layerSet = font.layers
if layerSet is None:
return
for event in ('LayerSet.LayerAdded', 'LayerSet.LayerChanged',
'LayerSet.LayerOrderChanged', 'LayerSet.LayerDeleted'):
layerSet.removeObserver(self, event)
def _layerSetEvents(self, notification):
self._updateLayerControls()
def _layerSetLayerDeleted(self, notification):
self._layerSetEvents(notification)
self._currentLayerBox.setCurrentIndex(0)
# other updaters
def _updateUndoRedo(self):
glyph = self.view.glyph()
self._undoAction.setEnabled(glyph.canUndo())
self._redoAction.setEnabled(glyph.canRedo())
def _updateSelection(self):
def hasSelection():
glyph = self.view.glyph()
for contour in glyph:
if len(contour.selection):
return True
for anchor in glyph.anchors:
if anchor.selected:
return True
for component in glyph.components:
if component.selected:
return True
return False
self._copyAction.setEnabled(hasSelection())
# --------------
# Public Methods
# --------------
def setGlyph(self, glyph):
currentGlyph = self.view.glyph()
self._unsubscribeFromGlyph(currentGlyph)
self._subscribeToGlyph(glyph)
self.view.setGlyph(glyph)
self._updateLayerControls()
self._updateUndoRedo()
self._updateSelection()
self.setWindowTitle(glyph.name, glyph.font)
def setDrawingAttribute(self, attr, value, layerName=None):
self.view.setDrawingAttribute(attr, value, layerName)
def drawingAttribute(self, attr, layerName=None):
return self.view.drawingAttribute(attr, layerName)
# -----------------
# Layers management
# -----------------
def _layerChanged(self, newLayerIndex):
glyph = self.view.glyph()
layer = self._currentLayerBox.itemData(newLayerIndex)
if layer is None:
layer = self._makeLayer()
if layer is None:
# restore comboBox to active index
layerSet = glyph.layerSet
index = layerSet.layerOrder.index(glyph.layer.name)
self._setLayerBoxIndex(index)
return
if glyph.name in layer:
newGlyph = layer[glyph.name]
else:
# TODO: make sure we mimic defcon ufo3 APIs for that
newGlyph = self._makeLayerGlyph(layer, glyph)
self.setGlyph(newGlyph)
# setting the layer-glyph here
app = QApplication.instance()
app.setCurrentGlyph(newGlyph)
def _makeLayer(self):
# TODO: what with duplicate names?
glyph = self.view.glyph()
newLayerName, ok = AddLayerDialog.getNewLayerName(self)
if ok:
layerSet = glyph.layerSet
# TODO: this should return the layer
layerSet.newLayer(newLayerName)
return layerSet[newLayerName]
else:
return None
def _makeLayerGlyph(self, layer, currentGlyph):
glyph = layer.newGlyph(currentGlyph.name)
glyph.width = currentGlyph.width
glyph.template = True
return glyph
def _updateLayerControls(self):
comboBox = self._currentLayerBox
glyph = self.view.glyph()
comboBox.blockSignals(True)
comboBox.clear()
for layer in glyph.layerSet:
comboBox.addItem(layer.name, layer)
comboBox.setCurrentText(glyph.layer.name)
comboBox.addItem("New layer…", None)
comboBox.blockSignals(False)
self._layerAction.setEnabled(len(glyph.layerSet) > 1)
def _setLayerBoxIndex(self, index):
comboBox = self._currentLayerBox
comboBox.blockSignals(True)
comboBox.setCurrentIndex(index)
comboBox.blockSignals(False)
# ---------------------
# QMainWindow functions
# ---------------------
def event(self, event):
if event.type() == QEvent.WindowActivate:
app = QApplication.instance()
app.setCurrentGlyph(self.view.glyph())
return super().event(event)
def closeEvent(self, event):
glyph = self.view.glyph()
self._unsubscribeFromGlyph(glyph)
event.accept()
def setWindowTitle(self, title, font=None):
if font is not None:
title = "%s – %s %s" % (
title, font.info.familyName, font.info.styleName)
super().setWindowTitle(title)
