def build_menu(tree, accelgroup=None, root=True):
"""Build a gtk menu, including submenu's
tree is an array of items, each item being a dictionary with:
-'name': the visible item name
-'icon': an (optional) icon
-'submenu': an array of items representing a submenu
"""
if root:
menu = gtk.MenuBar()
else:
menu = gtk.Menu()
for element in tree:
item = gtk.MenuItem(element['name'])
if element.has_key('icon'):
pass
if element.has_key('submenu'):
item.set_submenu(build_menu(element['submenu'],
root=False, accelgroup=accelgroup))
if element.has_key('action'):
item.connect('activate', element['action'])
if element.has_key('accel') and accelgroup is not None:
(key, mod) = gtk.accelerator_parse(element['accel'])
item.add_accelerator('activate', accelgroup, key, mod,
gtk.ACCEL_VISIBLE)
menu.add(item)
return menu
def _create_menus(self):
m_bar = gtk.MenuBar()
self._mainvbox.pack_start(m_bar, False, False, 0)
m_bar.show()
m_file = gtk.Menu()
m_file_open = gtk.MenuItem("Open")
m_file_quit = gtk.MenuItem("Quit")
m_file.append(m_file_open)
m_file.append(m_file_quit)
m_file_open.connect_object("activate", self._menu_open, "file.open")
m_file_quit.connect_object("activate", self.destroy, "file.quit")
m_file_blah = gtk.MenuItem("File")
m_file_blah.show()
m_file_blah.set_submenu(m_file)
m_bar.append(m_file_blah)
m_filter = gtk.Menu()
m_filter_outlier = gtk.MenuItem("Outlier")
m_filter_outlier.connect_object("activate", self._outlier_filter, "outlier")
m_filter_outlier.show()
m_filter.append(m_filter_outlier)
m_filter.show()
m_filter_blah = gtk.MenuItem("Filter")
m_filter_blah.show()
m_filter_blah.set_submenu(m_filter)
m_bar.append(m_filter_blah)
m_file_open.show()
m_file_quit.show()
m_bar.show()
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Dialog Boxes")
self.set_default_size(250, 200)
self.set_position(gtk.WIN_POS_CENTER)
mb = gtk.MenuBar()
menu1 = gtk.Menu()
file = gtk.MenuItem("_File")
file.set_submenu(menu1)
msg = gtk.MenuItem("MessageDialog")
menu1.append(msg)
abt = gtk.MenuItem("AboutDialog")
menu1.append(abt)
colo = gtk.MenuItem("colorDialog")
menu1.append(colo)
font = gtk.MenuItem("FontSelectionDialog")
menu1.append(font)
fl = gtk.MenuItem("FileChooserDialog")
menu1.append(fl)
mb.append(file)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
self.add(vbox)
self.text = gtk.Label("TutorialsPoint")
vbox.pack_start(self.text, True, True, 0)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self, definition):
GafferUI.Widget.__init__(self, gtk.MenuBar())
self.__menuBar = self.gtkWidget()
self.definition = definition
def get_vnc_menu(self):
menubar = gtk.MenuBar()
sendkeys = gtk.MenuItem(constants.tools)
menubar.append(sendkeys)
scrs = gtk.MenuItem(constants.screenshot)
caf1 = gtk.MenuItem("Ctrl+Alt+F_1")
caf7 = gtk.MenuItem("Ctrl+Alt+F_7")
cad = gtk.MenuItem("Ctrl+Alt+_Del")
cab = gtk.MenuItem("Ctrl+Alt+_Backspace")
disc = gtk.MenuItem(constants.disconnect)
sep = gtk.SeparatorMenuItem()
submenu = gtk.Menu()
submenu.append(caf1)
submenu.append(caf7)
submenu.append(cad)
submenu.append(cab)
submenu.append(sep)
submenu.append(scrs)
submenu.append(disc)
#sendkeys.set_submenu(submenu)
caf1.connect("activate", self.send_caf1)
caf7.connect("activate", self.send_caf7)
cad.connect("activate", self.send_cad)
cab.connect("activate", self.send_cab)
scrs.connect("activate", self.screenshot_event)
disc.connect("activate", self.disconnect_event)
return submenu
def CreateMenu(self):
file = gtk.MenuItem('File')
file.show()
filemenu = gtk.Menu()
item = gtk.MenuItem('Open')
filemenu.append(item)
item.show()
item = gtk.MenuItem('Exit')
filemenu.append(item)
item.show()
file.set_submenu(filemenu)
about = gtk.MenuItem('About')
about.show()
aboutmenu = gtk.Menu()
item = gtk.MenuItem('CEF Python')
aboutmenu.append(item)
item.show()
about.set_submenu(aboutmenu)
menubar = gtk.MenuBar()
menubar.append(file)
menubar.append(about)
menubar.show()
return menubar
def _create_menu_bar(self):
open_item = gtk.MenuItem("Open")
open_item.connect("activate", self.openfile)
quit_item = gtk.MenuItem("Quit")
quit_item.connect("activate", gtk.main_quit)
file_menu = gtk.Menu()
file_menu.append(open_item)
file_menu.append(quit_item)
file_item = gtk.MenuItem("_File")
file_item.set_submenu(file_menu)
compile_item = gtk.MenuItem("Compile")
compile_item.connect("activate", self.compile_cb)
run_item = gtk.MenuItem("Run")
run_item.connect("activate", self.run_cb)
action_menu = gtk.Menu()
action_menu.append(compile_item)
action_menu.append(run_item)
action_item = gtk.MenuItem("_Action")
action_item.set_submenu(action_menu)
about_item = gtk.MenuItem("About")
about_item.connect("activate", self.about)
help_menu = gtk.Menu()
help_menu.append(about_item)
help_item = gtk.MenuItem("_Help")
help_item.set_submenu(help_menu)
menu_bar = gtk.MenuBar()
menu_bar.append(file_item)
menu_bar.append(action_item)
menu_bar.append(help_item)
return menu_bar
def build_menu_bar(self):
self.menubar = gtk.MenuBar()
f = gtk.MenuItem('File')
self.menubar.append(f)
fmenu = gtk.Menu()
f.set_submenu(fmenu)
i = gtk.ImageMenuItem(self.STOCK_BOOKMARK)
i.connect('activate', self.do_show_bookmarks)
fmenu.append(i)
i = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
i.connect('activate', self.do_configure)
fmenu.append(i)
i = gtk.MenuItem('Update bookmark data')
i.connect('activate', self.do_update_bookmarks)
fmenu.append(i)
i = gtk.ImageMenuItem(gtk.STOCK_QUIT)
i.connect('activate', self.cleanup)
fmenu.append(i)
f = gtk.MenuItem("Help")
fmenu = gtk.Menu()
self.menubar.append(f)
f.set_submenu(fmenu)
i = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
i.connect('activate', self.do_show_about_dialog)
fmenu.append(i)
self.menubar.show_all()
def createMenu(self):
#create menu bar
menu_bar = gtk.MenuBar()
menu_bar.show()
vbox = self.builder.get_object("menuBox")
vbox.pack_start(menu_bar, False, False, 0)
###create view menu
collumnsItem = gtk.MenuItem('collumns')
collumnsItem.show()
viewMenu = gtk.Menu()
viewMenu.append(collumnsItem)
###create columns menu
collumnsMenu = gtk.Menu()
for col in self.cols:
menu_item = gtk.CheckMenuItem(col[0])
menu_item.connect('toggled', self.on_col_toggled)
menu_item.set_active(col[1])
menu_item.show()
collumnsMenu.append(menu_item)
collumnsItem.set_submenu(collumnsMenu)
self.visibleCollumns = collumnsMenu
root_menu = gtk.MenuItem('View')
root_menu.show()
root_menu.set_submenu(viewMenu)
menu_bar.append(root_menu)
def create_main_menu(self):
self.menu_bar = gtk.MenuBar()
self.file_menu = add_submenu(self.menu_bar, "_File")
add_option(self.file_menu, "_Exit", self.exit)
self.plugin_menu = add_submenu(self.menu_bar, "_Plugins")
self.submenus = dict()
self.category_to_path = dict()
for (path, uri) in self.lv2db.get_categories():
if path == []:
continue
parent_menu = self.plugin_menu
parent_path = "/".join(path[:-1])
if parent_path in self.submenus:
parent_menu = self.submenus[parent_path]
self.submenus["/".join(path)] = add_submenu(parent_menu, path[-1])
self.category_to_path[uri] = path
for uri in self.lv2db.getPluginList():
plugin = self.lv2db.getPluginInfo(uri)
parent_menu = self.plugin_menu
best_path = self.get_best_category(plugin)
if best_path in self.submenus:
parent_menu = self.submenus[best_path]
add_option(parent_menu, plugin.name, self.add_module_cb,
(plugin, None, None))
def __init__(self, tree, empty_pix, empty_mask):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title("IceMe: " + _("Menu Preview"))
# self.set_decorated(gtk.FALSE)
self.set_default_size(400, -1)
self.connect("delete_event", self.close)
self.tree = tree
self.empty_pix = empty_pix
self.empty_mask = empty_mask
menu = gtk.MenuBar()
#DJM menu.set_shadow_type(SHADOW_OUT)
nodes = tree.base_nodes()
self.createMenu(menu, nodes[0])
toolbar_menu = nodes[2]
for n in toolbar_menu.children:
self.createMenu(menu, n, 1)
menu.show()
# added 4/25/2003 - Erica Andrews, let's create a little space around the menu so it doesn't look so
# cluttered - some icons were too close to the Preview window's edge
hb = gtk.HBox(0, 0)
hb.set_border_width(2)
hb.pack_start(menu, 1, 1, 0)
hb.show_all()
#self.add(menu) # disabled, 4/25/2003- Erica Andrews
self.add(hb) # added, 4/25/2003- Erica Andrews
def setup_window(self):
'''Set up all the bits of our window.'''
gtk.Window.__init__(self)
self.set_title("Shot Detector")
self.resize(230, 150)
self.connect('destroy', lambda w: gtk.main_quit())
self.connect('delete_event', lambda w, e: gtk.main_quit())
# Now start adding gui bits
vbox1 = gtk.VBox(False, 0)
self.add(vbox1)
vbox1.show()
# menubar bits
menu_bar = gtk.MenuBar()
vbox1.pack_start(menu_bar, False, False, 0)
menu_bar.show()
# File menu
file_item = gtk.MenuItem('File')
file_item.show()
file_menu = gtk.Menu()
quit_item = gtk.MenuItem('Quit')
quit_item.connect_object('activate', lambda w: gtk.main_quit(), None)
quit_item.show()
file_menu.append(quit_item)
file_item.set_submenu(file_menu)
menu_bar.append(file_item)
# Drawing area
self.draw_area = gtktargets.SmallBore50Ft()
vbox1.pack_start(self.draw_area, True, True, 0)
def constructMenu(self):
menuBar=gtk.MenuBar()
fileMenu=gtk.Menu()
menu_item=gtk.MenuItem('Load')
menu_item.connect('activate',self.on_loadButton_clicked)
menu_item.show()
fileMenu.append(menu_item)
menu_item=gtk.MenuItem('Load Template')
# menu_item.connect('select',self.on_loadTButton_clicked)
menu_item.show()
subMenu=gtk.Menu()
menu_item.set_submenu(subMenu)
subMenu.show()
subMenu.connect('show',self.on_loadTButton_clicked)
fileMenu.append(menu_item)
menu_item=gtk.MenuItem('Save Template')
menu_item.connect('activate',self.on_saveTButton_clicked)
menu_item.show()
fileMenu.append(menu_item)
root_menu=gtk.MenuItem('File')
root_menu.show()
root_menu.set_submenu(fileMenu)
menuBar.append(root_menu)
menuBar.show()
self.builder.get_object('vbox1').pack_start(menuBar,False,False)
def __init__(self):
gtk.Window.__init__(self)
self.menu_bar = gtk.MenuBar()
self.build_menu()
self.build_dialogs()
table = gtk.Table(4, 2, True)
table.attach(self.menu_bar, 0, 2, 0, 1)
scrolled_window = gtk.ScrolledWindow(hadjustment=None,
vadjustment=None)
textview = gtk.TextView(buffer=None)
textview.set_editable(False)
self.textbuffer = textview.get_buffer()
scrolled_window.add_with_viewport(textview)
# Left-attach, right, top, bottom
table.attach(scrolled_window, 0, 2, 1, 2)
self.button = gtk.Button(label="Click Here")
self.button.connect("clicked", self.on_button_clicked)
table.attach(self.button, 0, 1, 2, 3)
self.label = gtk.Label()
self.label.set_text(
"This is a left-justified label.\nWith multiple lines.")
table.attach(self.label, 0, 2, 3, 4)
self.add(table)
def build_menubar(self):
# Menu Items
self.login_item = gtk.MenuItem('Login')
self.login_item.show()
self.signup_item = gtk.MenuItem('Sign up')
self.signup_item.show()
self.quit_item = gtk.MenuItem('Quit')
self.quit_item.show()
# File Menu
self.file_menu = gtk.Menu()
self.file_menu.append(self.login_item)
self.file_menu.append(self.signup_item)
self.file_menu.append(self.quit_item)
self.file_menu.show()
# File Menu's Item in the Menubar
self.file_menu_item = gtk.MenuItem('File')
self.file_menu_item.set_submenu(self.file_menu)
self.file_menu_item.show()
# Finally, the Menubar
self.menubar = gtk.MenuBar()
self.menubar.append(self.file_menu_item)
self.menubar.show()
return
def __init__(self):
super(PyApp, self).__init__()
self.set_title("Simple menu")
self.set_size_request(250, 200)
self.modify_bg(gtk.STATE_NORMAL, gtk.gdk.Color(6400, 6400, 6400))
self.set_position(gtk.WIN_POS_CENTER)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("File")
filem.set_submenu(filemenu)
exit = gtk.MenuItem("Exit")
exit.connect("activate", gtk.main_quit)
filemenu.append(exit)
mb.append(filem)
vbox = gtk.VBox(False, 2)
vbox.pack_start(mb, False, False, 0)
self.add(vbox)
self.connect("destroy", gtk.main_quit)
self.show_all()
def __init__(self): #TODO add code to bypass automaticly loading profile if only 1 exists
self.platform = sys.platform
# Main Window
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Spring GUI -> Profile")
self.window.set_resizable(True)
self.window.connect("delete-event", gtk.main_quit)
self.window.add_events(gtk.gdk.BUTTON_PRESS_MASK)
# Vertical Box Part 1/2
vbox = gtk.VBox(False, 0)
vbox.show()
self.window.add(vbox)
# Menu Part 1/2
menu_bar = gtk.MenuBar()
menu_bar.show()
# Battle & Options Notebook
notebook = gtk.Notebook()
notebook.set_tab_pos(gtk.POS_TOP)
notebook.show()
# Notebook Tabs
GUI_Setup.create(self,notebook)
#Vertical Box Part 2/2
vbox.pack_start(notebook, True, True, 2)
self.window.show()
def __init__(self, macapp):
gtk.Window.__init__(self)
self.set_default_size(400, 300)
vbox = gtk.VBox(False, 0)
self.add(vbox)
vbox.pack_start(gtk.Label("Some content here"), True, True, 0)
# Setup a menu bar with GTK+
menubar = gtk.MenuBar()
menu = gtk.Menu()
item = gtk.MenuItem("Open")
item.connect("activate", self.activate_cb)
menu.add(item)
item = gtk.MenuItem("Save")
item.connect("activate", self.activate_cb)
menu.add(item)
quit_item = gtk.MenuItem("Quit")
quit_item.connect("activate", lambda d: gtk.main_quit())
menu.add(quit_item)
item = gtk.MenuItem("File")
item.set_submenu(menu)
menubar.add(item)
menubar.show_all()
vbox.pack_start(menubar)
self.show()
# menubar.hide()
# Set up the menu bar integration
macapp.set_menu_bar(menubar)
# Take care of the Quit item, the integration code will put it
# in the standard place
quit_item.hide()
# Add two groups with items in the application menu
item = gtk.MenuItem("About")
item.show()
item.connect("activate", self.activate_cb)
macapp.insert_app_menu_item(item, 0)
item = gtk.MenuItem("Check for updates...")
item.connect("activate", self.activate_cb)
item.show()
macapp.insert_app_menu_item(gtk.SeparatorMenuItem(), 1)
macapp.insert_app_menu_item(item, 2)
item = gtk.MenuItem("Preferences")
item.connect("activate", self.activate_cb)
item.show()
macapp.insert_app_menu_item(item, 3)
def __init__(self):
gtk.HBox.__init__(self)
self.entry=gtk.Entry()
self.entry.set_size_request(80,-1)
self.entry.connect("focus-in-event",self.entry_focus_in)
self.entry.connect("focus-out-event",self.entry_focus_out)
bar=gtk.MenuBar()
self.search=gtk.MenuItem("search")
button=gtk.Button("",gtk.STOCK_FIND)
menu=gtk.Menu()
item=None
for name in ("Subject","From","Body"):
item=gtk.RadioMenuItem(item,name)
item.connect("toggled",self.change_search_type,name)
menu.append(item)
if name=="Subject": item.set_active(True)
self.search.set_submenu(menu)
bar.append(self.search)
#self.pack_start(gtk.VSeparator(),False,False,2)
self.pack_start(bar,False,False,0)
self.pack_start(self.entry,False,False,0)
self.pack_start(button,False,False,0)
#self.pack_start(gtk.VSeparator(),False,False,2)
button.connect("clicked",self.on_search_clicked)
self.search_type="Subject"
def _get_menu(self):
allmenus = (("File", ("load", "save", None, "shot", "recanim",
"recsound", None, "quit")),
("Emulation", ("run", "pause", "forward", None, "full",
None, "input", None, "reset")),
("Devices", ("display", "floppy", "harddisk", "joystick",
"machine", "device", "sound")),
("Configuration", ("path", None, "lconfig", "sconfig")),
("Debug", ("debug", "trace")), ("Help", (
"manual",
"compatibility",
"release",
"todo",
None,
"mails",
"changes",
None,
"authors",
"hatari",
"hatariui",
"about",
)))
bar = gtk.MenuBar()
for title, items in allmenus:
self._add_submenu(bar, title, items)
if self.panels:
self._add_submenu(bar, "Panels", self.panels)
return bar
def _buildMenu(self):
"""
Builds The application menu
"""
self.mainmenu = gtk.MenuBar()
self.menuitems = {}
# Build the base menus
for menu in (
("file", _("_File")),
("edit", _("_Edit")),
("view", _("_View")),
("help", _("_Help")),
):
self.menuitems[menu[0]] = self._addTopLevelMenu(
self.mainmenu, menu[1])
self.menuitems["help"].set_right_justified(True)
# Build the File menu
fm = self.menuitems["file"].get_submenu()
self._addChildMenuItem(fm, _("_New"), callback=None, data=None)
self._addChildMenuItem(fm, _("_Open"), callback=None, data=None)
self._addChildMenuItem(fm, _("_Save"), callback=None, data=None)
self._addChildMenuItem(fm, _("Save _As"), callback=None, data=None)
fm.append(gtk.SeparatorMenuItem())
self._addChildMenuItem(fm, _("Quit"), callback=self.close, data=None)
return self.mainmenu
def SetupWidgets(self):
self.MainWindow = gtk.Window()
self.MainConteiner = gtk.VBox()
self.MainWindow.add(self.MainConteiner)
self.Menubar = gtk.MenuBar()
self.MainConteiner.pack_start(self.Menubar, False, False, 0)
self.File = gtk.MenuItem("_File")
self.Menubar.add(self.File)
self.FileMenu = gtk.Menu()
self.File.set_submenu(self.FileMenu)
self.Save = gtk.ImageMenuItem("_Save as txt")
self.Save.connect("activate", self.save)
self.FileMenu.append(self.Save)
self.Exit = gtk.ImageMenuItem("E_xit")
self.Exit.connect("activate", self.destroy)
self.FileMenu.append(self.Exit)
self.SongLabel = gtk.TextView()
self.MainConteiner.add(self.SongLabel)
self.Buffer = gtk.TextBuffer()
self.SongLabel.set_buffer(self.Buffer)
def __init__(self):
self.config = tgcm.core.Config.Config(tgcm.country_support)
self.device_dialer = tgcm.core.FreeDesktop.DeviceDialer()
self.accelgroup = gtk.AccelGroup()
self.menubar = gtk.MenuBar()
self.main_actiongroup = gtk.ActionGroup('Tgcm')
self.help_actiongroup = gtk.ActionGroup('Help')
self.main_action = gtk.Action('Tgcm', self.config.get_app_name(), None,
None)
self.main_actiongroup.add_action(self.main_action)
self.main_menuitem = self.main_action.create_menu_item()
self.menubar.append(self.main_menuitem)
self.help_action = gtk.Action('HelpGroup', None, None, gtk.STOCK_HELP)
self.help_actiongroup.add_action(self.help_action)
self.help_menuitem = self.help_action.create_menu_item()
self.menubar.append(self.help_menuitem)
self.main_menu = gtk.Menu()
self.main_menuitem.set_submenu(self.main_menu)
self.help_menu = gtk.Menu()
self.help_menuitem.set_submenu(self.help_menu)
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.menu_box = gtk.VBox(False, 0)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(10)
self.read_card = gtk.Button(u"Прочитать карточку")
self.read_card.connect("clicked", self.read_card_cb, None)
self.menu_box.pack_start(self.read_card)
self.new_client = gtk.Button(u"Завести клиента")
self.new_client.connect("clicked", self.new_client_cb, None)
self.menu_box.pack_start(self.new_client)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("File")
filem.set_submenu(filemenu)
settings = gtk.MenuItem("Настройки")
settings.connect("activate", self.settings_cb)
filemenu.append(settings)
exit = gtk.MenuItem("Выход")
exit.connect("activate", gtk.main_quit)
filemenu.append(exit)
mb.append(filem)
self.menu_box.pack_start(mb, False, False, 0)
self.window.add(self.menu_box)
self.window.show_all()
def setup_menu(self):
self.menuBar = gtk.MenuBar()
fileMenu = gtk.Menu()
openMenuItem = gtk.MenuItem("Open")
saveMenuItem = gtk.MenuItem("Save")
quitMenuItem = gtk.MenuItem("Quit")
fileMenu.append(openMenuItem)
fileMenu.append(saveMenuItem)
fileMenu.append(gtk.SeparatorMenuItem())
fileMenu.append(quitMenuItem)
#TODO: callbacks
fileMenuItem = gtk.MenuItem("File")
fileMenuItem.set_submenu(fileMenu)
self.menuBar.append(fileMenuItem)
helpMenu = gtk.Menu()
aboutMenuItem = gtk.MenuItem("About")
helpMenu.append(aboutMenuItem)
helpMenuItem = gtk.MenuItem("Help")
helpMenuItem.set_submenu(helpMenu)
helpMenuItem.set_right_justified(right_justified=True)
self.menuBar.append(helpMenuItem)
return self.menuBar
def __set_menu(self):
mb=gtk.MenuBar()
mb.add(self.__set_menu_main('Весы',[[u'Настрока подключения','setlink'],[u'Выход','quit']]))
mb.add(self.__set_menu_main('Данные',[['Товары','plu'],'-',[u'Группы товаров','grouptovar'],[u'Продавцы','selers'],[u'Тара','tare'],'-',[u'Маска штрихкода','barcodemask'],'-',[u'Бегущая строка','scrollstr'],[u'Верхний и нижний текст чека','colontituls'],[u'Название магазина','shopname'],[u'Рекламный текст','misktext'],[u'Дополнительные тексты(ингридиенты)','doptext']]))
mb.add(self.__set_menu_main('Конфигурация',[['Конфигурация обслуживания','configsale']]))
mb.add(self.__set_menu_main('Редактор этикеток',[[u'Редактор этикеток','labeldesign'],[u'Редактор клавиатуры PLU','setkeyplu']]))
mb.add(self.__set_menu_main('Помощь',[[u'О программе','about']]))
return mb
def create_menubar(self):
self.menubar_box = gtk.HandleBox()
menubar = gtk.MenuBar()
self.menubar_box.add(menubar)
file_menu_item = gtk.MenuItem('_File')
edit_menu_item = gtk.MenuItem('_Edit')
view_menu_item = gtk.MenuItem('_View')
settings_menu_item = gtk.MenuItem('_Settings')
help_menu_item = gtk.MenuItem('_Help')
file_menu = gtk.Menu()
self.save_item = MyImageMenuItem('_Save', 'gtk-save')
separator1 = gtk.SeparatorMenuItem()
self.exit_item = MyImageMenuItem('_Quit', 'gtk-quit')
file_menu.add(self.save_item)
file_menu.add(separator1)
file_menu.add(self.exit_item)
file_menu_item.set_submenu(file_menu)
edit_menu = gtk.Menu()
self.add_item = MyImageMenuItem('_Add', 'gtk-add')
self.edit_item = MyImageMenuItem('_Edit', 'gtk-edit')
self.delete_item = MyImageMenuItem('_Delete', 'gtk-delete')
edit_menu.add(self.add_item)
edit_menu.add(self.edit_item)
edit_menu.add(self.delete_item)
edit_menu_item.set_submenu(edit_menu)
view_menu = gtk.Menu()
self.plan_view_item = MyImageMenuItem('_Plan', 'gnutr-plan')
self.recipe_view_item = MyImageMenuItem('_Recipe', 'gnutr-recipe')
self.food_view_item = MyImageMenuItem('_Food', 'gnutr-food')
view_menu.add(self.plan_view_item)
view_menu.add(self.recipe_view_item)
view_menu.add(self.food_view_item)
view_menu_item.set_submenu(view_menu)
settings_menu = gtk.Menu()
self.nutr_goal_item = MyImageMenuItem('Nutrient _Goal',
'gtk-properties')
settings_menu.add(self.nutr_goal_item)
settings_menu_item.set_submenu(settings_menu)
help_menu = gtk.Menu()
self.manual_item = MyImageMenuItem('_Contents', 'gtk-help')
self.about_item = MyImageMenuItem('_About', 'gtk-about')
help_menu.add(self.manual_item)
help_menu.add(self.about_item)
help_menu_item.set_submenu(help_menu)
menubar.add(file_menu_item)
menubar.add(edit_menu_item)
menubar.add(view_menu_item)
menubar.add(settings_menu_item)
menubar.add(help_menu_item)
self.menubar_box.show_all()
def create_menu_bar(self): # Create a menu-bar to hold the menus and add it to our main window self.menuBar = gtk.MenuBar() self.menuBar.show() self.menuBar.append(self.fileMenuRoot) self.menuBar.append(self.viewMenuRoot) self.menuBar.append(self.debugMenuRoot) self.menuBar.append(self.helpMenuRoot) return self.menuBar
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda w: gtk.main_quit())
self.set_title(self.__class__.__name__)
self.set_default_size(400, 200)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=200, min_height=100)
vbox = gtk.VBox(False, 0)
self.add(vbox)
mb = gtk.MenuBar()
filemenu = gtk.Menu()
file = gtk.MenuItem("File")
file.set_submenu(filemenu)
# img.set_from_file
open = gtk.ImageMenuItem("Open")
img = gtk.Image()
img.set_from_file(OPEN)
open.set_image(img)
open.connect("activate", self.menuitem_response, "Open picked")
filemenu.append(open)
exit = gtk.MenuItem("Exit")
exit.connect("activate", self.menuitem_response, "Exit pressed")
filemenu.append(exit)
mb.append(file)
viewmenu = gtk.Menu()
# From StockItem
view = gtk.ImageMenuItem("View")
img = gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)
view.set_image(img)
view.set_submenu(viewmenu)
set = gtk.MenuItem("Set View")
set.connect("activate", self.menuitem_response, "Set View pressed")
viewmenu.append(set)
mb.append(view)
infomenu = gtk.Menu()
info = gtk.MenuItem("Info")
info.set_submenu(infomenu)
# PixBuffFromFile with scaling
see = gtk.ImageMenuItem("See Info")
pixbuf = gtk.gdk.pixbuf_new_from_file(APPLE)
pixbuf = pixbuf.scale_simple(20, 20, gtk.gdk.INTERP_BILINEAR)
img = gtk.Image()
img.set_from_pixbuf(pixbuf)
see.set_image(img)
see.connect("activate", self.menuitem_response, "See Info pressed")
infomenu.append(see)
mb.append(info)
vbox.pack_start(mb, False, False, 2)
self.show_all()
def __init__(self):
self.version = "1.2"
self.socket_count = 0
gtkpccardwin = gtk.Window(gtk.WINDOW_TOPLEVEL)
gtkpccardwin.set_wmclass("gtkpccard", "gtk.PCCard")
self.tips = gtk.Tooltips()
gtkpccardwin.realize()
gtkpccardwin.set_title("gtk.PCCard" + " v." + self.version)
gtkpccardwin.set_position(gtk.WIN_POS_CENTER)
self.gtkpccardwin = gtkpccardwin
mainvbox1 = gtk.VBox(0, 1)
mainvbox1.set_spacing(2)
mainvbox = gtk.VBox(0, 1)
mainvbox.set_spacing(2)
mymenubar = gtk.MenuBar()
self.mymenubar = mymenubar
ag = gtk.AccelGroup()
self.itemf = gtk.ItemFactory(gtk.MenuBar, "<main>", ag)
self.itemf.create_items((
# path key callback action# type
(_("/ _File"), "<alt>F", None, 0, "<Branch>"),
(_("/ _File") + "/_" + FILE_RUN, "<control>R", rundlg, 421, ""),
(_("/ _File") + "/_" +
_("Check for newer versions of this program..."), "<control>U",
checkSoftUpdate, 420, ""),
(_("/ _File/sep4"), None, None, 49, "<Separator>"),
(_("/ _File/_Quit"), "<control>Q", self.doQuit, 10, ""),
(_("/_Help"), "<alt>H", None, 16, "<LastBranch>"),
(_("/Help/_About..."), "F2", self.doAbout, 17, ""),
(_("/_Help") + "/_" + APP_HELP_STR, "F4", displayHelp, 5011, ""),
(_("/_Help") + "/_" + CONTRIBUTORS + "...", "F3", show_credits,
913, ""),
(_("/_Help") + "/_" + BUG_REPORT_MENU + "...", "F5",
file_bug_report, 5011, ""),
))
gtkpccardwin.add_accel_group(ag)
mymenubar = self.itemf.get_widget("<main>")
mymenubar.show()
mainvbox1.pack_start(mymenubar, 0, 0, 0)
mainvbox1.pack_start(mainvbox, 1, 1, 0)
mainvbox.pack_start(
getImage(getBaseDir() + "icewmcp.png", "IceWM Control Panel"), 0,
0, 2)
mainvbox.pack_start(gtk.Label("gtk.PCCard: " + _("PC Card Manager")),
0, 0, 2)
self.mynotebook = gtk.Notebook()
self.mynotebook.set_scrollable(1)
self.addWidgets()
mainvbox.pack_start(self.mynotebook, 1, 1, 2)
gtkpccardwin.add(mainvbox1)
self.gtkpccardwin = gtkpccardwin
gtkpccardwin.set_default_size(-1, 440)
gtkpccardwin.connect("destroy", self.doQuit)
gtkpccardwin.show_all()
