def qmenu(self):
if self._qmenu is not None:
return self._qmenu
if self.parent is not None:
menu = QMenu(self.caption, self.parent)
else:
menu = QMenu(self.caption)
for entry in self.entries:
if isinstance(entry, MenuEntry):
action = menu.addAction(entry.caption, entry.action) # type: QAction
if entry.shortcut is not None:
action.setShortcut(entry.shortcut)
if entry.checkable:
action.setCheckable(True)
action.setChecked(entry.checked_initially)
entry.qaction = action
elif isinstance(entry, MenuSeparator):
menu.addSeparator()
else:
raise Exception('Unsupported type %s' % type(entry))
self._qmenu = menu
return menu
def create_menus(self):
self.toolbar = self.addToolBar("Edit")
self.toolbar.addAction(self.open_action)
self.toolbar.addAction(self.save_action)
for action in [a for a in self.plugin_actions if a.icon()]:
self.toolbar.addAction(action)
self.toolbar.addAction(self.zoom_in_action)
self.toolbar.addAction(self.zoom_out_action)
self.toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.fileMenu = QMenu("&File", self)
self.fileMenu.addAction(self.open_action)
self.fileMenu.addAction(self.save_action)
self.fileMenu.addAction(self.save_crops_action)
self.fileMenu.addAction(self.export_csv_action)
self.fileMenu.addAction(self.close_action)
self.fileMenu.addSeparator()
self.fileMenu.addAction(self.exit_action)
self.editMenu = QMenu("&Edit", self)
self.editMenu.addAction(self.select_all_action)
self.editMenu.addAction(self.select_none_action)
self.editMenu.addAction(self.delete_action)
self.editMenu.addSeparator()
self.editMenu.addAction(self.next_box_action)
self.editMenu.addAction(self.previous_box_action)
self.editMenu.addSeparator()
self.editMenu.addAction(self.rotate_clockwise_action)
self.editMenu.addAction(self.rotate_counter_clockwise_action)
self.editMenu.addSeparator()
for action in self.plugin_actions:
self.editMenu.addAction(action)
self.viewMenu = QMenu("&View", self)
self.viewMenu.addAction(self.boxes_view_action)
self.viewMenu.addAction(self.metadata_view_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.full_screen_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.zoom_in_action)
self.viewMenu.addAction(self.zoom_out_action)
self.viewMenu.addAction(self.toogle_zoom_action)
self.viewMenu.addAction(self.zoom_home_action)
self.viewMenu.addAction(self.toggle_plugin_image_action)
self.viewMenu.addSeparator()
self.viewMenu.addAction(self.show_specimen_grid_action)
self.viewMenu.addAction(self.show_specimen_expanded_action)
self.helpMenu = QMenu("&Help", self)
self.helpMenu.addAction(self.help_action)
self.helpMenu.addAction(self.about_action)
self.menuBar().addMenu(self.fileMenu)
self.menuBar().addMenu(self.editMenu)
self.menuBar().addMenu(self.viewMenu)
self.menuBar().addMenu(self.helpMenu)
def createMenus(self):
self.popupMenu = QMenu(self)
# Markers
subMenuItem = QMenu(self.tr('Marker'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Set marker'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPixmap)
menuItem = QAction(self.tr('Remove marker'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.removePixmaps)
menuItem = QAction(self.tr('Select objects'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.selectObjects)
# Draw
subMenuItem = QMenu(self.tr('Draw'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Rectangle'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawRect)
menuItem = QAction(self.tr('Polyline'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPolyline)
menuItem = QAction(self.tr('Polygon'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawPolygon)
menuItem = QAction(self.tr('Circle'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawCircle)
menuItem = QAction(self.tr('Text'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.drawText)
# Routing
subMenuItem = QMenu(self.tr('Route'), self)
self.popupMenu.addMenu(subMenuItem)
menuItem = QAction(self.tr('Calculate route'), self)
subMenuItem.addAction(menuItem)
menuItem.triggered[bool].connect(self.calculateRoute)
def createVersionEveryWhereMenuForView(self, view):
versionEverywhereMenu = QMenu(self.actionTitle)
self._versionActions = []
# We look to the activeView for a selection of Clips
clips = self.clipSelectionFromView(view)
# And bail if nothing is found
if len(clips)==0:
return versionEverywhereMenu
# Now, if we have just one Clip selected, we'll form a special menu, which lists all versions
if len(clips)==1:
# Get a reversed list of Versions, so that bigger ones appear at top
versions = list(reversed(clips[0].binItem().items()))
for version in versions:
self._versionActions+=[self.makeVersionActionForSingleClip(version)]
elif len(clips)>1:
# We will add Max/Min/Prev/Next options, which can be called on a TrackItem, without the need for a Version object
self._versionActions+=[self.makeAction(self.eMaxVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.eMinVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.eNextVersion,self.setTrackItemVersionForClipSelection, icon=None)]
self._versionActions+=[self.makeAction(self.ePreviousVersion,self.setTrackItemVersionForClipSelection, icon=None)]
for act in self._versionActions:
versionEverywhereMenu.addAction(act)
return versionEverywhereMenu
def _create_theme_menu(self):
theme_menu = QMenu(self)
theme_menu.setTitle('Buttons Theme')
theme_menu.setTearOffEnabled(True)
theme_menu.setWindowTitle(TAG)
theme_actions = QActionGroup(self)
theme_actions.setExclusive(True)
# create ordered theme list
custom_order_theme = sorted(THEMES.iterkeys())
custom_order_theme.remove('Maya Theme')
custom_order_theme.insert(0, 'Maya Theme')
default_item = True
for theme in custom_order_theme:
current_theme_action = QAction(theme, theme_actions)
current_theme_action.setCheckable(True)
current_theme_action.setChecked(
MTTSettings.value('theme', 'Maya Theme') == theme)
current_theme_action.triggered.connect(self.on_change_theme)
theme_menu.addAction(current_theme_action)
if default_item:
theme_menu.addSeparator()
default_item = False
return theme_menu
def _create_instance_menu(self):
self.instance_menu = QMenu(self)
self.instance_menu.setTitle('Prompt Instance Delay')
self.instance_menu.aboutToShow.connect(
self.on_show_prompt_instance_delay_menu)
return self.instance_menu
def click(self, res, event):
"""Open resource"""
button = event.button()
if button == Qt.LeftButton:
subprocess.Popen(['xdg-open', res.file_path])
elif button == Qt.RightButton:
menu = QMenu(self.parent)
menu.addAction(
self.app.translate('ResourceEdit', 'Put to Content'),
Slot()(partial(
self.to_content,
res=res,
)),
)
if not self.parent.note_edit.in_content(res):
menu.addAction(
self.app.translate('ResourceEdit', 'Remove Resource'),
Slot()(partial(
self.remove,
res=res,
)))
menu.addAction(self.app.translate('ResourceEdit', 'Save As'),
Slot()(partial(
self.save,
res=res,
)))
menu.exec_(event.globalPos())
def popup_menu(self, position):
selected_row = self.view.rowAt(position.y())
if selected_row >= 0 and self._used_categories and len(
self._used_categories) > 1:
category_menu = QMenu(_("Categories"))
selected_doc = self.model.object_at(selected_row)
category_actions = []
for category in self._used_categories:
a = QAction(category.full_name, category_menu)
a.setData(category)
a.setEnabled(selected_doc.document_category_id !=
category.document_category_id)
category_menu.addAction(a)
category_actions.append(a)
action = category_menu.exec_(QCursor.pos())
if action:
new_category = action.data()
if selected_doc.document_category_id != new_category.document_category_id:
selected_doc.document_category_id = new_category.document_category_id
self.model.signal_object_change(selected_doc)
def note_context_menu(self, pos):
menu = QMenu(self.ui.notesList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Edit'),
self.edit_note)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_note)
menu.exec_(self.ui.notesList.mapToGlobal(pos))
def loadContextMenu(self, *args):
menu = QMenu(self.w_tree)
path = self.w_tree.currentItem().text(0)
if os.path.isdir(path):
dirPath = path
else:
dirPath = os.path.dirname(path)
if os.path.exists(dirPath):
menu.addAction(unicode("Open Folder", errors='replace'),
self.openFolder)
menu.addAction(unicode("Copy Path", errors='replace'), self.copyPath)
separator = QAction(self.w_tree)
separator.setSeparator(True)
menu.addAction(separator)
menu.addAction(unicode("Replace Path", errors='replace'),
self.replacePath)
separator = QAction(self.w_tree)
separator.setSeparator(True)
menu.addAction(separator)
if self.unusedExists():
menu.addAction(unicode("Remove Unused Files", errors='replace'),
self.removeUnused)
pos = QCursor.pos()
point = QtCore.QPoint(pos.x() + 10, pos.y())
menu.exec_(point)
def showContextMenu(self, pos):
"""
Shows a context menu to add a node in the graph widget
"""
gpos = self.graphicsView.mapToGlobal(pos)
menu = QMenu()
actionAddNode = menu.addAction("Add Node")
QAction = menu.exec_(gpos)
if (actionAddNode == QAction):
(text,
ok) = QInputDialog.getText(self.graphicsView, "Insert Node Name",
"Please insert a name for the node")
if ok:
if text not in self.nodesToQNodes:
#User clicked on ok. Otherwise do nothing
self.gv.add_node(text)
node = self.gv.get_node(text)
qnode = self.createQtNode(node, 0, 0,
QColor(204, 255, 255))
self.graphicsView.scene().addItem(qnode)
qnode.setPos(self.graphicsView.mapToScene(gpos))
qnode.setPos(qnode.x(), qnode.y() - 200)
self.nodesToQNodes[node] = qnode
else:
msg = QMessageBox()
msg.setText("The node already exists.")
msg.exec_()
self.searchNode(text)
def __menu(self, pos):
u"""Slot d'apparition du menu contextuel"""
menu = QMenu()
menu.addAction("Supprimer", self, SLOT("supprimer()"),
QKeySequence.Delete)
menu.addAction("Nouveau", self, SLOT("nouveau()"), QKeySequence.New)
menu.exec_(self._ui.tv.mapToGlobal(pos))
def __init__(self, parent=None):
"""Initialize Widget."""
super().__init__(parent)
self.setLayout(QVBoxLayout())
self.imglabel = QLabel()
self.imglabel.setBackgroundRole(QPalette.Base)
self.imglabel.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.imglabel.setScaledContents(True) # Resize pixmap along with label
self.imglabel.setAlignment(Qt.AlignCenter)
self.imglabel.setText("(No image yet)")
self.namelabel = QLabel()
self.scrollarea = QScrollArea()
self.scrollarea.setWidget(self.imglabel)
self.scrollarea.setWidgetResizable(False)
self.scrollarea.setAlignment(Qt.AlignCenter)
self.layout().addWidget(self.scrollarea)
self.layout().addWidget(self.namelabel)
self.scale_factor = 1.0
self._initial_size = QSize(0, 0)
self._img_path = ""
self.setContextMenuPolicy(Qt.CustomContextMenu)
# pylint: disable=no-member
self.customContextMenuRequested.connect(self.show_context_menu)
self.menu = QMenu()
self.add_actions_to_menu(self.menu)
def on_show_debug_menu(self):
self.debug_menu.clear()
if self.is_master_cmd or self.power_user:
power_user_mode = QAction('Power User Mode', self)
power_user_mode.setCheckable(True)
power_user_mode.setChecked(MTTSettings.value('powerUser'))
power_user_mode.triggered.connect(self.__on_toggle_power_user)
self.debug_menu.addAction(power_user_mode)
self.is_master_cmd = False
self.debug_menu.addSeparator()
open_pref_folder_action = QAction('Open Preferences Folder', self)
open_pref_folder_action.setStatusTip('Open MTT preference folder')
open_pref_folder_action.triggered.connect(
self.on_open_preference_folder)
self.debug_menu.addAction(open_pref_folder_action)
self.debug_menu.addSeparator()
database_dump_csv = QAction('Dump Database as CSV', self)
database_dump_csv.triggered.connect(self.view.model.database_dump_csv)
self.debug_menu.addAction(database_dump_csv)
database_dump_sql = QAction('Dump Database as SQL', self)
database_dump_sql.triggered.connect(self.view.model.database_dump_sql)
self.debug_menu.addAction(database_dump_sql)
self.debug_menu.addSeparator()
support_info = QMenu(self)
support_info.setTitle('Supported Node Type')
support_info.aboutToShow.connect(self.on_show_supported_type)
self.debug_menu.addMenu(support_info)
def __init__(self, app, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = app
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
self.activated.connect(self._activated)
def tag_context_menu(self, pos):
index = self.ui.tagsList.currentIndex()
item = self.tagsModel.itemFromIndex(index)
if hasattr(item, 'tag'):
menu = QMenu(self.ui.tagsList)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_tag)
menu.exec_(self.ui.tagsList.mapToGlobal(pos))
def notebook_context_menu(self, pos):
index = self.ui.notebooksList.currentIndex()
item = self.notebooksModel.itemFromIndex(index)
if hasattr(item, 'notebook'):
menu = QMenu(self.ui.notebooksList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Rename'),
self.rename_notebook)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_notebook)
menu.exec_(self.ui.notebooksList.mapToGlobal(pos))
if hasattr(item, 'stack'):
menu = QMenu(self.ui.notebooksList)
menu.addAction(QIcon.fromTheme('gtk-edit'), self.tr('Rename'),
self.rename_stack)
menu.addAction(QIcon.fromTheme('gtk-delete'), self.tr('Remove'),
self.remove_stack)
menu.exec_(self.ui.notebooksList.mapToGlobal(pos))
def __init__(self, parent):
super(TheView, self).__init__(parent)
self.tar_menu = QMenu(_("Time tracking"), parent)
# self.change_report_action = self.tar_menu.addAction(_("Change report"))
self.delete_report_action = self.tar_menu.addAction(_("Delete report"))
self.task_menu = QMenu(_("Task"), parent)
self.add_task_report_action = self.task_menu.addAction(_("Add time"))
self.tar_presence_menu = QMenu(_("Presence"), parent)
self.add_presence_report_action = self.tar_presence_menu.addAction(
_("Add presence report"))
self.all_menu = QMenu(_("All"), parent)
self.all_menu.addAction(self.add_task_report_action)
self.all_menu.addAction(self.add_presence_report_action)
def __init__(self, icon, parent=None):
QSystemTrayIcon.__init__(self, icon, parent)
self.setToolTip("usb-resetter 1.0 (Left\Right-Click)")
self.parent = parent
self.activated.connect(self.toggleP)
menu = QMenu(parent)
self.fmenu = QMenu("Fast reset", parent)
self.fmenu.setToolTip("List of filtered devices to fast reset")
aboutAction = QAction("About", self)
aboutAction.triggered.connect(parent.show_about)
quitAction = QAction("Exit", self)
quitAction.triggered.connect(parent.exitEvent)
menu.addMenu(self.fmenu)
menu.addSeparator()
menu.addAction(aboutAction)
menu.addAction(quitAction)
self.setContextMenu(menu)
def __init__(self, *args, **kwargs):
QSystemTrayIcon.__init__(self, *args, **kwargs)
self.app = QApplication.instance()
self.menu = QMenu()
self.setContextMenu(self.menu)
self.menu.aboutToShow.connect(self.update)
self.opened_notes = {}
self.activated.connect(self._activated)
self.settings = QSettings('everpad', 'everpad-pad')
def _setupContextMenu(self):
from visualscrape.lib.data import ActionStore
context_menu = QMenu(self)
export_action = NamedAction(self.tr("Export ..."), self, name="export")
export_action.triggered.connect(self._requestTabExport)
context_menu.addAction(export_action)
self.setTabBar(ContextMenuTabBar(context_menu))
action_store = ActionStore.get_instance()
action_store.register_action(export_action)
def mousePressEvent(self, mouse_event):
if mouse_event.button() == Qt.RightButton:
if self._spec_index is None:
print("spec_index is None")
print(self)
print(self._running_providers)
return
pos = mouse_event.pos()
items = [
item for item in self.items(pos)
if isinstance(item, NodeItem) and item._label.text()
]
if len(items) != 1:
print("wrong number of things",
[x._label.text() for x in items])
return
name = items[0]._label.text().rstrip('(default)').strip()
if name not in self._spec_index.provider_names:
print(name, "Not in list of providers")
return
provider = self._spec_index.providers[name]
def start_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/start_capability'.format(
'capability_server')
rospy.wait_for_service(service_name)
start_capability = rospy.ServiceProxy(service_name,
StartCapability)
start_capability(provider.implements, name)
def stop_trigger():
# TODO: replace 'capability_server' with user provided server name
service_name = '/{0}/stop_capability'.format(
'capability_server')
rospy.wait_for_service(service_name)
stop_capability = rospy.ServiceProxy(service_name,
StopCapability)
stop_capability(provider.implements)
if name not in self._running_providers:
trigger = start_trigger
msg = "start => "
else:
trigger = stop_trigger
msg = "stop => "
menu = QMenu()
action = menu.addAction(msg + name)
action.triggered.connect(trigger)
pos = mouse_event.globalPos()
pos = QPoint(pos.x(), pos.y())
menu.exec_(pos)
else:
InteractiveGraphicsView.mousePressEvent(self, mouse_event)
def _setupContextMenu(self):
from visualscrape.lib.data import ActionStore
self._context_menu = QMenu(self)
# get the export action from the action store
action_store = ActionStore.get_instance()
for action in action_store:
if action.get_name() == "export":
export_action = action
break
self._context_menu.addAction(export_action)
def testMenu(self):
self._actionDestroyed = False
w = QWidget()
menu = QMenu(w)
act = menu.addAction("MENU")
_ref = weakref.ref(act, self.actionDestroyed)
act = None
self.assertFalse(self._actionDestroyed)
menu.clear()
self.assertTrue(self._actionDestroyed)
def __init__(self, parent=None):
super(Status, self).__init__(parent)
self.setupUi(self)
self.base = parent
self.wait_anim = QMovie(":/stuff/wait.gif")
self.anim_lbl.setMovie(self.wait_anim)
self.anim_lbl.hide()
self.show_menu = QMenu(self)
for i in [
self.act_page, self.act_date, self.act_text, self.act_comment
]:
self.show_menu.addAction(i)
# noinspection PyUnresolvedReferences
i.triggered.connect(self.on_show_items)
i.setChecked(True)
sort_menu = QMenu(self)
ico_sort = QIcon(":/stuff/sort.png")
group = QActionGroup(self)
action = QAction(_("Date"), sort_menu)
action.setCheckable(True)
action.setChecked(not self.base.high_by_page)
action.triggered.connect(self.base.set_highlight_sort)
action.setData(False)
group.addAction(action)
sort_menu.addAction(action)
action = QAction(_("Page"), sort_menu)
action.setCheckable(True)
action.setChecked(self.base.high_by_page)
action.triggered.connect(self.base.set_highlight_sort)
action.setData(True)
group.addAction(action)
sort_menu.addAction(action)
sort_menu.setIcon(ico_sort)
sort_menu.setTitle(_("Sort by"))
self.show_menu.addMenu(sort_menu)
self.show_items_btn.setMenu(self.show_menu)
def contextMenuEvent(self, event):
"""
Handles the ``contextMenuEvent`` event for :class:`CmdPromptInput`.
:param `event`: a `QContextMenuEvent` event to be processed.
"""
menu = QMenu(self)
menu.addSeparator()
# TODO: Extra stuff
menu.addAction(QAction("TODO: Add Extra stuff", self))
menu.exec_(event.globalPos())
def __init__(self, parent=None):
self.color = QColor(0, 0, 0)
super().__init__(parent)
self.setFrameStyle(QFrame.Panel | QFrame.Raised)
dial = QColorDial(self)
dial.sliderMoved.connect(self.set_color)
action = QWidgetAction(self)
action.setDefaultWidget(dial)
self.menu = QMenu()
self.menu.addAction(action)
def loadContextMenu(self):
def cmd_loadSelected():
selObjects = pymel.core.ls(sl=1)
if not selObjects: return
cuItem = self.treeWidget.currentItem()
cuItem.setText(1, selObjects[0].name())
menu = QMenu(self.treeWidget)
menu.addAction("Load Object", cmd_loadSelected)
pos = QCursor.pos()
point = QtCore.QPoint(pos.x() + 10, pos.y())
menu.exec_(point)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
# activate the window and use the full screen
self.setWindowState(Qt.WindowFullScreen | Qt.WindowActive)
# empty the mouse cursor
self.setCursor(Qt.BlankCursor)
# add a menu to close the window
appmenu = QMenu('&Application', self)
quit = QAction('&Quit', self)
appmenu.addAction(quit)
self.menuBar().addMenu(appmenu)
quit.triggered.connect(QApplication.instance().quit)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
# self.setObjectName("MainWindow")
self.resize(731, 475)
centralwidget = QWidget(self)
# centralwidget.setObjectName("centralwidget")
gridLayout = QGridLayout(centralwidget)
# gridLayout.setObjectName("gridLayout")
# textEdit needs to be a class variable.
self.textEdit = QTextEdit(centralwidget)
# self.textEdit.setObjectName("textEdit")
gridLayout.addWidget(self.textEdit, 0, 0, 1, 1)
self.setCentralWidget(centralwidget)
menubar = QMenuBar(self)
menubar.setGeometry(QRect(0, 0, 731, 29))
# menubar.setObjectName("menubar")
menu_File = QMenu(menubar)
# menu_File.setObjectName("menu_File")
self.setMenuBar(menubar)
statusbar = QStatusBar(self)
# statusbar.setObjectName("statusbar")
self.setStatusBar(statusbar)
actionShow_GPL = QAction(self)
# actionShow_GPL.setObjectName("actionShow_GPL")
actionShow_GPL.triggered.connect(self.showGPL)
action_About = QAction(self)
# action_About.setObjectName("action_About")
action_About.triggered.connect(self.about)
iconToolBar = self.addToolBar("iconBar.png")
#------------------------------------------------------
# Add icons to appear in tool bar - step 1
actionShow_GPL.setIcon(QIcon(":/showgpl.png"))
action_About.setIcon(QIcon(":/about.png"))
action_Close = QAction(self)
action_Close.setCheckable(False)
action_Close.setObjectName("action_Close")
action_Close.setIcon(QIcon(":/quit.png"))
#------------------------------------------------------
# Show a tip on the Status Bar - step 2
actionShow_GPL.setStatusTip("Show GPL Licence")
action_About.setStatusTip("Pop up the About dialog.")
action_Close.setStatusTip("Close the program.")
#------------------------------------------------------
menu_File.addAction(actionShow_GPL)
menu_File.addAction(action_About)
menu_File.addAction(action_Close)
menubar.addAction(menu_File.menuAction())
iconToolBar.addAction(actionShow_GPL)
iconToolBar.addAction(action_About)
iconToolBar.addAction(action_Close)
action_Close.triggered.connect(self.close)
