def prefMenuItem_radioButtons(preferenceName,
labelList,
defaultIndex,
menu,
command=None,
font=None):
"""Adds a set of radio buttons to the menu, who's value selection gets stored as
a preference"""
actionGroup = QtGui.QActionGroup(menu)
actionGroup.setExclusive(True)
defaultIndex = ka_preference.get(preferenceName, defaultIndex)
for i, label in enumerate(labelList):
action = actionGroup.addAction(label)
action.setCheckable(True)
if font:
action.setFont(font)
if i == defaultIndex:
action.setChecked(True)
def cmd(i=i, preferenceName=preferenceName, command=command):
ka_preference.set(preferenceName, i)
if command != None:
command()
menu.connect(action, QtCore.SIGNAL('triggered()'), cmd)
menu.addAction(action)
return actionGroup
def __init__(self):
loader = QUiLoader()
filePath = os.path.join(os.path.dirname(__file__), 'bug_426.ui')
self.widget = loader.load(filePath)
self.group = QtGui.QActionGroup(self.widget)
self.widget.show()
QtCore.QTimer.singleShot(0, self.widget.close)
def createActions(self):
self.addImagesAct = QtGui.QAction("&Add Images...",
self,
shortcut="Ctrl+A",
triggered=self.addImage)
self.removeAllImagesAct = QtGui.QAction("&Remove All Images",
self,
shortcut="Ctrl+R",
triggered=self.removeAllImages)
self.exitAct = QtGui.QAction("&Quit",
self,
shortcut="Ctrl+Q",
triggered=self.close)
self.styleActionGroup = QtGui.QActionGroup(self)
for styleName in QtGui.QStyleFactory.keys():
action = QtGui.QAction(self.styleActionGroup,
text="%s Style" % styleName,
checkable=True,
triggered=self.changeStyle)
action.setData(styleName)
self.guessModeStateAct = QtGui.QAction("&Guess Image Mode/State",
self,
checkable=True,
checked=True)
self.aboutAct = QtGui.QAction("&About", self, triggered=self.about)
self.aboutQtAct = QtGui.QAction("About &Qt",
self,
triggered=QtGui.qApp.aboutQt)
def __init__(self, *args, **kwargs):
super(LayerToggleGroup, self).__init__(*args, **kwargs)
self.actions = {}
self.actionGroup = QtGui.QActionGroup(self)
self.actionGroup.setExclusive(False)
self.options = {}
for layer in Layer.AllLayers:
option = LayerToggleOptions.getOption("%s_visible" % layer, bool,
True)
self.options[layer] = option
action = QtGui.QAction(layer, self)
action.setCheckable(True)
action.setChecked(option.value())
log.info("LAYER %s VISIBLE %s", layer, option.value())
action.layerName = layer
self.actions[layer] = action
self.actionGroup.addAction(action)
self.actionGroup.triggered.connect(self.actionTriggered)
self.menu = QtGui.QMenu()
for layer in Layer.AllLayers:
self.menu.addAction(self.actions[layer])
def ViewMenu(self):
font = QtGui.QAction(QtGui.QIcon('exit.png'), '&Font', self)
font.setShortcut('Shift+F')
font.triggered.connect(self.fontEdit)
viewmenu = self.menu.addMenu('&View')
viewmenu.addAction(font)
syntaxMenu = viewmenu.addMenu('&Syntax Highlighting')
self.group = QtGui.QActionGroup(self, exclusive=True)
self.checkdefault = self.group.addAction(
QtGui.QAction('&None', self, checkable=True))
self.checkdefault.setChecked(True)
syntaxMenu.addAction(self.checkdefault)
self.checkpython = self.group.addAction(
QtGui.QAction('&Python', self, checkable=True))
syntaxMenu.addAction(self.checkpython)
self.checkc = self.group.addAction(
QtGui.QAction('&C/C++', self, checkable=True))
syntaxMenu.addAction(self.checkc)
self.checkhtml = self.group.addAction(
QtGui.QAction('&HTML', self, checkable=True))
syntaxMenu.addAction(self.checkhtml)
self.checkmkd = self.group.addAction(
QtGui.QAction('&Markdown', self, checkable=True))
syntaxMenu.addAction(self.checkmkd)
self.checkc.triggered.connect(self.changeHighlightToC)
self.checkpython.triggered.connect(self.changeHighlightToPython)
self.checkhtml.triggered.connect(self.changeHighlightToHtml)
self.checkmkd.triggered.connect(self.changeHighlightToMkd)
self.checkdefault.triggered.connect(self.removeHighlight)
def __init__(self, *args, **kwargs):
QtGui.QMainWindow.__init__(self)
w = QtGui.QWidget()
self.setCentralWidget(w)
self.resize(800,600)
self.setWindowTitle('Simple')
fileMenu = self.menuBar().addMenu('&File')
optMenu = self.menuBar().addMenu('&Options')
self.addToMenu(fileMenu, '&New', lambda: self.new())
self.addToMenu(fileMenu, '&Open...', lambda: self.openConf())
self.addToMenu(fileMenu, '&Save', lambda: self.saveConf(True))
self.addToMenu(fileMenu, 'Save &as...', lambda: self.saveConf(False))
self.addToMenu(fileMenu, '&Quit', self.close)
optLevelGroup = QtGui.QActionGroup(optMenu)
a = self.addToMenu(optMenu, '&Basic',
lambda: self.setLevel(0), optLevelGroup)
self.addToMenu(optMenu, '&Advanced',
lambda: self.setLevel(1), optLevelGroup)
self.addToMenu(optMenu, '&Expert',
lambda: self.setLevel(2), optLevelGroup)
a.setChecked(True)
self.level = 0
self.confFileName = None
if len(args) == 2:
self.new(args[1])
else:
self.new()
def __init__(self, session=None, parent=None):
'''Main window that holds all GUI pieces.'''
super(MainWindow, self).__init__(parent)
# -- Functional members --
self.session = session
self.regActionGroup = QtGui.QActionGroup(self) # Registration actions
self.fitAtStart = True # Fit image to window at start (or not)
# -- Widget members --
self.imageViewer = imageviewer.ImageViewer(self, fit=self.fitAtStart)
self.imhist = histogram.HistogramEditor() # If parent=self, it will be non-window child
# -- Intialize graphical interface --
self.init_ui()
# -- If session already has images, show them --
if session.loaded:
# FIXME: initialization should be automatic inside imageViewer
# maybe by checking a flag (reset when loading data)
self.imageViewer.initialize(self.session.get_current_image())
self.set_image()
# -- Connect signals --
self.imhist.sliders.sliderMoved.connect(self.change_levels)
def create_connections(self):
# Define group to action fit items and load fit of settings file
self.ui.action_group_view = QtGui.QActionGroup(self)
self.ui.action_group_view.addAction(self.ui.action_original_fit)
self.ui.action_group_view.addAction(self.ui.action_vertical_fit)
self.ui.action_group_view.addAction(self.ui.action_horizontal_fit)
self.ui.action_group_view.addAction(self.ui.action_best_fit)
view_adjust = self.model.load_view_adjust(
self.ui.action_group_view.checkedAction().objectName())
# Define that action fit is checked
for act in self.ui.action_group_view.actions():
if act.objectName() == view_adjust:
act.setChecked(True)
self.model.fit_type = act.objectName()
# Connect recent file menu
for act in self.ui.menu_recent_files.actions():
act.triggered.connect(self.open_recent_file)
# Connect recent bookmark menu
for act in self.ui.menu_recent_bookmarks.actions():
act.triggered.connect(self.open_recent_bookmark)
# update recent bookmark menu when mouse hover
self.ui.menu_recent_bookmarks.aboutToShow.connect(
self.update_recent_bookmarks_menu)
def __init__(self):
"""
Create toolbar and invoke pressing of first tab.
"""
super().__init__()
layout = QtGui.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
# create tool bar
toolbar = QtGui.QToolBar()
action_group = QtGui.QActionGroup(toolbar)
toolbar.addAction(g.create_action(t.load_ui_icon('icon.lobby.single.new.png'), 'Start new single player scenario', action_group, toggle_connection=self.toggled_single_player_scenario_selection, checkable=True))
toolbar.addAction(g.create_action(t.load_ui_icon('icon.lobby.single.load.png'), 'Continue saved single player scenario', action_group, toggle_connection=self.toggled_single_player_load_scenario, checkable=True))
toolbar.addSeparator()
toolbar.addAction(g.create_action(t.load_ui_icon('icon.lobby.network.png'), 'Show server lobby', action_group, toggle_connection=self.toggled_server_lobby, checkable=True))
toolbar.addAction(g.create_action(t.load_ui_icon('icon.lobby.multiplayer-game.png'), 'Start or continue multiplayer scenario', action_group, toggle_connection=self.toggled_multiplayer_scenario_selection, checkable=True))
layout.addWidget(toolbar)
content = QtGui.QWidget()
self.content_layout = QtGui.QVBoxLayout(content)
self.content_layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(content)
def setupGUI(self):
pg.setConfigOption('background', (255, 255, 255))
pg.setConfigOption('foreground', (0, 0, 0))
self.layout = QtGui.QVBoxLayout()
self.layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(self.layout)
# menu
self.menuBar = QtGui.QMenuBar()
self.layout.setMenuBar(self.menuBar)
# menu actions
self.viewMenu = self.menuBar.addMenu('View')
self.parMenu = self.viewMenu.addMenu('Parameter')
self.plotVsMenu = self.viewMenu.addMenu('Plot versus')
self.plotVsXAction = QtGui.QAction('x', self, checkable=True)
self.plotVsYAction = QtGui.QAction('y', self, checkable=True)
self.plotVsGroup = QtGui.QActionGroup(self)
self.plotVsXAction.setActionGroup(self.plotVsGroup)
self.plotVsYAction.setActionGroup(self.plotVsGroup)
self.plotVsMenu.addAction(self.plotVsXAction)
self.plotVsMenu.addAction(self.plotVsYAction)
self.plotVsXAction.setChecked(True)
self.autoScaleAction = QtGui.QAction('Auto scale',
self,
checkable=True)
self.autoScaleAction.setChecked(True)
self.viewMenu.addAction(self.autoScaleAction)
self.parameterGroup = QtGui.QActionGroup(self)
# widgets
splitter = QtGui.QSplitter()
splitter.setOrientation(QtCore.Qt.Horizontal)
self.tree = CParameterTree(name='Elastic moduli')
self.sublayout = pg.GraphicsLayoutWidget()
#
self.layout.addWidget(splitter)
splitter.addWidget(self.tree)
splitter.addWidget(self.sublayout)
self.plt = self.sublayout.addPlot()
setupPlot.setup_plot(self.plt)
#
self.tree.setGeometry(0, 0, 200, 15)
splitter.setSizes([
int(self.width() * 0.4),
int(self.width() * 0.6),
])
splitter.setStretchFactor(0, 0)
splitter.setStretchFactor(1, 1)
def create_action(self,i):
amp_group = QtGui.QActionGroup(self)
five = QtGui.QAction(amp_group, checkable=True)
five.setText('500')
ten = QtGui.QAction(amp_group, checkable=True, checked=True)
ten.setText('1000')
amp_group.triggered.connect(lambda button: self.change_amp(button, i))
return amp_group, five, ten
def __initUI__(self):
self.ui = Ui_mapcreater()
self.ui.setupUi(self)
g1 = QtGui.QActionGroup(self)
g1.addAction(self.ui.actionDrawMap)
g1.addAction(self.ui.actionDrawRoute)
g2 = QtGui.QActionGroup(self)
g2.addAction(self.ui.actionEraser)
g2.addAction(self.ui.actionPen)
self.sa = QtGui.QScrollArea()
self.sa.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.sa.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.sa.setWidgetResizable(False)
self.mc = MapCanvas(self.sa)
self.sa.setWidget(self.mc)
self.setCentralWidget(self.sa)
self.centralWidget().setAlignment(QtCore.Qt.AlignCenter)
def _setQActionGroup(self,menu,enum):
#Set Menu Saves Config File Chackable
indexes = menu.actions()
menu.clear()
print len(indexes)
group = QtGui.QActionGroup(self.ui)
mapper = QtCore.QSignalMapper()
group.setExclusive(True)
for item in enum.names.items():
index = QtGui.QAction(item[0],group)
index.setCheckable(True)
index.triggered.connect(mapper.map)
mapper.setMapping(index,item[1])
group.addAction(index)
return group,mapper
def __init__(self):
QtGui.QMainWindow.__init__(self)
self.currentPath = ""
self.area = SvgWindow()
fileMenu = QtGui.QMenu(self.tr("&File"), self)
self.openAction = fileMenu.addAction(self.tr("&Open..."))
self.openAction.setShortcut(QtGui.QKeySequence(self.tr("Ctrl+O")))
self.quitAction = fileMenu.addAction(self.tr("E&xit"))
self.quitAction.setShortcut(QtGui.QKeySequence(self.tr("Ctrl+Q")))
self.menuBar().addMenu(fileMenu)
rendererMenu = QtGui.QMenu(self.tr("&Renderer"), self)
self.nativeAction = rendererMenu.addAction(self.tr("&Native"))
self.nativeAction.setCheckable(True)
if QtOpenGL.QGLFormat.hasOpenGL():
self.glAction = rendererMenu.addAction(self.tr("&OpenGL"))
self.glAction.setCheckable(True)
self.imageAction = rendererMenu.addAction(self.tr("&Image"))
self.imageAction.setCheckable(True)
self.imageAction.setChecked(True)
rendererGroup = QtGui.QActionGroup(self)
rendererGroup.addAction(self.nativeAction)
if QtOpenGL.QGLFormat.hasOpenGL():
rendererGroup.addAction(self.glAction)
rendererGroup.addAction(self.imageAction)
self.menuBar().addMenu(rendererMenu)
self.connect(self.openAction, QtCore.SIGNAL("triggered()"),
self.openFile)
self.connect(self.quitAction, QtCore.SIGNAL("triggered()"), QtGui.qApp,
QtCore.SLOT("quit()"))
self.connect(rendererGroup, QtCore.SIGNAL("triggered(QAction *)"),
self.setRenderer)
self.setCentralWidget(self.area)
self.setWindowTitle(self.tr("SVG Viewer"))
def init_draft_statusbar_scale():
"""
this function initializes draft statusbar scale widget
"""
param = App.ParamGet("User parameter:BaseApp/Preferences/Mod/Draft")
mw = Gui.getMainWindow()
if mw:
sb = mw.statusBar()
if sb is None:
return
else:
return
scale_widget = QtGui.QToolBar()
scale_widget.setObjectName("draft_status_scale_widget")
# get scales list according to system units
draft_scales = get_scales()
# get draft annotation scale
draft_annotation_scale = param.GetFloat("DraftAnnotationScale", 1.0)
# initializes scale widget
scale_widget.draft_scales = draft_scales
scaleLabel = QtGui.QPushButton("Scale")
scaleLabel.setObjectName("ScaleLabel")
scaleLabel.setFlat(True)
menu = QtGui.QMenu(scaleLabel)
gUnits = QtGui.QActionGroup(menu)
for u in draft_scales:
a = QtGui.QAction(gUnits)
a.setText(u)
menu.addAction(a)
scaleLabel.setMenu(menu)
gUnits.triggered.connect(_set_scale)
scale_label = scale_to_label(draft_annotation_scale)
scaleLabel.setText(scale_label)
tooltip = "Set the scale used by draft annotation tools"
scaleLabel.setToolTip(QT_TRANSLATE_NOOP("draft", tooltip))
scale_widget.addWidget(scaleLabel)
scale_widget.scaleLabel = scaleLabel
# add scale widget to the statusbar
sb.insertPermanentWidget(3, scale_widget)
scale_widget.show()
def makePlotMenu(self, name, plots, style_fn):
if not len(plots):
return
menu = QtGui.QMenu(name, self.lineStyleMenu)
group = QtGui.QActionGroup(act)
action = QtGui.QAction("All", group)
action.triggered.connect(lambda: AllLineStyleDialog(self, name, self.getCanvas(), plots, style_fn).exec_())
group.addAction(action)
sep = QtGui.QAction(group)
sep.setSeparator(True)
group.addAction(sep)
for y in plots:
style = style_fn(y)
action = QtGui.QAction(style.label, group)
action.triggered.connect(lambda yin=y,stylein=style: LineStyleDialog(self, yin, self.getCanvas(), stylein, style_fn).exec_())
group.addAction(action)
menu.addActions(group.actions())
self.lineStyleMenu.addMenu(menu)
def init_ui(self):
self.resize(800, 700)
self.setContentsMargins(10, 10, 10, 10)
self.setWindowTitle('Mine Bash')
filemenu = self.menuBar().addMenu('File')
self.open = filemenu.addAction('Open')
self.save = filemenu.addAction('Save')
self.tabs = QtGui.QTabWidget(self)
self.setCentralWidget(self.tabs)
self.tools = QtGui.QToolBar(self)
self.addToolBar(self.tools)
# selection tools
self.seltools = QtGui.QActionGroup(self.tools)
self.brush = self.tools.addAction('Brush')
self.brush.setCheckable(1)
self.seltools.addAction(self.brush)
self.box = self.tools.addAction('Box')
self.box.setCheckable(1)
self.seltools.addAction(self.box)
# clipboard tools
self.tools.addSeparator()
self.copybtn = self.tools.addAction('Copy')
self.pastebtn = self.tools.addAction('Paste')
self.mergebtn = self.tools.addAction('Merge')
self.cancelbtn = self.tools.addAction('Cancel Merge')
# status bar
self.status = self.statusBar()
self.status.setSizeGripEnabled(0)
self.status.setContentsMargins(10, 0, 10, 0)
self.copylabel = QtGui.QLabel('')
self.status.addWidget(self.copylabel)
def __init__(self, parent=None):
super(TexManagerUI, self).__init__(parent=parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.coordinator = CoordinatorMayaUI()
self.clipboard = None
uiAGR_selectionBehaviour = QtGui.QActionGroup(self)
self.ui.uiACT_selectNothing.setActionGroup(uiAGR_selectionBehaviour)
self.ui.uiACT_selectTextureNode.setActionGroup(
uiAGR_selectionBehaviour)
self.ui.uiACT_selectAssigned.setActionGroup(uiAGR_selectionBehaviour)
self.searchReplaceDlg = SearchReplaceDialog(self)
self.retargetDlg = RetargetDialog(self)
self.copyMoveDlg = CopyMoveDialog(self)
self.logDlg = LogDialog(self)
self.createContextMenu()
self.ui_initSettings()
self.setUpdatesAllowed(False)
self.ui_loadSettings(self.ui.uiACT_collapseRepetitions)
self.setUpdatesAllowed(True)
self.harvester = MayaSceneHarvester()
self.setTableDelegates()
self.initModels()
self.fillTable()
self.ui_loadSettings()
self.connect(
self.ui.uiTBL_textures.selectionModel(),
QtCore.SIGNAL('selectionChanged(QItemSelection, QItemSelection)'),
self.onTableSelectionChanged)
self.displayStatusBarInfo()
self.updateUiStates()
def __init__(self, parent=None, f=QtCore.Qt.WindowFlags()):
""" SpreadsheetWindow(parent: QWidget, f: WindowFlags)
-> SpreadsheetWindow
Layout menu, status bar and tab widget
"""
QtGui.QMainWindow.__init__(self, parent, f)
self.setWindowTitle('UV-CDAT - Untitled')
self.shownConfig = False #flag to control the window setup code is done only once
# The stack of current spreadsheets
self.stackedCentralWidget = QtGui.QStackedWidget(self)
# The controller that handles the spreadsheets
self.tabControllerStack = TabControllerStack(self.stackedCentralWidget)
# FIXME: Temprary create view for now
self.tabControllerStack.add_view('Default')
self.stackedCentralWidget.addWidget(self.tabControllerStack)
# Do we need fullscreen?
self.fullScreenStackedWidget = QtGui.QStackedWidget(
self.stackedCentralWidget)
self.stackedCentralWidget.addWidget(self.fullScreenStackedWidget)
self.setCentralWidget(self.stackedCentralWidget)
self.setStatusBar(QtGui.QStatusBar(self))
self.modeActionGroup = QtGui.QActionGroup(self)
self.App = QtCore.QCoreApplication.instance()
self.App.installEventFilter(self)
self.setupMenu()
self.tabControllerStack.needChangeTitle.connect(self.setWindowTitle)
self.quitAction = QtGui.QAction('&Quit Spreadsheet', self)
self.addAction(self.quitAction)
self.quitAction.setShortcut('Ctrl+Q')
self.quitAction.triggered.connect(self.quitActionTriggered)
# if the spreadsheet has one row and 2 columns
# this will cause the spreadsheet to have each cell
# 550 x 450 size in the server
#self.resize(1156, 599)
# FIXME: remove test
self.testPlot()
def __init__(self):
QtCore.QObject.__init__(self)
elements = utils.loadUi(self._MAIN_WINDOW_UI)
self.window = elements["MainWindow"]
# Binding Window's custom event handlers
self.window.closeEvent = self.closeEvent
self.centralWidget = elements["centralWidget"]
# Menus
self.menuFile = elements["menuFile"]
elements["actionQuit"].triggered.connect(self.window.close)
self._actionQuit = elements["actionQuit"]
self.menuEdit = elements["menuEdit"]
self._actionDevices = elements["actionDevices"]
self.menuView = elements["menuView"]
# Tool bars
self.toolBarMain = elements["toolBarMain"]
self.toolBarSwitch = elements["toolBarSwitch"]
self.toolBarView = elements["toolBarView"]
# Dialogs
self.about = about.About()
elements["actionAbout"].triggered.connect(self.about.run)
self.devices = devices.DevicesDialog()
elements["actionDevices"].triggered.connect(self.devices.run)
self.settings = settings.SettingsDialog()
elements["actionSettings"].triggered.connect(self.settings.run)
# Views
self._viewGroup = QtGui.QActionGroup(self.window)
self._views = view.all(self)
for i, obj in enumerate(self._views):
self._viewGroup.addAction(obj.action)
self.menuView.addAction(obj.action)
self.toolBarSwitch.addAction(obj.action)
obj.action.setShortcut("ALT+%d" % (i+1))
# Uniform width of ToolBar buttons
self._buttonWidth = QtGui.QFontMetrics(self.window.font()).width(
'a' * self._TOOLBAR_BUTTON_LETTERS)
for toolBar in (self.toolBarMain, self.toolBarSwitch):
for action in toolBar.actions():
if action.isSeparator():
continue
toolBar.widgetForAction(action).setFixedWidth(self._buttonWidth)
# Settings
self._loadState()
def aboutShowMenu(self):
self.menu.clear()
self.ag = QtGui.QActionGroup(self.menu)
self.ag.setExclusive(True)
for n, vp in enumerate(self.project.stackup.via_pairs):
l1, l2 = vp.layers
a1 = QtGui.QAction("%d-%d" % (l1.order, l2.order), self.menu)
a1.setCheckable(True)
a1.setChecked(vp is self.model.current_layer_pair)
def closure(vp):
def fn():
self.__changed_selected_viapair(vp)
return fn
a1.triggered.connect(closure(vp))
self.menu.addAction(a1)
self.ag.addAction(a1)
def setupToolButtonExtra(self):
self.menu = QtGui.QMenu()
self.ag = QtGui.QActionGroup(self.menu)
for n in valid_select:
a1 = QtGui.QAction(select_names[n], self.menu)
def closure(n):
def fn():
self.__set_version(n)
self.toolButton.click()
return fn
a1.triggered.connect(closure(n))
self.menu.addAction(a1)
self.ag.addAction(a1)
self.toolButton.setMenu(self.menu)
self.__update_icon()
def init_draft_statusbar(sb):
"""
this function initializes draft statusbar
"""
statuswidget = QtGui.QToolBar()
statuswidget.setObjectName("draft_status_widget")
# SCALE TOOL -------------------------------------------------------------
# get scales list according to system units
draft_scales = get_scales()
# get draft annotation scale
param = App.ParamGet("User parameter:BaseApp/Preferences/Mod/Draft")
draft_annotation_scale = param.GetFloat("DraftAnnotationScale", 1.0)
# initializes scale widget
statuswidget.draft_scales = draft_scales
scaleLabel = QtGui.QPushButton("Scale")
scaleLabel.setObjectName("ScaleLabel")
scaleLabel.setFlat(True)
menu = QtGui.QMenu(scaleLabel)
gUnits = QtGui.QActionGroup(menu)
for u in draft_scales:
a = QtGui.QAction(gUnits)
a.setText(u)
menu.addAction(a)
scaleLabel.setMenu(menu)
gUnits.triggered.connect(_set_scale)
scale_label = scale_to_label(draft_annotation_scale)
scaleLabel.setText(scale_label)
tooltip = "Set the scale used by draft annotation tools"
scaleLabel.setToolTip(QT_TRANSLATE_NOOP("draft", tooltip))
statuswidget.addWidget(scaleLabel)
statuswidget.scaleLabel = scaleLabel
# ADD TOOLS TO STATUS BAR ------------------------------------------------
sb.addPermanentWidget(statuswidget)
statuswidget.show()
def add_menubar_items(self, items, parent, level):
if not items:
return
for item in items:
itype = item.get('type', None)
if itype == 'separator':
parent.addSeparator()
continue
if itype == 'menu':
menu = parent.addMenu(item['text'])
if 'items' in item:
self.add_menubar_items(item['items'], menu, level + 1)
continue
if itype == 'radio':
radio = QtWidgets.QActionGroup(self.main, exclusive=True)
for item in item['items']:
action = self.add_action(item, parent)
action.setCheckable(True)
action.setChecked(item['checked'])
radio.addAction(action)
continue
self.add_action(item, parent)
def initMenu(self):
self.clear()
d = self.depthCameraStreamController.getDepthCamera()
if not d:
return
names = sorted(
d.getCameraProfileNames().items(),
key=lambda x:
(d.configFile.getCameraProfile(x[0]).getLocation() << 16) + x[0],
reverse=True)
if len(names) == 0:
return
cameraProfilesGroup = QtGui.QActionGroup(self, exclusive=True)
for id, n in names:
profile = d.configFile.getCameraProfile(id)
if profile:
if profile.getLocation() == Voxel.ConfigurationFile.IN_CAMERA:
n += " (HW)"
a = QtGui.QAction(n, self)
a.triggered.connect(
partial(self.setCameraProfile, name=n, id=id))
a.setCheckable(True)
self.addAction(a)
if d.getCurrentCameraProfileID() == id:
a.setChecked(True)
a.setActionGroup(cameraProfilesGroup)
self.addSeparator()
self.addAction(a)
def initUI(self):
grid = QtGui.QGridLayout()
#Create actions dictionary and group dictionary
self.atomActionGroup = QtGui.QActionGroup(self, exclusive=True)
self.atomActions = {}
#for atomname in self.editor.atomtypes.keys(): Gives unsorted list
for key in self.ptable.keys():
atomname = self.ptable[key]["Symbol"]
action = QtGui.QAction( '%s'%atomname,
self,
statusTip="Set atomtype to %s"%atomname,
triggered=self.atomtypePush, objectName=atomname,
checkable=True)
self.atomActionGroup.addAction(action)
self.atomActions[atomname] = action
if action.objectName() == "C":
action.setChecked(True)
button = QtGui.QToolButton()
button.setDefaultAction(action)
button.setFocusPolicy(QtCore.Qt.NoFocus)
button.setMaximumWidth(40)
if self.ptable[key]["Group"] != None:
grid.addWidget(button, self.ptable[key]["Period"], self.ptable[key]["Group"])
else:
if key <72:
grid.addWidget(button, 9, key-54)
else:
grid.addWidget(button, 10, key-86)
#Ensure spacing between main table and actinides/lathanides
grid.addWidget(QtGui.QLabel(''), 8,1)
self.setLayout(grid)
self.move(300, 150)
self.setWindowTitle('Periodic Table')
def __init__(self, *args, **kwargs):
super(ShapeWidget, self).__init__(*args, **kwargs)
buttons = self.buttons = []
layout = flowlayout.FlowLayout()
actionGroup = QtGui.QActionGroup(self)
actionGroup.setExclusive(True)
iconBase = resourcePath("mcedit2/assets/mcedit2/icons")
actions = {}
for shape in Shapes.allShapes:
filename = os.path.join(iconBase, shape.icon)
assert os.path.exists(filename), "%r does not exist" % filename
icon = QtGui.QIcon(filename)
if icon is None:
raise ValueError("Failed to read shape icon file %s" % filename)
def _handler(shape):
def handler():
self.currentShape = shape
BrushShapeSetting.setValue(shape.ID)
self.shapeChanged.emit()
return handler
action = QtGui.QAction(icon, shape.ID, self, triggered=_handler(shape))
button = QtGui.QToolButton()
action.setCheckable(True)
button.setDefaultAction(action)
button.setIconSize(QtCore.QSize(32, 32))
buttons.append(button)
layout.addWidget(button)
actionGroup.addAction(action)
actions[shape.ID] = action
self.setLayout(layout)
currentID = BrushShapeSetting.value(Shapes.allShapes[0].ID)
shapesByID = {shape.ID:shape for shape in Shapes.allShapes}
actions[currentID].setChecked(True)
self.currentShape = shapesByID.get(currentID, Shapes.allShapes[0])
def __init__(self):
"""
Create and add all tabs
"""
super().__init__()
toolbar = QtGui.QToolBar()
toolbar.setIconSize(QtCore.QSize(32, 32))
action_group = QtGui.QActionGroup(toolbar)
action_preferences_general = g.create_action(t.load_ui_icon('icon.preferences.general.png'), 'Show general preferences', action_group, toggle_connection=self.toggled_general, checkable=True)
toolbar.addAction(action_preferences_general)
toolbar.addAction(g.create_action(t.load_ui_icon('icon.preferences.network.png'), 'Show network preferences', action_group, toggle_connection=self.toggled_network, checkable=True))
toolbar.addAction(g.create_action(t.load_ui_icon('icon.preferences.graphics.png'), 'Show graphics preferences', action_group, toggle_connection=self.toggled_graphics, checkable=True))
toolbar.addAction(g.create_action(t.load_ui_icon('icon.preferences.music.png'), 'Show music preferences', action_group, toggle_connection=self.toggled_music, checkable=True))
self.stacked_layout = QtGui.QStackedLayout()
layout = QtGui.QVBoxLayout(self)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(toolbar)
layout.addLayout(self.stacked_layout)
# empty lists
self.checkboxes = []
self.lineedits = []
# add tabs
self.create_options_widget_general()
self.create_options_widget_graphics()
self.create_options_widget_music()
self.create_options_widget_network()
# show general preferences
action_preferences_general.setChecked(True)
def __init__(self, path=None):
self.imageshape = (1475, 1709)
if path is None: # If not loading an exeriment from file
# Build an empty experiment tree
config = [
{
'name': 'Name',
'type': 'str',
'value': 'New Experiment'
},
{
'name': 'Detector',
'type': 'list',
'values': detectors.ALL_DETECTORS
},
{
'name': 'Pixel Size X',
'type': 'float',
'value': 172.e-6,
'siPrefix': True,
'suffix': 'm',
'step': 1e-6
},
{
'name': 'Pixel Size Y',
'type': 'float',
'value': 172.e-6,
'siPrefix': True,
'suffix': 'm',
'step': 1e-6
},
{
'name': 'Center X',
'type': 'float',
'value': 0,
'suffix': ' px'
},
{
'name': 'Center Y',
'type': 'float',
'value': 0,
'suffix': ' px'
},
{
'name': 'Detector Distance',
'type': 'float',
'value': 1,
'siPrefix': True,
'suffix': 'm',
'step': 1e-3
},
{
'name': 'Detector Tilt',
'type': 'float',
'value': 0,
'siPrefix': False,
'suffix': u'°',
'step': 1e-1
},
{
'name': 'Detector Rotation',
'type': 'float',
'value': 0,
'siPrefix': False,
'suffix': u'°',
'step': 1e-1
},
{
'name': 'Energy',
'type': 'float',
'value': 10000,
'siPrefix': True,
'suffix': 'eV'
},
{
'name': 'Wavelength',
'type': 'float',
'value': 1,
'siPrefix': True,
'suffix': 'm'
},
# {'name': 'View Mask', 'type': 'action'},
{
'name': 'Incidence Angle (GIXS)',
'type': 'float',
'value': 0.1,
'suffix': u'°'
},
{
'name': 'Notes',
'type': 'text',
'value': ''
}
]
super(experiment, self).__init__(name='Experiment Properties',
type='group',
children=config)
# Wire up the energy and wavelength parameters to fire events on change (so they always match)
self.param('Energy').sigValueChanged.connect(self.EnergyChanged)
self.param('Wavelength').sigValueChanged.connect(
self.WavelengthChanged)
self.param('Detector').sigValueChanged.connect(
self.DetectorChanged)
# Add tilt style dialog
self.tiltStyleMenu = QtGui.QMenu()
grp = QtGui.QActionGroup(self)
self.fit2dstyle = QtGui.QAction('Use Fit2D style rot/tilt',
self.tiltStyleMenu)
self.wxdiffstyle = QtGui.QAction('Use WxDiff style rot/tilt',
self.tiltStyleMenu)
self.fit2dstyle.setCheckable(True)
self.wxdiffstyle.setCheckable(True)
self.fit2dstyle.setActionGroup(grp)
self.wxdiffstyle.setActionGroup(grp)
self.fit2dstyle.setChecked(True)
self.fit2dstyle.triggered.connect(self.resetUnits)
self.wxdiffstyle.triggered.connect(self.resetUnits)
self.tiltStyleMenu.addActions([self.fit2dstyle, self.wxdiffstyle])
# Start with a null mask
self._mask = None
self.EnergyChanged()
else:
# Load the experiment from file
with open(path, 'r') as f:
self.config = pickle.load(f)
self.headermap = {
'Beam Energy': 'Beam Energy',
'Sample Alpha Stage': 'Sample Alpha Stage',
'Detector Vertical': 'Detector Vertical',
'Detector Horizontal': 'Detector Horizontal',
'I1 AI': 'I1 AI',
'Timeline Axis': None
}
def __init__(self, parent=None):
# Initialise the UI
self.display = None
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Current file
self._filename = None
self._filetype = None
self._last_file_handler = None
# Importers / Exporters
self._file_handlers = []
# Update our window caption
self._caption = "Zoxel"
# Our global state + user plugins
if platform.system() == "Windows":
appdata = os.path.expandvars("%APPDATA%")
elif platform.system() == "Darwin":
appdata = os.path.expanduser("~/Library/Application Support")
else:
appdata = os.path.expanduser("~/.local/share")
self.user_plugins_path = os.path.join(appdata, "Zoxel", "plugins")
if not os.path.isdir(self.user_plugins_path):
os.makedirs(self.user_plugins_path, 16877)
QtCore.QCoreApplication.setOrganizationName("Zoxel")
QtCore.QCoreApplication.setApplicationName("Zoxel")
QtCore.QSettings.setDefaultFormat(QtCore.QSettings.IniFormat)
QtCore.QSettings.setPath(QtCore.QSettings.IniFormat, QtCore.QSettings.UserScope, appdata)
self.settings = QtCore.QSettings()
self.state = {}
# Our animation timer
self._timer = QtCore.QTimer(self)
self.connect(self._timer, QtCore.SIGNAL("timeout()"), self.on_animation_tick)
self._anim_speed = 200
# Load our state if possible
self.load_state()
# Create our GL Widget
try:
glw = GLWidget(self.ui.glparent)
self.ui.glparent.layout().addWidget(glw)
self.display = glw
except Exception as E:
QtGui.QMessageBox.warning(self, "Initialisation Failed", str(E))
exit(1)
# Load default model dimensions
width = self.get_setting("default_model_width")
height = self.get_setting("default_model_height")
depth = self.get_setting("default_model_depth")
if width:
self.resize_voxels(width, height, depth)
# Resize is detected as a change, discard changes
self.display.voxels.saved()
# Create our palette widget
voxels = PaletteWidget(self.ui.palette, RGBvalue=self.ui.paletteRGBvalue)
self.ui.palette.layout().addWidget(voxels)
self.color_palette = voxels
# More UI state
value = self.get_setting("display_axis_grids")
if value is not None:
self.ui.action_axis_grids.setChecked(value)
self.display.axis_grids = value
value = self.get_setting("background_color")
if value is not None:
self.display.background = QtGui.QColor.fromRgb(*value)
value = self.get_setting("voxel_edges")
if value is not None:
self.display.voxel_edges = value
self.ui.action_voxel_edges.setChecked(value)
else:
self.ui.action_voxel_edges.setChecked(self.display.voxel_edges)
value = self.get_setting("occlusion")
if value is None:
value = True
self.display.voxels.occlusion = value
self.ui.action_occlusion.setChecked(value)
# Connect some signals
if self.display:
self.display.voxels.notify = self.on_data_changed
self.display.mouse_click_event.connect(self.on_tool_mouse_click)
self.display.start_drag_event.connect(self.on_tool_drag_start)
self.display.end_drag_event.connect(self.on_tool_drag_end)
self.display.drag_event.connect(self.on_tool_drag)
if self.color_palette:
self.color_palette.changed.connect(self.on_color_changed)
# Initialise our tools
self._tool_group = QtGui.QActionGroup(self.ui.toolbar_drawing)
self._tools = []
self._tools_priorities = {}
# Setup window
self.update_caption()
self.refresh_actions()
self.display.ready = True
# Update Check
try:
latest_tag = urllib.urlopen("https://github.com/chrmoritz/zoxel/releases/latest").geturl()
if not latest_tag.endswith(ZOXEL_TAG):
responce = QtGui.QMessageBox.question(self, "Outdated Zoxel version",
"A new version of Zoxel is available! Do you want to update now?",
buttons=(QtGui.QMessageBox.Yes | QtGui.QMessageBox.No),
defaultButton=QtGui.QMessageBox.Yes)
if responce == QtGui.QMessageBox.Yes:
webbrowser.open(latest_tag, 2)
sys.exit(0)
except IOError:
pass
