def init_menu(window):
exitAction = QAction('&Exit', window)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(window.close)
menu = window.menuBar()
menuitem = menu.addMenu('&File')
menuitem.addAction(exitAction)
class MainWindow(QDialog):
def __init__(self,
default_status_msg=_('Welcome to') + ' ' + __appname__+' console',
parent=None):
QDialog.__init__(self, parent)
self.restart_requested = False
self.l = QVBoxLayout()
self.setLayout(self.l)
self.resize(800, 600)
geom = dynamic.get('console_window_geometry', None)
if geom is not None:
self.restoreGeometry(geom)
# Setup tool bar {{{
self.tool_bar = QToolBar(self)
self.tool_bar.setToolButtonStyle(Qt.ToolButtonTextOnly)
self.l.addWidget(self.tool_bar)
# }}}
# Setup status bar {{{
self.status_bar = QStatusBar(self)
self.status_bar.defmsg = QLabel(__appname__ + _(' console ') +
__version__)
self.status_bar._font = QFont()
self.status_bar._font.setBold(True)
self.status_bar.defmsg.setFont(self.status_bar._font)
self.status_bar.addWidget(self.status_bar.defmsg)
# }}}
self.console = Console(parent=self)
self.console.running.connect(partial(self.status_bar.showMessage,
_('Code is running')))
self.console.running_done.connect(self.status_bar.clearMessage)
self.l.addWidget(self.console)
self.l.addWidget(self.status_bar)
self.setWindowTitle(__appname__ + ' console')
self.setWindowIcon(QIcon(I('console.png')))
self.restart_action = QAction(_('Restart console'), self)
self.restart_action.setShortcut(_('Ctrl+R'))
self.addAction(self.restart_action)
self.restart_action.triggered.connect(self.restart)
self.console.context_menu.addAction(self.restart_action)
def restart(self):
self.restart_requested = True
self.reject()
def closeEvent(self, *args):
dynamic.set('console_window_geometry',
bytearray(self.saveGeometry()))
self.console.shutdown()
return QDialog.closeEvent(self, *args)
def init_file_toolbar(window):
# QIcon.fromTheme('exit'),
exitAction = QAction('Exit', window)
exitAction.setShortcut('Ctrl+Q')
exitAction.triggered.connect(window.controller.handle_close)
printAction = QAction('Print', window)
printAction.setShortcut('Ctrl+P')
printAction.triggered.connect(window.sig_print)
exportAction = QAction('Export', window)
exportAction.triggered.connect(window.sig_export)
importAction = QAction('Import', window)
importAction.triggered.connect(window.sig_import)
undoAction = QAction('Undo', window)
window.toolbar = window.addToolBar('Exit')
window.toolbar.addAction(exitAction)
window.toolbar.addAction(printAction)
window.toolbar.addAction(exportAction)
window.toolbar.addAction(importAction)
window.toolbar.addAction(undoAction)
class Splitter(QSplitter):
state_changed = pyqtSignal(object)
def __init__(self, name, label, icon, initial_show=True,
initial_side_size=120, connect_button=True,
orientation=Qt.Horizontal, side_index=0, parent=None,
shortcut=None, hide_handle_on_single_panel=True):
QSplitter.__init__(self, parent)
if hide_handle_on_single_panel:
self.state_changed.connect(self.update_handle_width)
self.original_handle_width = self.handleWidth()
self.resize_timer = QTimer(self)
self.resize_timer.setSingleShot(True)
self.desired_side_size = initial_side_size
self.desired_show = initial_show
self.resize_timer.setInterval(5)
self.resize_timer.timeout.connect(self.do_resize)
self.setOrientation(orientation)
self.side_index = side_index
self._name = name
self.label = label
self.initial_side_size = initial_side_size
self.initial_show = initial_show
self.splitterMoved.connect(self.splitter_moved, type=Qt.QueuedConnection)
self.button = LayoutButton(icon, label, self, shortcut=shortcut)
if connect_button:
self.button.clicked.connect(self.double_clicked)
if shortcut is not None:
self.action_toggle = QAction(QIcon(icon), _('Toggle') + ' ' + label,
self)
self.action_toggle.changed.connect(self.update_shortcut)
self.action_toggle.triggered.connect(self.toggle_triggered)
if parent is not None:
parent.addAction(self.action_toggle)
if hasattr(parent, 'keyboard'):
parent.keyboard.register_shortcut('splitter %s %s'%(name,
label), unicode_type(self.action_toggle.text()),
default_keys=(shortcut,), action=self.action_toggle)
else:
self.action_toggle.setShortcut(shortcut)
else:
self.action_toggle.setShortcut(shortcut)
def update_shortcut(self):
self.button.update_shortcut(self.action_toggle)
def toggle_triggered(self, *args):
self.toggle_side_pane()
def createHandle(self):
return SplitterHandle(self.orientation(), self)
def initialize(self):
for i in range(self.count()):
h = self.handle(i)
if h is not None:
h.splitter_moved()
self.state_changed.emit(not self.is_side_index_hidden)
def splitter_moved(self, *args):
self.desired_side_size = self.side_index_size
self.state_changed.emit(not self.is_side_index_hidden)
def update_handle_width(self, not_one_panel):
self.setHandleWidth(self.original_handle_width if not_one_panel else 0)
@property
def is_side_index_hidden(self):
sizes = list(self.sizes())
try:
return sizes[self.side_index] == 0
except IndexError:
return True
@property
def save_name(self):
ori = 'horizontal' if self.orientation() == Qt.Horizontal \
else 'vertical'
return self._name + '_' + ori
def print_sizes(self):
if self.count() > 1:
print(self.save_name, 'side:', self.side_index_size, 'other:', end=' ')
print(list(self.sizes())[self.other_index])
@dynamic_property
def side_index_size(self):
def fget(self):
if self.count() < 2:
return 0
return self.sizes()[self.side_index]
def fset(self, val):
if self.count() < 2:
return
if val == 0 and not self.is_side_index_hidden:
self.save_state()
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else 10
self.setSizes(sizes)
total = sum(self.sizes())
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else total-val
self.setSizes(sizes)
self.initialize()
return property(fget=fget, fset=fset)
def do_resize(self, *args):
orig = self.desired_side_size
QSplitter.resizeEvent(self, self._resize_ev)
if orig > 20 and self.desired_show:
c = 0
while abs(self.side_index_size - orig) > 10 and c < 5:
self.apply_state(self.get_state(), save_desired=False)
c += 1
def resizeEvent(self, ev):
if self.resize_timer.isActive():
self.resize_timer.stop()
self._resize_ev = ev
self.resize_timer.start()
def get_state(self):
if self.count() < 2:
return (False, 200)
return (self.desired_show, self.desired_side_size)
def apply_state(self, state, save_desired=True):
if state[0]:
self.side_index_size = state[1]
if save_desired:
self.desired_side_size = self.side_index_size
else:
self.side_index_size = 0
self.desired_show = state[0]
def default_state(self):
return (self.initial_show, self.initial_side_size)
# Public API {{{
def update_desired_state(self):
self.desired_show = not self.is_side_index_hidden
def save_state(self):
if self.count() > 1:
gprefs[self.save_name+'_state'] = self.get_state()
@property
def other_index(self):
return (self.side_index+1)%2
def restore_state(self):
if self.count() > 1:
state = gprefs.get(self.save_name+'_state',
self.default_state())
self.apply_state(state, save_desired=False)
self.desired_side_size = state[1]
def toggle_side_pane(self, hide=None):
if hide is None:
action = 'show' if self.is_side_index_hidden else 'hide'
else:
action = 'hide' if hide else 'show'
getattr(self, action+'_side_pane')()
def show_side_pane(self):
if self.count() < 2 or not self.is_side_index_hidden:
return
if self.desired_side_size == 0:
self.desired_side_size = self.initial_side_size
self.apply_state((True, self.desired_side_size))
def hide_side_pane(self):
if self.count() < 2 or self.is_side_index_hidden:
return
self.apply_state((False, self.desired_side_size))
def double_clicked(self, *args):
self.toggle_side_pane()
class JobsButton(QFrame): # {{{
def __init__(self, horizontal=False, size=48, parent=None):
QFrame.__init__(self, parent)
if horizontal:
size = 24
self.pi = ProgressIndicator(self, size)
self._jobs = QLabel('<b>'+_('Jobs:')+' 0')
self._jobs.mouseReleaseEvent = self.mouseReleaseEvent
self.shortcut = 'Shift+Alt+J'
if horizontal:
self.setLayout(QHBoxLayout())
self.layout().setDirection(self.layout().RightToLeft)
else:
self.setLayout(QVBoxLayout())
self._jobs.setAlignment(Qt.AlignHCenter|Qt.AlignBottom)
self.layout().addWidget(self.pi)
self.layout().addWidget(self._jobs)
if not horizontal:
self.layout().setAlignment(self._jobs, Qt.AlignHCenter)
self._jobs.setMargin(0)
self.layout().setContentsMargins(0, 0, 0, 0)
self._jobs.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Minimum)
self.setCursor(Qt.PointingHandCursor)
b = _('Click to see list of jobs')
self.setToolTip(b + u' (%s)'%self.shortcut)
self.action_toggle = QAction(b, parent)
parent.addAction(self.action_toggle)
self.action_toggle.setShortcut(self.shortcut)
self.action_toggle.triggered.connect(self.toggle)
def initialize(self, jobs_dialog, job_manager):
self.jobs_dialog = jobs_dialog
job_manager.job_added.connect(self.job_added)
job_manager.job_done.connect(self.job_done)
self.jobs_dialog.addAction(self.action_toggle)
def mouseReleaseEvent(self, event):
self.toggle()
def toggle(self, *args):
if self.jobs_dialog.isVisible():
self.jobs_dialog.hide()
else:
self.jobs_dialog.show()
@property
def is_running(self):
return self.pi.isAnimated()
def start(self):
self.pi.startAnimation()
def stop(self):
self.pi.stopAnimation()
def jobs(self):
src = unicode(self._jobs.text())
return int(re.search(r'\d+', src).group())
def job_added(self, nnum):
jobs = self._jobs
src = unicode(jobs.text())
num = self.jobs()
text = src.replace(str(num), str(nnum))
jobs.setText(text)
self.start()
def job_done(self, nnum):
jobs = self._jobs
src = unicode(jobs.text())
num = self.jobs()
text = src.replace(str(num), str(nnum))
jobs.setText(text)
if nnum == 0:
self.no_more_jobs()
def no_more_jobs(self):
if self.is_running:
self.stop()
QCoreApplication.instance().alert(self, 5000)
class Preferences(QMainWindow):
run_wizard_requested = pyqtSignal()
def __init__(self, gui, initial_plugin=None, close_after_initial=False):
QMainWindow.__init__(self, gui)
self.gui = gui
self.must_restart = False
self.committed = False
self.close_after_initial = close_after_initial
self.resize(930, 720)
nh, nw = min_available_height()-25, available_width()-10
if nh < 0:
nh = 800
if nw < 0:
nw = 600
nh = min(self.height(), nh)
nw = min(self.width(), nw)
self.resize(nw, nh)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.esc_action.setShortcut(QKeySequence(Qt.Key_Escape))
self.esc_action.triggered.connect(self.esc)
geom = gprefs.get('preferences_window_geometry', None)
if geom is not None:
self.restoreGeometry(geom)
# Center
if islinux:
self.move(gui.rect().center() - self.rect().center())
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle(__appname__ + ' - ' + _('Preferences'))
self.setWindowIcon(QIcon(I('config.png')))
self.status_bar = StatusBar(self)
self.setStatusBar(self.status_bar)
self.stack = QStackedWidget(self)
self.cw = QWidget(self)
self.cw.setLayout(QVBoxLayout())
self.cw.layout().addWidget(self.stack)
self.bb = QDialogButtonBox(QDialogButtonBox.Close)
self.wizard_button = self.bb.addButton(_('Run welcome wizard'),
self.bb.ActionRole)
self.wizard_button.setIcon(QIcon(I('wizard.png')))
self.wizard_button.clicked.connect(self.run_wizard,
type=Qt.QueuedConnection)
self.cw.layout().addWidget(self.bb)
self.bb.button(self.bb.Close).setDefault(True)
self.bb.rejected.connect(self.close, type=Qt.QueuedConnection)
self.setCentralWidget(self.cw)
self.browser = Browser(self)
self.browser.show_plugin.connect(self.show_plugin)
self.stack.addWidget(self.browser)
self.scroll_area = QScrollArea(self)
self.stack.addWidget(self.scroll_area)
self.scroll_area.setWidgetResizable(True)
self.setContextMenuPolicy(Qt.NoContextMenu)
self.bar = QToolBar(self)
self.addToolBar(self.bar)
self.bar.setVisible(False)
self.bar.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
self.bar.setMovable(False)
self.bar.setFloatable(False)
self.bar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.apply_action = self.bar.addAction(QIcon(I('ok.png')), _('&Apply'),
self.commit)
self.cancel_action = self.bar.addAction(QIcon(I('window-close.png')),
_('&Cancel'), self.cancel)
self.bar_title = BarTitle(self.bar)
self.bar.addWidget(self.bar_title)
self.restore_action = self.bar.addAction(QIcon(I('clear_left.png')),
_('Restore &defaults'), self.restore_defaults)
for ac, tt in [('apply', _('Save changes')),
('cancel', _('Cancel and return to overview'))]:
ac = getattr(self, ac+'_action')
ac.setToolTip(tt)
ac.setWhatsThis(tt)
ac.setStatusTip(tt)
for ch in self.bar.children():
if isinstance(ch, QToolButton):
ch.setCursor(Qt.PointingHandCursor)
ch.setAutoRaise(True)
self.stack.setCurrentIndex(0)
if initial_plugin is not None:
category, name = initial_plugin
plugin = get_plugin(category, name)
if plugin is not None:
self.show_plugin(plugin)
def run_wizard(self):
self.close()
self.run_wizard_requested.emit()
def set_tooltips_for_labels(self):
def process_child(child):
for g in child.children():
if isinstance(g, QLabel):
buddy = g.buddy()
if buddy is not None and hasattr(buddy, 'toolTip'):
htext = unicode(buddy.toolTip()).strip()
etext = unicode(g.toolTip()).strip()
if htext and not etext:
g.setToolTip(htext)
g.setWhatsThis(htext)
else:
process_child(g)
process_child(self.showing_widget)
def show_plugin(self, plugin):
self.showing_widget = plugin.create_widget(self.scroll_area)
self.showing_widget.genesis(self.gui)
self.showing_widget.initialize()
self.set_tooltips_for_labels()
self.scroll_area.setWidget(self.showing_widget)
self.stack.setCurrentIndex(1)
self.showing_widget.show()
self.setWindowTitle(__appname__ + ' - ' + _('Preferences') + ' - ' +
plugin.gui_name)
self.apply_action.setEnabled(False)
self.showing_widget.changed_signal.connect(lambda :
self.apply_action.setEnabled(True))
self.showing_widget.restart_now.connect(self.restart_now)
self.restore_action.setEnabled(self.showing_widget.supports_restoring_to_defaults)
tt = self.showing_widget.restore_defaults_desc
if not self.restore_action.isEnabled():
tt = _('Restoring to defaults not supported for') + ' ' + \
plugin.gui_name
self.restore_action.setToolTip(textwrap.fill(tt))
self.restore_action.setWhatsThis(textwrap.fill(tt))
self.restore_action.setStatusTip(tt)
self.bar_title.show_plugin(plugin)
self.setWindowIcon(QIcon(plugin.icon))
self.bar.setVisible(True)
self.bb.setVisible(False)
def hide_plugin(self):
self.showing_widget = QWidget(self.scroll_area)
self.scroll_area.setWidget(self.showing_widget)
self.setWindowTitle(__appname__ + ' - ' + _('Preferences'))
self.bar.setVisible(False)
self.stack.setCurrentIndex(0)
self.setWindowIcon(QIcon(I('config.png')))
self.bb.setVisible(True)
def esc(self, *args):
if self.stack.currentIndex() == 1:
self.cancel()
elif self.stack.currentIndex() == 0:
self.close()
def restart_now(self):
try:
self.showing_widget.commit()
except AbortCommit:
return
self.hide_plugin()
self.close()
self.gui.quit(restart=True)
def commit(self, *args):
try:
must_restart = self.showing_widget.commit()
except AbortCommit:
return
rc = self.showing_widget.restart_critical
self.committed = True
do_restart = False
if must_restart:
self.must_restart = True
msg = _('Some of the changes you made require a restart.'
' Please restart calibre as soon as possible.')
if rc:
msg = _('The changes you have made require calibre be '
'restarted immediately. You will not be allowed to '
'set any more preferences, until you restart.')
do_restart = show_restart_warning(msg, parent=self)
self.showing_widget.refresh_gui(self.gui)
self.hide_plugin()
if self.close_after_initial or (must_restart and rc) or do_restart:
self.close()
if do_restart:
self.gui.quit(restart=True)
def cancel(self, *args):
if self.close_after_initial:
self.close()
else:
self.hide_plugin()
def restore_defaults(self, *args):
self.showing_widget.restore_defaults()
def closeEvent(self, *args):
gprefs.set('preferences_window_geometry',
bytearray(self.saveGeometry()))
if self.committed:
self.gui.must_restart_before_config = self.must_restart
self.gui.tags_view.recount()
self.gui.create_device_menu()
self.gui.set_device_menu_items_state(bool(self.gui.device_connected))
self.gui.bars_manager.apply_settings()
self.gui.bars_manager.update_bars()
self.gui.build_context_menus()
return QMainWindow.closeEvent(self, *args)
def __init__(self, parent=None):
QTextEdit.__init__(self, parent)
self.setTabChangesFocus(True)
self.document().setDefaultStyleSheet(css())
font = self.font()
f = QFontInfo(font)
delta = tweaks['change_book_details_font_size_by'] + 1
if delta:
font.setPixelSize(f.pixelSize() + delta)
self.setFont(font)
f = QFontMetrics(self.font())
self.em_size = f.horizontalAdvance('m')
self.base_url = None
self._parent = weakref.ref(parent)
self.comments_pat = re.compile(r'<!--.*?-->', re.DOTALL)
extra_shortcuts = {
'bold': 'Bold',
'italic': 'Italic',
'underline': 'Underline',
}
for rec in (
('bold', 'format-text-bold', _('Bold'), True),
('italic', 'format-text-italic', _('Italic'), True),
('underline', 'format-text-underline', _('Underline'), True),
('strikethrough', 'format-text-strikethrough', _('Strikethrough'), True),
('superscript', 'format-text-superscript', _('Superscript'), True),
('subscript', 'format-text-subscript', _('Subscript'), True),
('ordered_list', 'format-list-ordered', _('Ordered list'), True),
('unordered_list', 'format-list-unordered', _('Unordered list'), True),
('align_left', 'format-justify-left', _('Align left'), True),
('align_center', 'format-justify-center', _('Align center'), True),
('align_right', 'format-justify-right', _('Align right'), True),
('align_justified', 'format-justify-fill', _('Align justified'), True),
('undo', 'edit-undo', _('Undo'), ),
('redo', 'edit-redo', _('Redo'), ),
('remove_format', 'edit-clear', _('Remove formatting'), ),
('copy', 'edit-copy', _('Copy'), ),
('paste', 'edit-paste', _('Paste'), ),
('paste_and_match_style', 'edit-paste', _('Paste and match style'), ),
('cut', 'edit-cut', _('Cut'), ),
('indent', 'format-indent-more', _('Increase indentation'), ),
('outdent', 'format-indent-less', _('Decrease indentation'), ),
('select_all', 'edit-select-all', _('Select all'), ),
('color', 'format-text-color', _('Foreground color')),
('background', 'format-fill-color', _('Background color')),
('insert_link', 'insert-link', _('Insert link or image'),),
('insert_hr', 'format-text-hr', _('Insert separator'),),
('clear', 'trash', _('Clear')),
):
name, icon, text = rec[:3]
checkable = len(rec) == 4
ac = QAction(QIcon(I(icon + '.png')), text, self)
if checkable:
ac.setCheckable(checkable)
setattr(self, 'action_'+name, ac)
ss = extra_shortcuts.get(name)
if ss is not None:
ac.setShortcut(QKeySequence(getattr(QKeySequence, ss)))
ac.triggered.connect(getattr(self, 'do_' + name))
self.action_block_style = QAction(QIcon(I('format-text-heading.png')),
_('Style text block'), self)
self.action_block_style.setToolTip(
_('Style the selected text block'))
self.block_style_menu = QMenu(self)
self.action_block_style.setMenu(self.block_style_menu)
self.block_style_actions = []
h = _('Heading {0}')
for text, name in (
(_('Normal'), 'p'),
(h.format(1), 'h1'),
(h.format(2), 'h2'),
(h.format(3), 'h3'),
(h.format(4), 'h4'),
(h.format(5), 'h5'),
(h.format(6), 'h6'),
(_('Blockquote'), 'blockquote'),
):
ac = QAction(text, self)
self.block_style_menu.addAction(ac)
ac.block_name = name
ac.setCheckable(True)
self.block_style_actions.append(ac)
ac.triggered.connect(self.do_format_block)
self.setHtml('')
self.copyAvailable.connect(self.update_clipboard_actions)
self.update_clipboard_actions(False)
self.selectionChanged.connect(self.update_selection_based_actions)
self.update_selection_based_actions()
connect_lambda(self.undoAvailable, self, lambda self, yes: self.action_undo.setEnabled(yes))
connect_lambda(self.redoAvailable, self, lambda self, yes: self.action_redo.setEnabled(yes))
self.action_undo.setEnabled(False), self.action_redo.setEnabled(False)
self.textChanged.connect(self.update_cursor_position_actions)
self.cursorPositionChanged.connect(self.update_cursor_position_actions)
self.textChanged.connect(self.data_changed)
self.update_cursor_position_actions()
class Splitter(QSplitter):
state_changed = pyqtSignal(object)
def __init__(self,
name,
label,
icon,
initial_show=True,
initial_side_size=120,
connect_button=True,
orientation=Qt.Horizontal,
side_index=0,
parent=None,
shortcut=None,
hide_handle_on_single_panel=True):
QSplitter.__init__(self, parent)
if hide_handle_on_single_panel:
self.state_changed.connect(self.update_handle_width)
self.original_handle_width = self.handleWidth()
self.resize_timer = QTimer(self)
self.resize_timer.setSingleShot(True)
self.desired_side_size = initial_side_size
self.desired_show = initial_show
self.resize_timer.setInterval(5)
self.resize_timer.timeout.connect(self.do_resize)
self.setOrientation(orientation)
self.side_index = side_index
self._name = name
self.label = label
self.initial_side_size = initial_side_size
self.initial_show = initial_show
self.splitterMoved.connect(self.splitter_moved,
type=Qt.QueuedConnection)
self.button = LayoutButton(icon, label, self, shortcut=shortcut)
if connect_button:
self.button.clicked.connect(self.double_clicked)
if shortcut is not None:
self.action_toggle = QAction(QIcon(icon),
_('Toggle') + ' ' + label, self)
self.action_toggle.changed.connect(self.update_shortcut)
self.action_toggle.triggered.connect(self.toggle_triggered)
if parent is not None:
parent.addAction(self.action_toggle)
if hasattr(parent, 'keyboard'):
parent.keyboard.register_shortcut(
'splitter %s %s' % (name, label),
unicode_type(self.action_toggle.text()),
default_keys=(shortcut, ),
action=self.action_toggle)
else:
self.action_toggle.setShortcut(shortcut)
else:
self.action_toggle.setShortcut(shortcut)
def update_shortcut(self):
self.button.update_shortcut(self.action_toggle)
def toggle_triggered(self, *args):
self.toggle_side_pane()
def createHandle(self):
return SplitterHandle(self.orientation(), self)
def initialize(self):
for i in range(self.count()):
h = self.handle(i)
if h is not None:
h.splitter_moved()
self.state_changed.emit(not self.is_side_index_hidden)
def splitter_moved(self, *args):
self.desired_side_size = self.side_index_size
self.state_changed.emit(not self.is_side_index_hidden)
def update_handle_width(self, not_one_panel):
self.setHandleWidth(self.original_handle_width if not_one_panel else 0)
@property
def is_side_index_hidden(self):
sizes = list(self.sizes())
try:
return sizes[self.side_index] == 0
except IndexError:
return True
@property
def save_name(self):
ori = 'horizontal' if self.orientation() == Qt.Horizontal \
else 'vertical'
return self._name + '_' + ori
def print_sizes(self):
if self.count() > 1:
print(self.save_name,
'side:',
self.side_index_size,
'other:',
end=' ')
print(list(self.sizes())[self.other_index])
@property
def side_index_size(self):
if self.count() < 2:
return 0
return self.sizes()[self.side_index]
@side_index_size.setter
def side_index_size(self, val):
if self.count() < 2:
return
if val == 0 and not self.is_side_index_hidden:
self.save_state()
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else 10
self.setSizes(sizes)
total = sum(self.sizes())
sizes = list(self.sizes())
for i in range(len(sizes)):
sizes[i] = val if i == self.side_index else total - val
self.setSizes(sizes)
self.initialize()
def do_resize(self, *args):
orig = self.desired_side_size
QSplitter.resizeEvent(self, self._resize_ev)
if orig > 20 and self.desired_show:
c = 0
while abs(self.side_index_size - orig) > 10 and c < 5:
self.apply_state(self.get_state(), save_desired=False)
c += 1
def resizeEvent(self, ev):
if self.resize_timer.isActive():
self.resize_timer.stop()
self._resize_ev = ev
self.resize_timer.start()
def get_state(self):
if self.count() < 2:
return (False, 200)
return (self.desired_show, self.desired_side_size)
def apply_state(self, state, save_desired=True):
if state[0]:
self.side_index_size = state[1]
if save_desired:
self.desired_side_size = self.side_index_size
else:
self.side_index_size = 0
self.desired_show = state[0]
def default_state(self):
return (self.initial_show, self.initial_side_size)
# Public API {{{
def update_desired_state(self):
self.desired_show = not self.is_side_index_hidden
def save_state(self):
if self.count() > 1:
gprefs[self.save_name + '_state'] = self.get_state()
@property
def other_index(self):
return (self.side_index + 1) % 2
def restore_state(self):
if self.count() > 1:
state = gprefs.get(self.save_name + '_state', self.default_state())
self.apply_state(state, save_desired=False)
self.desired_side_size = state[1]
def toggle_side_pane(self, hide=None):
if hide is None:
action = 'show' if self.is_side_index_hidden else 'hide'
else:
action = 'hide' if hide else 'show'
getattr(self, action + '_side_pane')()
def show_side_pane(self):
if self.count() < 2 or not self.is_side_index_hidden:
return
if self.desired_side_size == 0:
self.desired_side_size = self.initial_side_size
self.apply_state((True, self.desired_side_size))
def hide_side_pane(self):
if self.count() < 2 or self.is_side_index_hidden:
return
self.apply_state((False, self.desired_side_size))
def double_clicked(self, *args):
self.toggle_side_pane()
def ac(text, key, role=QAction.MenuRole.TextHeuristicRole):
ans = QAction(text, self)
ans.setMenuRole(role)
ans.setShortcut(QKeySequence(key))
self.edit_menu.addAction(ans)
return ans
def _init_ui(self):
self.statusBar().showMessage('Ready')
# ------- FILE MENU
menubar = self.menuBar()
fileMenu = menubar.addMenu('File')
impMenu = QMenu('Import', self)
impAct = QAction('Import obj', self)
impMenu.addAction(impAct)
newAct = QAction('New', self)
fileMenu.addAction(newAct)
fileMenu.addMenu(impMenu)
# ------- Icon exit and animate
exitAct = QAction(
QIcon('models/icon_exit.png'),
'Exit', self)
exitAct.setShortcut('Ctrl+Q')
exitAct.triggered.connect(qApp.quit)
animationButton = QAction(
QIcon('models/icon_play.png'),
'Animate', self)
animationButton.setShortcut('Space')
animationButton.triggered.connect(self._animate)
# self.action.setShortcut("ESC")
# ------- Display slider value
lcdAperture = QLCDNumber(self)
lcdFocalLength = QLCDNumber(self)
# lcdNear = QLCDNumber(self)
lcdFar = QLCDNumber(self)
# ------- Slider creation and connection to lcd
self.sldAperture = QSlider(Qt.Horizontal, self)
self.sldAperture.setTickPosition(QSlider.TicksBothSides)
self.sldFocalLength = QSlider(Qt.Horizontal, self)
self.sldFocalLength.setTickPosition(QSlider.TicksBothSides)
'''
self.sldNear = QSlider(Qt.Horizontal, self)
self.sldNear.setTickPosition(QSlider.TicksBothSides)
'''
self.sldFar = QSlider(Qt.Horizontal, self)
self.sldFar.setTickPosition(QSlider.TicksBothSides)
# ------- Connect slider to lcd
self.sldAperture.valueChanged.connect(lcdAperture.display)
self.sldFocalLength.valueChanged.connect(lcdFocalLength.display)
'''
self.sldNear.valueChanged.connect(lcdNear.display)
'''
self.sldFar.valueChanged.connect(lcdFar.display)
# ------- Slider parameter and specifications
# self.sldAperture.setMinimum(0)
# self.sldAperture.setMaximum(80)
self.sldAperture.setValue(sC.aperture)
self.sldAperture.setRange(10, 100)
self.sldFocalLength.setValue(sC.focalLength)
self.sldFocalLength.setRange(1, 15)
self.sldFocalLength.valueChanged.connect(self._valueHandler)
'''
self.sldNear.setValue(sC.near)
self.sldNear.setRange(0,10)
self.sldNear.valueChanged.connect(self._valueHandler)
'''
self.sldFar.setValue(sC.far)
self.sldFar.setRange(50, 150)
# ------- Show slide bar
self.exitToolbar = self.addToolBar('exit')
self.exitToolbar.addAction(exitAct)
self.exitToolbar.addAction(animationButton)
# ------- Go back to line
self.addToolBarBreak()
self.lcdToolbar = self.addToolBar('lcd')
self.lcdToolbar.addWidget(lcdAperture)
self.apertureToolbar = self.addToolBar('aperture')
self.apertureToolbar.addWidget(self.sldAperture)
self.apertureToolbar.addWidget(QLabel("Aperture"))
self.addToolBarBreak()
self.lcdToolbar2 = self.addToolBar('lcd2')
self.lcdToolbar2.addWidget(lcdFocalLength)
self.focalLengthToolbar = self.addToolBar('focalLength')
self.focalLengthToolbar.addWidget(self.sldFocalLength)
self.focalLengthToolbar.addWidget(QLabel("focalLength *100"))
self.addToolBarBreak()
'''
self.lcdToolbarNear = self.addToolBar('lcd2')
self.lcdToolbarNear.addWidget(lcdNear)
self.nearToolbar = self.addToolBar('near')
self.nearToolbar.addWidget(self.sldNear)
self.nearToolbar.addWidget(QLabel("near(/100)"))
self.addToolBarBreak()
'''
self.lcdToolbarFar = self.addToolBar('lcdFar')
self.lcdToolbarFar.addWidget(lcdFar)
self.farToolbar = self.addToolBar('far')
self.farToolbar.addWidget(self.sldFar)
self.farToolbar.addWidget(QLabel("far"))
# ------- required to display
self.setGeometry(600, 600, 600, 600)
self.show()
class UFDebugToolUI(object):
def __init__(self, window=None):
self.window = window if window is not None else QWidget
super(UFDebugToolUI, self).__init__()
self.lang = 'en'
self.set_ui()
def set_ui(self):
self._set_window()
self._set_menubar()
self._set_tab()
def _set_window(self):
self.window.setWindowTitle(self.window.tr('UF-Debug-Tool'))
self.window.setMinimumHeight(800)
self.window.setMinimumWidth(1080)
self.main_layout = QVBoxLayout(self.window)
def _set_menubar(self):
self.menuBar = QMenuBar()
self.main_layout.setMenuBar(self.menuBar)
fileMenu = self.menuBar.addMenu('File')
self.newFileAction = QAction(self.window.tr('New'), self.window)
self.newFileAction.setShortcut('Ctrl+N')
self.newFileAction.setStatusTip('New File')
fileMenu.addAction(self.newFileAction)
self.openFileAction = QAction(self.window.tr('Open'), self.window)
self.openFileAction.setShortcut('Ctrl+O')
self.openFileAction.setToolTip('Open File')
fileMenu.addAction(self.openFileAction)
self.saveFileAction = QAction(self.window.tr('Save'), self.window)
self.saveFileAction.setShortcut('Ctrl+S')
self.saveFileAction.setStatusTip('Save File')
fileMenu.addAction(self.saveFileAction)
self.closeFileAction = QAction(self.window.tr('Close'), self.window)
self.closeFileAction.setShortcut('Ctrl+W')
self.closeFileAction.setStatusTip('Close File')
fileMenu.addAction(self.closeFileAction)
self.newFileAction.triggered.connect(self.new_dialog)
self.openFileAction.triggered.connect(self.open_dialog)
self.saveFileAction.triggered.connect(self.save_dialog)
self.closeFileAction.triggered.connect(self.close_dialog)
debugMenu = self.menuBar.addMenu('Debug')
self.logAction = QAction(self.window.tr('Log'), self.window)
self.logAction.setShortcut('Ctrl+D')
self.logAction.setStatusTip('Open-Log')
self.logAction.triggered.connect(self.control_log_window)
debugMenu.addAction(self.logAction)
def control_log_window(self):
if self.window.log_window.isHidden():
self.window.log_window.show()
self.logAction.setText('Close-Log')
else:
self.window.log_window.hide()
self.logAction.setText('Open-Log')
def switch_tab(self, index):
pass
# if index == 2:
# self.menuBar.setHidden(False)
# else:
# self.menuBar.setHidden(True)
def _set_tab(self):
self.tab_widget = QTabWidget()
# self.tab_widget.currentChanged.connect(self.switch_tab)
# tab_widget.setMaximumHeight(self.window.geometry().height() // 2)
self.main_layout.addWidget(self.tab_widget)
toolbox1 = QToolBox()
toolbox2 = QToolBox()
toolbox3 = QToolBox()
toolbox4 = QToolBox()
toolbox5 = QToolBox()
groupbox1 = QGroupBox()
groupbox2 = QGroupBox()
groupbox3 = QGroupBox()
groupbox4 = QGroupBox()
groupbox5 = QGroupBox()
toolbox1.addItem(groupbox1, "")
toolbox2.addItem(groupbox2, "")
toolbox3.addItem(groupbox3, "")
toolbox4.addItem(groupbox4, "")
toolbox5.addItem(groupbox5, "")
self.tab_widget.addTab(toolbox1, "uArm")
self.tab_widget.addTab(toolbox2, "xArm")
self.tab_widget.addTab(toolbox3, "OpenMV")
self.tab_widget.addTab(toolbox4, "Gcode")
self.tab_widget.addTab(toolbox5, "WebView")
uarm_layout = QVBoxLayout(groupbox1)
xarm_layout = QVBoxLayout(groupbox2)
openmv_layout = QHBoxLayout(groupbox3)
gcode_layout = QVBoxLayout(groupbox4)
webview_layout = QVBoxLayout(groupbox5)
self.uarm_ui = UArmUI(self, uarm_layout)
self.xarm_ui = XArmUI(self, xarm_layout)
self.openmv_ui = OpenMV_UI(self, openmv_layout)
self.gcode_ui = GcodeUI(self, gcode_layout)
self.webview_ui = WebViewUI(self, webview_layout)
self.tab_widget.setCurrentIndex(0)
def new_dialog(self):
self.openmv_ui.textEdit.setText('')
self.openmv_ui.textEdit.filename = None
self.openmv_ui.label_title.setText('untitled')
self.tab_widget.setCurrentIndex(2)
self.openmv_ui.textEdit.setDisabled(False)
def open_dialog(self):
fname = QFileDialog.getOpenFileName(self.window, 'Open file', '')
if fname and fname[0]:
with open(fname[0], "r") as f:
self.openmv_ui.textEdit.setText(f.read())
self.openmv_ui.label_title.setText(fname[0])
self.openmv_ui.textEdit.filename = fname[0]
self.tab_widget.setCurrentIndex(2)
self.openmv_ui.textEdit.setDisabled(False)
def save_dialog(self):
widget = self.window.focusWidget()
if widget:
if not self.openmv_ui.textEdit.filename:
fname = QFileDialog.getSaveFileName(self.window, 'Save File',
'')
if fname and fname[0]:
self.openmv_ui.textEdit.filename = fname[0]
if self.openmv_ui.textEdit.filename:
data = widget.toPlainText()
with open(self.openmv_ui.textEdit.filename, "w") as f:
f.write(data)
def close_dialog(self):
self.openmv_ui.textEdit.clear()
self.openmv_ui.textEdit.filename = None
self.openmv_ui.label_title.setText('')
self.openmv_ui.textEdit.setDisabled(True)
class EventList(QListWidget):
follow_clicked = pyqtSignal(int)
event_role = Qt.UserRole
offset_role = Qt.UserRole + 1
NOP = script.FighterEvent.from_hex('0xCC000000')
def __init__(self, parent=None):
super().__init__(parent)
self.start_offset = None # will be set by parent
self.itemDoubleClicked.connect(
lambda item: self.popup_event_editor(self.row(item)))
self.setSelectionMode(self.ContiguousSelection)
style = self.style()
self.move_up = QAction(style.standardIcon(QStyle.SP_ArrowUp),
'Move Up', self)
self.move_up.setShortcut(QKeySequence(Qt.Key_Minus))
self.move_up.triggered.connect(lambda: self.shift(-1))
self.addAction(self.move_up)
self.move_down = QAction(style.standardIcon(QStyle.SP_ArrowDown),
'Move Down', self)
self.move_down.setShortcut(QKeySequence(Qt.Key_Plus))
self.move_down.triggered.connect(lambda: self.shift(+1))
self.addAction(self.move_down)
copy = QAction(self)
copy.setShortcut(QKeySequence.Copy)
copy.triggered.connect(self.copy)
self.addAction(copy)
paste = QAction(self)
paste.setShortcut(QKeySequence.Paste)
paste.triggered.connect(self.paste)
self.addAction(paste)
self.delete = QAction(
style.standardIcon(QStyle.SP_DialogDiscardButton), 'Delete',
self)
self.delete.setShortcut(QKeySequence.Delete)
self.delete.triggered.connect(self.delete_selected)
self.addAction(self.delete)
self.new = QAction(style.standardIcon(QStyle.SP_FileIcon),
'Insert Event', self)
self.new.triggered.connect(
lambda: self.insert_event(self.currentRow(), self.NOP.copy()))
self.addAction(self.new)
def delete_selected(self):
selected = sorted(self.selectedIndexes())
if selected:
self.setCurrentIndex(selected[0])
row = self.currentIndex().row()
for i in range(len(selected)):
ev = self.takeItem(row)
del ev
def copy(self):
s = ''
for item in self.selectedItems():
event_text = hex_display(hex(item.data(self.event_role)),
show_0x=False)
if len(event_text) % 2:
event_text = '0' + event_text
s += event_text
app.clipboard().setText(s)
def paste(self):
cb = app.clipboard()
formats = cb.mimeData().formats()
try:
fmt_010 = r'application/x-qt-windows-mime;value="010 Editor Binary Data"'
if fmt_010 in formats:
data = cb.mimeData().data(fmt_010)
# [:-2] because 010 appends \x00\x00
scr = script.script_from_bytes(data[:-2])
for ev in scr:
self.insert_event(max(self.currentRow(), 0), ev)
# any other binary formats go here
elif cb.text():
scr = script.script_from_hex_str(cb.text())
for ev in scr:
self.insert_event(max(self.currentRow(), 0), ev)
self.selectionModel().clearSelection()
except EOFError:
mbox = QMessageBox(self)
mbox.setText('Error interpreting pasted event data')
mbox.exec_()
def contextMenuEvent(self, e):
row = self.currentRow()
if self.item(row):
event = self.item(row).data(Qt.UserRole)
menu = QMenu(self)
edit_action = menu.addAction(
self.style().standardIcon(
QStyle.SP_FileDialogDetailedView), 'Edit')
edit_action.triggered.connect(
lambda: self.popup_event_editor(row))
menu.addAction(self.new)
# insert_action = menu.addAction(
# self.style().standardIcon(QStyle.SP_FileIcon),
# 'Insert Event'
# )
# insert_action.triggered.connect(
# lambda: self.insert_event(self.currentRow(), self.NOP.copy())
# )
if event.pointers:
follow_action = menu.addAction(
self.style().standardIcon(QStyle.SP_ArrowForward),
'Follow')
follow_action.triggered.connect(lambda: self.follow(row))
menu.exec_(e.globalPos())
def insert_event(self, pos, event):
if self.item(pos) is None:
offset = self.start_offset
else:
offset = self.item(pos).data(self.offset_role)
self.insertItem(pos, self.item_from_event(event, offset))
self.update_offsets()
def popup_event_editor(self, row):
ev = self.item(row).data(self.event_role)
offset = self.item(row).data(self.offset_role)
event_editor = EventEditor(ev, self)
event_editor.applied.connect(
lambda ev: self.replace_event(row, ev, offset))
event_editor.exec_()
def replace_event(self, row, event, offset):
self.insertItem(row + 1, self.item_from_event(event, offset))
old = self.takeItem(row)
del old
self.update_offsets()
def follow(self, row):
target = self.item(row).data(self.event_role)['target']
self.follow_clicked.emit(target)
def add_event(self, event, offset):
self.addItem(self.item_from_event(event, offset))
@staticmethod
def event_text(event, offset):
if compact_event_display:
return event.compact_str(offset=offset)
else:
return event.__str__(offset=offset)
def item_from_event(self, event, offset):
name = self.event_text(event, offset)
new = QListWidgetItem(name)
new.setData(self.event_role, event)
new.setData(self.offset_role, offset)
return new
def get_script(self):
return [
self.item(row).data(self.event_role)
for row in range(self.count())
]
def update_offsets(self):
offset = self.start_offset
for row in range(self.count()):
item = self.item(row)
ev = item.data(self.event_role)
item.setData(self.offset_role, offset)
item.setText(self.event_text(ev, offset))
offset += ev.length
def shift(self, shift):
# shift: 1 = down, -1 = up
selected = sorted(self.selectedIndexes())
if selected:
if shift > 0:
# down
current = selected[-1]
else:
# up
current = selected[0]
self.setCurrentIndex(current)
else:
current = self.currentIndex()
row = self.currentIndex().row()
if not 0 <= row + shift < self.count():
shift = 0
for i in range(len(selected)):
self.insertItem(row + (1 - i) * shift,
self.takeItem(row - i * shift))
self.update_offsets()
self.setCurrentRow(row + shift)
self.selectionModel().clear()
self.setCurrentIndex(
current.sibling(current.row() + shift, current.column()))
for index in selected:
self.selectionModel().select(
index.sibling(index.row() + shift, index.column()),
self.selectionModel().Select)
class GUI(QtWidgets.QMainWindow):
def __init__(self):
'''Asetetaan muuttujille alkuarvoja ohjelman suorittamiseksi'''
super().__init__()
self.title = "Lujuusanalysaattori"
self.left = 200
self.top = 200
self.width = 1300
self.height = 700
self.palkin_default_pituus = 5
self.square_size = 10
self.ikkuna()
self.button_height = 75
self.button_width = 150
self.button_separation = 25
self.x = 0
self.y = 0
self.palkin_leveys = 700
self.palkin_korkeus = 75
self.palkin_keskipiste = 650
self.palkin_paatypiste = 1000
self.yksikko_arvo = 0
self.voima = 20
self.maks_jannitys = "-"
self.asteikko_teksti = QGraphicsSimpleTextItem()
'''Lisää QGraphicsScenen ruudukon piirtämistä varten'''
self.scene = QtWidgets.QGraphicsScene()
self.scene.setSceneRect(0, -20, self.width - 200, self.height - 100)
'''Suoritetaan lukuisia metodeja, jolla ohjelma "alustetaan"'''
self.aloita_simulaatio()
self.simulaatioikkuna()
self.simulaatio_nappi()
self.materiaali_valikko()
self.uusi_palkki_nappi()
self.lisaa_tuki_nappi()
self.lisaa_ulkoinen_voima_nappi()
self.poista_ulkoinen_voima_nappi()
self.vaihda_tuki_nappi()
Ominaisuudet.alkuarvot(self)
self.lisaa_palkki()
self.palkin_pituus_valikko()
self.yksikko_pituus()
self.asteikko()
self.lisaa_asteikko_arvo()
self.asteikko_teksti.hide()
self.tulos_teksti()
self.lisaa_seina_tuki()
self.lisaa_tuki_alhaalta()
self.ulkoinen_voima_valikko()
self.ulkoinen_voima_nuoli_alatuki()
self.ulkoinen_voima_nuoli_seinatuki()
Ominaisuudet.alkuarvot(self)
'''Asetetaan tietyille napeille tietty näkyvyys'''
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.show()
def ikkuna(self):
'''Tekee ohjelman pääikkunan'''
self.setGeometry(self.left, self.top, self.width, self.height)
self.setWindowTitle('Lujuusanalysaattori')
self.horizontal = QtWidgets.QHBoxLayout()
'''Luo menubarin'''
self.uusiAction = QAction("Uusi simulaatio", self)
self.uusiAction.setStatusTip("Luo uusi rakenne")
self.uusiAction.triggered.connect(self.uusi_rakenne)
self.uusiAction.setEnabled(True)
self.uusiAction.setShortcut("Ctrl+N")
self.tallennaAction = QAction("Tallenna simulaatio", self)
self.tallennaAction.setStatusTip("Tallenna simulaatio")
self.tallennaAction.triggered.connect(self.tallenna_rakenne)
self.tallennaAction.setEnabled(False)
self.tallennaAction.setShortcut("Ctrl+S")
self.avaaAction = QAction("Lataa simulaatio", self)
self.avaaAction.setStatusTip("Lataa simulaatio tiedostosta")
self.avaaAction.triggered.connect(self.lataa_tallennettu_rakenne)
self.avaaAction.setShortcut("Ctrl+O")
self.exitAction = QAction("Exit", self)
self.exitAction.setToolTip("Lopeta ohjelma")
self.exitAction.triggered.connect(self.close_application)
self.exitAction.setShortcut("Ctrl+E")
self.statusBar()
mainMenu = self.menuBar()
fileMenu = mainMenu.addMenu('&File')
aboutMenu = mainMenu.addMenu('&About')
fileMenu.addAction(self.uusiAction)
fileMenu.addAction(self.avaaAction)
fileMenu.addAction(self.tallennaAction)
fileMenu.addAction(self.exitAction)
def tallenna_rakenne(self):
'''Hoitaa rakenteen tallentamisen'''
tallennus = Tallennin.tallenin(self)
if tallennus == True:
'''Kerrotaan käyttäjälle, että tallennus onnistui'''
msgBox = QMessageBox()
msgBox.setText("Tallennus onnistui!")
msgBox.setWindowTitle("Onnistunut Tallennus")
msgBox.setMinimumWidth(50)
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def lataa_tallennettu_rakenne(self):
'''Metodi avaa QFileDialog ikkunan, josta käyttäjä valitsee tiedoston, jossa aiemmin tallennettu rakenne sijaitsee. Vain .txt -tiedostot
ovat ladattavissa '''
options = QFileDialog.Options()
options |= QFileDialog.DontUseNativeDialog
tiedosto, _ = QFileDialog.getOpenFileName(self,
"Valitse tiedosto",
"",
"txt Files (*.txt)",
options=options)
lataus = Lataaja.lataaja(self, tiedosto)
if lataus == False:
return
if lataus == True:
self.uusi_rakenne()
Lataaja.lataaja(self, tiedosto)
tuen_tyyppi = Ominaisuudet.palauta_tuen_tyyppi(self)
'''Jos tuki on seinästä, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 0:
self.nayta_seina_tuki()
self.gradient_seina_tuki()
'''Jos tuki on alhaalta, piirretään sitä vastaava grafiikka'''
if tuen_tyyppi == 1:
self.nayta_tuki_alhaalta()
self.gradient_alatuki()
if tuen_tyyppi != 2:
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
'''Jos ulkoinen voima on asetettu, piirretään se'''
ulkoinen_voima = int(
Ominaisuudet.onko_ulkoinen_voima_asetettu(self))
if ulkoinen_voima == 1:
self.nayta_ulkoinen_voima()
self.nayta_palkki()
Laskin.laskin(self)
self.paivita_tulos_teksti()
self.tulos.show()
self.sp.setValue(float(Ominaisuudet.palauta_palkin_pituus(self)))
self.uusiAction.setEnabled(True)
self.simuloi.setEnabled(True)
'''Kerrotaan käyttäjälle, että kaikki onnistui'''
msgBox = QMessageBox()
msgBox.setText("Lataus onnistui!")
msgBox.setWindowTitle("Onnistunut lataus")
msgBox.addButton(QPushButton('OK'), QMessageBox.NoRole)
msgBox.exec_()
def aloita_simulaatio(self):
'''Aloittaa simulaation'''
self.setCentralWidget(QtWidgets.QWidget())
self.horizontal = QtWidgets.QHBoxLayout()
self.centralWidget().setLayout(self.horizontal)
def simulaatioikkuna(self):
'''lisää view näyttämistä varten'''
self.view = QtWidgets.QGraphicsView(self.scene, self)
self.view.adjustSize()
self.view.show()
self.horizontal.addWidget(self.view)
def uusi_palkki_nappi(self):
'''Luo Uusi palkki -napin'''
self.uusi_palkki = QPushButton('Uusi palkki')
self.uusi_palkki.setToolTip("Lisää uusi palkki")
self.uusi_palkki.move(0, 0)
self.uusi_palkki.resize(self.button_width, self.button_height)
self.uusi_palkki.font = QtGui.QFont()
self.uusi_palkki.font.setPointSize(12)
self.uusi_palkki.setFont(self.uusi_palkki.font)
self.uusi_palkki.setEnabled(True)
self.scene.addWidget(self.uusi_palkki)
self.uusi_palkki.clicked.connect(self.nayta_palkki)
def nayta_palkki(self):
'''Näyttää kaikki palkkiin liittyvät komponentit sekä asettaa uusi palkki -napin toimimattomaksi'''
self.rect.show()
self.palkin_pituus.show()
self.sp.show()
self.yksikko.show()
self.asteikko_teksti.show()
self.line.show()
self.nuoli_1.show()
self.nuoli_2.show()
self.uusi_palkki.setEnabled(False)
self.lisaa_tuki.setEnabled(True)
self.materiaali_valinta.setEnabled(True)
def lisaa_palkki(self):
'''lisää palkin'''
self.rect = QGraphicsRectItem(300, 200, self.palkin_leveys,
self.palkin_korkeus)
self.rect.setBrush(QBrush(4))
self.scene.addItem(self.rect)
self.rect.hide()
self.lisaa_tuki.setEnabled(True)
'''Aina kun on uusi palkki luotu, voidaan aloittaa simulaatio alusta'''
self.uusiAction.setEnabled(True)
def lisaa_tuki_nappi(self):
'''Luo Lisää tuki -napin'''
self.lisaa_tuki = QPushButton("Lisää tuki")
self.lisaa_tuki.setToolTip("Lisää tuki")
self.lisaa_tuki.move(0, self.button_height + self.button_separation)
self.lisaa_tuki.resize(self.button_width, self.button_height)
self.lisaa_tuki.font = QtGui.QFont()
self.lisaa_tuki.font.setPointSize(12)
self.lisaa_tuki.setFont(self.lisaa_tuki.font)
self.lisaa_tuki.setEnabled(False)
self.lisaa_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.lisaa_tuki)
def vaihda_tuki_nappi(self):
'''Luo vaihda tuki -napin'''
self.vaihda_tuki = QPushButton("Vaihda tuki")
self.vaihda_tuki.setToolTip("Vaihda tuki")
self.vaihda_tuki.move(0, self.button_height + self.button_separation)
self.vaihda_tuki.resize(self.button_width, self.button_height)
self.vaihda_tuki.setFont(self.lisaa_tuki.font)
self.vaihda_tuki.clicked.connect(self.valitse_tuki)
self.scene.addWidget(self.vaihda_tuki)
self.vaihda_tuki.hide()
def valitse_tuki(self):
'''Tuen valinta.
Jos tuki on seinästä (tyyppi = 0), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 1:
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.nayta_tuki_alhaalta()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.tuki(self, 1)
return
'''Jos tuki on alhaalta (tyyppi = 1), kysytään halutaanko vaihtaa.
Jos haluaa muutetaan tuen grafiikka ja arvo'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
msgBox = QMessageBox()
msgBox.setText("Haluatko vaihtaa tuen tyyppiä?")
msgBox.addButton(QPushButton('Kyllä'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('En'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.rect.setBrush(QBrush(4))
if vastaus == 0:
Ominaisuudet.tuki(self, 0)
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nayta_seina_tuki()
if int(Ominaisuudet.onko_ulkoinen_voima_asetettu(self)) == 1:
self.viiva.show()
self.nuoli_3.show()
self.viiva_5.hide()
self.nuoli_6.hide()
if vastaus == 1:
pass
'''Jos tukea ei ole (tyyppi = 2). Tuen tyypin valinta'''
if Ominaisuudet.palauta_tuen_tyyppi(self) == 2:
msgBox = QMessageBox()
msgBox.setText("Valitse tuen tyyppi")
msgBox.addButton(QPushButton('Seinätuki'), QMessageBox.YesRole)
msgBox.addButton(QPushButton('Tuki alhaalta'), QMessageBox.NoRole)
vastaus = msgBox.exec_()
self.vaihda_tuki.show()
self.lisaa_tuki.hide()
if vastaus == 0:
self.nayta_seina_tuki()
Ominaisuudet.tuki(self, 0)
if vastaus == 1:
self.nayta_tuki_alhaalta()
Ominaisuudet.tuki(self, 1)
'''Joka tapauksessa asetetaan ulkoisen voiman lisääminen mahdolliseksi
sekä maalataan palkki normaaliksi'''
self.lisaa_ulkoinen_voima.setEnabled(True)
self.simuloi.setEnabled(True)
def nayta_seina_tuki(self):
'''Näytetään seinätukea kuvaavat grafiikat'''
self.viiva_1.show()
self.viiva_2.show()
self.viiva_3.show()
self.viiva_4.show()
def nayta_tuki_alhaalta(self):
'''Näytetään alatukea kuvaavat grafiikat'''
self.nuoli_4.show()
self.nuoli_5.show()
def paivita_tuen_tyyppi(self, tyyppi):
'''Päivittää tuen tyypin arvon Ominaisuudet luokassa'''
Ominaisuudet.tuki(self, tyyppi)
def lisaa_seina_tuki(self):
'''Piirtää seinätukea kuvaavat viivat sekä asettaa self.tuen_tyyppi arvoksi
Asettaa SIMULOI-napin painettavaksi'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
self.viiva_1 = QGraphicsLineItem(QtCore.QLineF(300, 202, 275, 225))
self.viiva_2 = QGraphicsLineItem(QtCore.QLineF(300, 222, 275, 245))
self.viiva_3 = QGraphicsLineItem(QtCore.QLineF(300, 242, 275, 265))
self.viiva_4 = QGraphicsLineItem(QtCore.QLineF(300, 262, 275, 285))
self.scene.addItem(self.viiva_1)
self.scene.addItem(self.viiva_2)
self.scene.addItem(self.viiva_3)
self.scene.addItem(self.viiva_4)
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
tyyppi = 0
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_tuki_alhaalta(self):
'''Piirtää alhaalta tukemista kuvaavat grafiikat
sekä asettaa self.tuen_tyyppi arvoksi 1'''
leveys = 15 #nuolen leveus pikseleissä
korkeus = 30 #nuuolen korkeus pikseleissä
'''Nuolen kärkien koordinaatit'''
nuoli_piste_1 = QtCore.QPointF(305, 275)
nuoli_piste_2 = QtCore.QPointF(305 - leveys, 275 + korkeus)
nuoli_piste_3 = QtCore.QPointF(305 + leveys, 275 + korkeus)
nuoli_piste_4 = QtCore.QPointF(995, 275)
nuoli_piste_5 = QtCore.QPointF(995 - leveys, 275 + korkeus)
nuoli_piste_6 = QtCore.QPointF(995 + leveys, 275 + korkeus)
'''Luodaan nuolia kuvaavat QPolygonF oliot'''
self.nuoli_4 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_5 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_4, nuoli_piste_5, nuoli_piste_6]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään nuolet sceneen'''
self.scene.addItem(self.nuoli_4)
self.scene.addItem(self.nuoli_5)
self.nuoli_4.hide()
self.nuoli_5.hide()
tyyppi = 1
Ominaisuudet.tuki(self, tyyppi)
self.simuloi.setEnabled(True)
def lisaa_ulkoinen_voima_nappi(self):
'''Luo Lisää ulkoinen voima -napin'''
self.lisaa_ulkoinen_voima = QPushButton("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.setToolTip("Lisää ulkoinen voima")
self.lisaa_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.lisaa_ulkoinen_voima.resize(self.button_width, self.button_height)
self.lisaa_ulkoinen_voima.font = QtGui.QFont()
self.lisaa_ulkoinen_voima.font.setPointSize(8)
self.lisaa_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.clicked.connect(self.nayta_ulkoinen_voima)
self.lisaa_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addWidget(self.lisaa_ulkoinen_voima)
def poista_ulkoinen_voima_nappi(self):
'''Luo poista ulkoinen voima -napin'''
self.poista_ulkoinen_voima = QPushButton("Poista ulkoinen voima")
self.poista_ulkoinen_voima.setToolTip("Poista ulkoinen voima")
self.poista_ulkoinen_voima.move(
0, 2 * self.button_height + 2 * self.button_separation)
self.poista_ulkoinen_voima.resize(self.button_width,
self.button_height)
self.poista_ulkoinen_voima.setFont(self.lisaa_ulkoinen_voima.font)
self.poista_ulkoinen_voima.clicked.connect(self.piilota_ulkoinen_voima)
self.poista_ulkoinen_voima.clicked.connect(self.nollaa_gradientti)
self.scene.addWidget(self.poista_ulkoinen_voima)
self.poista_ulkoinen_voima.hide()
def piilota_ulkoinen_voima(self):
'''Piilotaa kaiken ulkoiseen voimaan liittyvän'''
self.sp_voima.hide()
self.yksikko_voima.hide()
self.ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.setEnabled(True)
self.viiva.hide()
self.nuoli_3.hide()
self.viiva_5.hide()
self.nuoli_6.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
self.tulos.hide()
Ominaisuudet.ulkoinen_voima(self, 0)
def nayta_ulkoinen_voima(self):
'''Näytetään ulkoinen voima riippuen tuen tyypistä'''
self.sp_voima.show()
self.yksikko_voima.show()
self.ulkoinen_voima.show()
self.lisaa_ulkoinen_voima.hide()
self.poista_ulkoinen_voima.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 0:
self.viiva.show()
self.nuoli_3.show()
if int(Ominaisuudet.palauta_tuen_tyyppi(self)) == 1:
self.viiva_5.show()
self.nuoli_6.show()
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_valikko(self):
'''Luo voiman suuruus -tekstin'''
self.ulkoinen_voima = QGraphicsSimpleTextItem("Voiman suuruus")
self.ulkoinen_voima.setPos(600, 5)
self.ulkoinen_voima.font = QtGui.QFont()
self.ulkoinen_voima.font.setPointSize(12)
self.ulkoinen_voima.setFont(self.ulkoinen_voima.font)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.scene.addItem(self.ulkoinen_voima)
self.ulkoinen_voima.hide()
'''Luo voiman arvon QSpinBoxin'''
self.sp_voima = QSpinBox()
self.sp_voima.move(750, 5)
self.sp_voima.setRange(0, 10000)
self.sp_voima.setSingleStep(1)
self.sp_voima.setMinimumHeight(30)
self.sp_voima.setValue(int(Ominaisuudet.palauta_voima(self)))
self.sp_voima.valueChanged.connect(self.paivita_voima)
self.scene.addWidget(self.sp_voima)
self.sp_voima.hide()
'''Luo yksikönvalinta QComboBOxin'''
self.yksikko_voima = QComboBox()
self.yksikko_voima.addItem("kN", 0)
self.yksikko_voima.addItem("N", 1)
self.yksikko_voima.move(820, 5)
self.yksikko_voima.setMinimumHeight(30)
self.yksikko_voima.setCurrentIndex(
int(Ominaisuudet.palauta_voiman_yksikko(self)))
self.yksikko_voima.setEditable(True)
self.yksikko_voima.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.scene.addWidget(self.yksikko_voima)
self.yksikko_voima.currentIndexChanged.connect(
self.paivita_yksikko_voima)
self.yksikko_voima.hide()
def ulkoinen_voima_nuoli_seinatuki(self):
'''Luo nuolen osoittamaan ulkoisen voiman paikkaa'''
voima_viiva = QtGui.QPen(QtCore.Qt.black, 2)
voima_viiva.setStyle(QtCore.Qt.SolidLine)
'''Nuolen kärkien koordinaatit seinätuelle'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_paatypiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_paatypiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_paatypiste + 7, 185)
viiva_x = self.palkin_paatypiste
self.viiva = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_3 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva)
self.scene.addItem(self.nuoli_3)
self.viiva.hide()
self.nuoli_3.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def ulkoinen_voima_nuoli_alatuki(self):
'''Nuolen kärkien koordinaatit alhaalta tuetulle palkille'''
nuoli_piste_1 = QtCore.QPointF(self.palkin_keskipiste - 7, 185)
nuoli_piste_2 = QtCore.QPointF(self.palkin_keskipiste, 200)
nuoli_piste_3 = QtCore.QPointF(self.palkin_keskipiste + 7, 185)
viiva_x = self.palkin_keskipiste
'''Luodaan nuoli QPolygonItem olio'''
self.nuoli_6 = QGraphicsPolygonItem(
QtGui.QPolygonF([nuoli_piste_1, nuoli_piste_2, nuoli_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.viiva_5 = QGraphicsLineItem(
QtCore.QLineF(viiva_x, 100, viiva_x, 200))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.viiva_5)
self.scene.addItem(self.nuoli_6)
self.viiva_5.hide()
self.nuoli_6.hide()
'''Lisätään tieto, että voima on asetettu'''
Ominaisuudet.ulkoinen_voima(self, 1)
def paivita_voima(self):
'''Lukee voiman arvon
ja kutsuu Ominaisuudet luoka metodia voima'''
voima = self.sp_voima.value()
Ominaisuudet.voima(self, voima)
def paivita_yksikko_voima(self):
'''Lukee ykiskön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko_voima'''
self.yksikko_voima_arvo = self.yksikko_voima.currentData()
Ominaisuudet.yksikko_voima(self, self.yksikko_voima_arvo)
def materiaali_valikko(self):
''' Luo Materiaali-otsikon'''
self.materiaali = QGraphicsSimpleTextItem("Materiaali")
self.materiaali.setPos(
0, 3 * self.button_height + 3 * self.button_separation)
self.materiaali.font = QtGui.QFont()
self.materiaali.font.setPointSize(12)
self.materiaali.setFont(self.materiaali.font)
self.scene.addItem(self.materiaali)
'''Luo drop down valikon materiaalivalinnalle'''
self.materiaali_valinta = QComboBox()
self.materiaali_valinta.addItem("Teräs", 0)
self.materiaali_valinta.addItem("Alumiini", 1)
self.materiaali_valinta.addItem("Muovi", 2)
self.materiaali_valinta.move(
0, 3 * self.button_height + 3 * self.button_separation + 25)
self.materiaali_valinta.resize(self.button_width,
self.button_height - 25)
self.materiaali_valinta.setEditable(True)
self.materiaali_valinta.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.materiaali_valinta.setCurrentIndex(0)
self.scene.addWidget(self.materiaali_valinta)
self.materiaali_valinta.setEnabled(False)
self.materiaali_valinta.currentIndexChanged.connect(
self.paivita_materiaali)
def paivita_materiaali(self):
'''Lukee materiaalin arvon
ja kutsuu Ominaisuudet-luokan metodia materiaali'''
materiaali = self.materiaali_valinta.currentData()
Ominaisuudet.materiaali(self, materiaali)
def simulaatio_nappi(self):
'''Luo SIMULOI-napin'''
self.simuloi = QPushButton('SIMULOI')
self.simuloi.setToolTip('Simuloi valittu rakenne')
self.simuloi.move(0,
4 * self.button_height + 4 * self.button_separation)
self.simuloi.setStyleSheet("background-color:rgb(122, 201, 255)")
self.simuloi.resize(self.button_width, self.button_height)
self.simuloi.font = QtGui.QFont()
self.simuloi.font.setPointSize(12)
self.simuloi.setFont(self.simuloi.font)
self.simuloi.setEnabled(False)
self.simuloi.clicked.connect(self.simulaatio)
self.scene.addWidget(self.simuloi)
def simulaatio(self):
'''Kutsuu laskentaa suorittavaa metodia ja tallentaa tuloksen.
Tämän jälkeen kutsuu lopputuloksen esittävän tekstin päivittävää metodia
sekä palkin visualisoivaa gradient-metodia'''
Laskin.laskin(self)
Ominaisuudet.palauta_tulos(self)
self.paivita_tulos_teksti()
self.tallennaAction.setEnabled(True)
if Ominaisuudet.palauta_tuen_tyyppi(self) == 0:
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 1:
self.gradient_seina_tuki()
if Ominaisuudet.onko_ulkoinen_voima_asetettu(self) == 0:
self.gradient_seina_tuki_ei_voimaa()
if Ominaisuudet.palauta_tuen_tyyppi(self) == 1:
self.gradient_alatuki()
def tulos_teksti(self):
'''Lisää tekstin, joka kertoo maksimijänintyksen arvon'''
teksti = "Maksimijännitys " + str(self.maks_jannitys) + " MPa"
self.tulos = QGraphicsSimpleTextItem(teksti)
self.tulos.setPos(550, 500)
self.tulos.font = QtGui.QFont()
self.tulos.font.setPointSize(12)
self.tulos.setFont(self.tulos.font)
self.scene.addItem(self.tulos)
self.tulos.hide()
def paivita_tulos_teksti(self):
'''Päivittää maksimijännityksen arvoa kuvaavan tekstin'''
maks_jannitys = Ominaisuudet.palauta_tulos(self)
self.tulos.setText("Maksimijännitys " + str(maks_jannitys) + " MPa")
self.tulos.show()
def palkin_pituus_valikko(self):
'''Luo palkin pituus tekstin sekä spinbox-valitsimen pituuden asettamista varten
Päivittää palkin pituuden Ominaisuudet luokan avulla'''
self.palkin_pituus = QGraphicsSimpleTextItem("Palkin pituus")
self.palkin_pituus.setPos(300, 5)
self.palkin_pituus.font = QtGui.QFont()
self.palkin_pituus.font.setPointSize(12)
self.palkin_pituus.setFont(self.palkin_pituus.font)
self.scene.addItem(self.palkin_pituus)
self.palkin_pituus.hide()
self.sp = QSpinBox()
self.scene.addWidget(self.sp)
self.sp.hide()
self.sp.move(450, 5)
self.sp.setRange(0, 100)
self.sp.setSingleStep(1)
self.sp.setMinimumHeight(30)
self.sp.setValue(int(Ominaisuudet.palauta_palkin_pituus(self)))
self.paivita_pituus()
self.sp.valueChanged.connect(self.paivita_pituus)
def paivita_pituus(self):
'''Lukee palkin pituuden ja aktivoi Ominaisuudet luokan meodin palkin pituus'''
self.palkin_pituus_arvo = self.sp.value()
Ominaisuudet.palkin_pituus(self, self.palkin_pituus_arvo)
self.paivita_asteikon_arvot()
def yksikko_pituus(self):
'''Luo yksikönvalinta dropdown-menun
ja arvon muuttuessa päivittää yksikön Ominaisuudet-luokassa'''
self.yksikko = QComboBox()
self.yksikko.addItem("m", 0)
self.yksikko.addItem("cm", 1)
self.yksikko.addItem("mm", 2)
self.yksikko.move(500, 5)
self.yksikko.setMinimumHeight(30)
self.yksikko.setEditable(True)
self.yksikko.lineEdit().setAlignment(QtCore.Qt.AlignCenter)
self.yksikko.setCurrentIndex(
Ominaisuudet.palauta_pituuden_yksikko(self))
self.scene.addWidget(self.yksikko)
self.yksikko.hide()
self.yksikko_arvo = self.yksikko.currentData()
self.yksikko.currentIndexChanged.connect(self.paivita_yksikko)
def paivita_yksikko(self):
'''Lukee yksikön arvon
ja kutsuu Ominaisuudet-luokan metodia yksikko'''
self.yksikko_arvo = self.yksikko.currentData()
Ominaisuudet.yksikko(self, self.yksikko_arvo)
self.paivita_asteikon_arvot()
def asteikko(self):
''''Luodaan viivaa kuvaava olio'''
viiva = QtGui.QPen(QtCore.Qt.black, 2)
viiva.setStyle(QtCore.Qt.SolidLine)
'''Oikean puoleisen nuolen kärkien koordinaatit'''
nuoli_1_piste_1 = QtCore.QPointF(990, 390)
nuoli_1_piste_2 = QtCore.QPointF(1000, 400)
nuoli_1_piste_3 = QtCore.QPointF(990, 410)
'''Vasemman puoleisen nuolen kärkien koordinaatit'''
nuoli_2_piste_1 = QtCore.QPointF(310, 390)
nuoli_2_piste_2 = QtCore.QPointF(300, 400)
nuoli_2_piste_3 = QtCore.QPointF(310, 410)
'''Luodaan nuoli QPolygonF oliot'''
self.nuoli_1 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_1_piste_1, nuoli_1_piste_2, nuoli_1_piste_3]))
self.nuoli_2 = QGraphicsPolygonItem(
QtGui.QPolygonF(
[nuoli_2_piste_1, nuoli_2_piste_2, nuoli_2_piste_3]))
self.nuoli_brush = QtGui.QBrush(1)
self.nuoli_pencil = QtGui.QPen(QtCore.Qt.black, 2)
self.nuoli_pencil.setStyle(QtCore.Qt.SolidLine)
self.line = QGraphicsLineItem(QtCore.QLineF(300, 400, 1000, 400))
'''Lisätään viiva sekä päiden nuolet sceneen'''
self.scene.addItem(self.line)
self.scene.addItem(self.nuoli_1)
self.scene.addItem(self.nuoli_2)
self.line.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
def lisaa_asteikko_arvo(self):
'''Lisää tekstikentän pituuden arvolle sekä yksikölle'''
teksti = (str(Ominaisuudet.palauta_palkin_pituus(self)) + " " + "m")
self.asteikko_teksti = QGraphicsSimpleTextItem()
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.setPos(650, 425)
self.asteikko_teksti.font = QtGui.QFont()
self.asteikko_teksti.font.setPointSize(12)
self.asteikko_teksti.setFont(self.asteikko_teksti.font)
self.scene.addItem(self.asteikko_teksti)
self.asteikko_teksti.hide()
def paivita_asteikon_arvot(self):
'''Päivittää palkin pituutta kuvaavan asteikon'''
yksikko = Ominaisuudet.palauta_pituuden_yksikko(self)
if yksikko == 0:
self.yksikko_merkki = "m"
if yksikko == 1:
self.yksikko_merkki = "cm"
if yksikko == 2:
self.yksikko_merkki = "mm"
pituus = float(Ominaisuudet.palauta_palkin_pituus(self))
teksti = str(str(pituus) + " " + self.yksikko_merkki)
self.asteikko_teksti.setText(teksti)
self.asteikko_teksti.show()
def gradient_seina_tuki(self):
'''Luo seinästä tuetun palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_seina_tuki_ei_voimaa(self):
'''Luo ilman ulkoista voimaa olevan gradientin'''
gradient = QLinearGradient(300, 200, 300 + (self.palkin_leveys / 2),
200)
gradient.setColorAt(0, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def gradient_alatuki(self):
'''Luo kahdella alatuella olevan palkin rasitusta kuvaavan gradientin'''
gradient = QLinearGradient(300, 200, 300 + self.palkin_leveys, 200)
gradient.setColorAt(0, QColor(65, 244, 83))
gradient.setColorAt(0.5, QColor(244, 72, 66))
gradient.setColorAt(1, QColor(65, 244, 83))
self.rect.setBrush(gradient)
def nollaa_gradientti(self):
'''Asettaa palkin "normaaliksi"'''
self.rect.setBrush(QBrush(4))
def uusi_rakenne(self):
'''Muokkaa ikkunaa uuden simulaation luomista varten'''
self.rect.hide()
self.ulkoinen_voima.hide()
self.sp_voima.hide()
self.yksikko_voima.hide()
self.nuoli_1.hide()
self.nuoli_2.hide()
self.nuoli_3.hide()
self.nuoli_4.hide()
self.nuoli_5.hide()
self.nuoli_6.hide()
self.viiva_1.hide()
self.viiva_2.hide()
self.viiva_3.hide()
self.viiva_4.hide()
self.viiva_5.hide()
self.viiva.hide()
self.palkin_pituus.hide()
self.sp.hide()
self.yksikko.hide()
self.line.hide()
self.asteikko_teksti.hide()
self.tulos.hide()
self.nollaa_gradientti()
self.lisaa_tuki.show()
self.vaihda_tuki.hide()
self.poista_ulkoinen_voima.hide()
self.lisaa_ulkoinen_voima.show()
Ominaisuudet.alkuarvot(self)
'''Asettaa napit'''
self.uusi_palkki.setEnabled(True)
self.lisaa_ulkoinen_voima.setEnabled(False)
self.lisaa_tuki.setEnabled(False)
self.simuloi.setEnabled(False)
self.tallennaAction.setEnabled(False)
'''Päivittää tuen tyypiksi arvon, joka vastaa, ettei tukea ole'''
self.tuen_tyyppi = 2
def close_application(self):
'''sulkee ohjelman'''
sys.exit()
class Preferences(QMainWindow):
run_wizard_requested = pyqtSignal()
def __init__(self, gui, initial_plugin=None, close_after_initial=False):
QMainWindow.__init__(self, gui)
self.gui = gui
self.must_restart = False
self.committed = False
self.close_after_initial = close_after_initial
self.resize(930, 720)
nh, nw = min_available_height() - 25, available_width() - 10
if nh < 0:
nh = 800
if nw < 0:
nw = 600
nh = min(self.height(), nh)
nw = min(self.width(), nw)
self.resize(nw, nh)
self.esc_action = QAction(self)
self.addAction(self.esc_action)
self.esc_action.setShortcut(QKeySequence(Qt.Key_Escape))
self.esc_action.triggered.connect(self.esc)
geom = gprefs.get('preferences_window_geometry', None)
if geom is not None:
self.restoreGeometry(geom)
# Center
if islinux:
self.move(gui.rect().center() - self.rect().center())
self.setWindowModality(Qt.WindowModal)
self.setWindowTitle(__appname__ + ' - ' + _('Preferences'))
self.setWindowIcon(QIcon(I('config.png')))
self.status_bar = StatusBar(self)
self.setStatusBar(self.status_bar)
self.stack = QStackedWidget(self)
self.cw = QWidget(self)
self.cw.setLayout(QVBoxLayout())
self.cw.layout().addWidget(self.stack)
self.bb = QDialogButtonBox(QDialogButtonBox.Close)
self.wizard_button = self.bb.addButton(_('Run welcome wizard'),
self.bb.ActionRole)
self.wizard_button.setIcon(QIcon(I('wizard.png')))
self.wizard_button.clicked.connect(self.run_wizard,
type=Qt.QueuedConnection)
self.cw.layout().addWidget(self.bb)
self.bb.button(self.bb.Close).setDefault(True)
self.bb.rejected.connect(self.close, type=Qt.QueuedConnection)
self.setCentralWidget(self.cw)
self.browser = Browser(self)
self.browser.show_plugin.connect(self.show_plugin)
self.stack.addWidget(self.browser)
self.scroll_area = QScrollArea(self)
self.stack.addWidget(self.scroll_area)
self.scroll_area.setWidgetResizable(True)
self.setContextMenuPolicy(Qt.NoContextMenu)
self.bar = QToolBar(self)
self.addToolBar(self.bar)
self.bar.setVisible(False)
self.bar.setIconSize(QSize(ICON_SIZE, ICON_SIZE))
self.bar.setMovable(False)
self.bar.setFloatable(False)
self.bar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
self.apply_action = self.bar.addAction(QIcon(I('ok.png')), _('&Apply'),
self.commit)
self.cancel_action = self.bar.addAction(QIcon(I('window-close.png')),
_('&Cancel'), self.cancel)
self.bar_title = BarTitle(self.bar)
self.bar.addWidget(self.bar_title)
self.restore_action = self.bar.addAction(QIcon(I('clear_left.png')),
_('Restore &defaults'),
self.restore_defaults)
for ac, tt in [('apply', _('Save changes')),
('cancel', _('Cancel and return to overview'))]:
ac = getattr(self, ac + '_action')
ac.setToolTip(tt)
ac.setWhatsThis(tt)
ac.setStatusTip(tt)
for ch in self.bar.children():
if isinstance(ch, QToolButton):
ch.setCursor(Qt.PointingHandCursor)
ch.setAutoRaise(True)
self.stack.setCurrentIndex(0)
if initial_plugin is not None:
category, name = initial_plugin
plugin = get_plugin(category, name)
if plugin is not None:
self.show_plugin(plugin)
def run_wizard(self):
self.close()
self.run_wizard_requested.emit()
def set_tooltips_for_labels(self):
def process_child(child):
for g in child.children():
if isinstance(g, QLabel):
buddy = g.buddy()
if buddy is not None and hasattr(buddy, 'toolTip'):
htext = unicode(buddy.toolTip()).strip()
etext = unicode(g.toolTip()).strip()
if htext and not etext:
g.setToolTip(htext)
g.setWhatsThis(htext)
else:
process_child(g)
process_child(self.showing_widget)
def show_plugin(self, plugin):
self.showing_widget = plugin.create_widget(self.scroll_area)
self.showing_widget.genesis(self.gui)
self.showing_widget.initialize()
self.set_tooltips_for_labels()
self.scroll_area.setWidget(self.showing_widget)
self.stack.setCurrentIndex(1)
self.showing_widget.show()
self.setWindowTitle(__appname__ + ' - ' + _('Preferences') + ' - ' +
plugin.gui_name)
self.apply_action.setEnabled(False)
self.showing_widget.changed_signal.connect(
lambda: self.apply_action.setEnabled(True))
self.showing_widget.restart_now.connect(self.restart_now)
self.restore_action.setEnabled(
self.showing_widget.supports_restoring_to_defaults)
tt = self.showing_widget.restore_defaults_desc
if not self.restore_action.isEnabled():
tt = _('Restoring to defaults not supported for') + ' ' + \
plugin.gui_name
self.restore_action.setToolTip(textwrap.fill(tt))
self.restore_action.setWhatsThis(textwrap.fill(tt))
self.restore_action.setStatusTip(tt)
self.bar_title.show_plugin(plugin)
self.setWindowIcon(QIcon(plugin.icon))
self.bar.setVisible(True)
self.bb.setVisible(False)
def hide_plugin(self):
self.showing_widget = QWidget(self.scroll_area)
self.scroll_area.setWidget(self.showing_widget)
self.setWindowTitle(__appname__ + ' - ' + _('Preferences'))
self.bar.setVisible(False)
self.stack.setCurrentIndex(0)
self.setWindowIcon(QIcon(I('config.png')))
self.bb.setVisible(True)
def esc(self, *args):
if self.stack.currentIndex() == 1:
self.cancel()
elif self.stack.currentIndex() == 0:
self.close()
def restart_now(self):
try:
self.showing_widget.commit()
except AbortCommit:
return
self.hide_plugin()
self.close()
self.gui.quit(restart=True)
def commit(self, *args):
try:
must_restart = self.showing_widget.commit()
except AbortCommit:
return
rc = self.showing_widget.restart_critical
self.committed = True
do_restart = False
if must_restart:
self.must_restart = True
msg = _('Some of the changes you made require a restart.'
' Please restart calibre as soon as possible.')
if rc:
msg = _('The changes you have made require calibre be '
'restarted immediately. You will not be allowed to '
'set any more preferences, until you restart.')
do_restart = show_restart_warning(msg, parent=self)
self.showing_widget.refresh_gui(self.gui)
self.hide_plugin()
if self.close_after_initial or (must_restart and rc) or do_restart:
self.close()
if do_restart:
self.gui.quit(restart=True)
def cancel(self, *args):
if self.close_after_initial:
self.close()
else:
self.hide_plugin()
def restore_defaults(self, *args):
self.showing_widget.restore_defaults()
def closeEvent(self, *args):
gprefs.set('preferences_window_geometry',
bytearray(self.saveGeometry()))
if self.committed:
self.gui.must_restart_before_config = self.must_restart
self.gui.tags_view.recount()
self.gui.create_device_menu()
self.gui.set_device_menu_items_state(
bool(self.gui.device_connected))
self.gui.bars_manager.apply_settings()
self.gui.bars_manager.update_bars()
self.gui.build_context_menus()
return QMainWindow.closeEvent(self, *args)
canvas.change_title.connect(set_title)
canvas.reset.connect(lambda: change_zoom(cell_size, restore_pattern=False))
canvas.reset_and_load.connect(
lambda grid: change_zoom(cell_size, overwrite=grid))
# Setting Title of Application
window.setWindowTitle(
f"Cellular Automaton Viewer [{cacanvas.ca_rule_name}, No Pattern, "
f"Number of States: {cacanvas.num_states}]")
grid.addWidget(canvas, 1, 0)
# Menu Bar
menu = QMenuBar()
file_menu = menu.addMenu("File")
new_pattern_action = QAction("New Pattern")
new_pattern_action.setShortcut("Ctrl+N")
new_pattern_action.triggered.connect(
lambda: change_zoom(cell_size, restore_pattern=False))
file_menu.addAction(new_pattern_action)
open_pattern_action = QAction("Open Pattern")
open_pattern_action.setShortcut("Ctrl+O")
open_pattern_action.triggered.connect(canvas.open_pattern)
file_menu.addAction(open_pattern_action)
save_pattern_action = QAction("Save Pattern")
save_pattern_action.setShortcut("Ctrl+S")
save_pattern_action.triggered.connect(canvas.save_pattern)
file_menu.addAction(save_pattern_action)
file_menu.addSeparator()
"""
Adds menu option to reload (which also backs up) the collection.
"""
from PyQt5.Qt import QAction
from PyQt5.QtGui import QKeySequence
from aqt import mw
def reloadCollection():
mw.unloadCollection(mw.loadCollection)
# Create action
reload_action = QAction('&Reload (and back up) collection')
reload_action.setShortcut(QKeySequence('Ctrl+R'))
reload_action.triggered.connect(reloadCollection)
# Insert into menu
menu = mw.form.menuCol
before = mw.form.actionExit
menu.insertAction(before, reload_action)
menu.insertSeparator(before)