Test you stuff in python first, then move it to c/c++ if need be. This
allows for rapid testing of what you really need to do. Whatever you
are trying to do, it is possible, for complete menubar, menus, menuitems
on any platform. Windowing APIs for windows, linux, mac all can handle
this.
gtk3-demo has tool-palette sample.
The gtk api jargon has set/unset, remove, append, show.
http://www.pygtk.org/pygtk2tutorial/sec-Toolbar.html
http://www.pygtk.org/pygtk2tutorial/examples/toolbar.py
Don't forget to disconnect callbacks before unsetting toolbars, menus,
menu items. Rule of thumb: if you connect it, you have to disconnect it
if you change the gui dynamically. Don't rely on
smart-pointers/garbage-collection to take care of these things.
http://zetcode.com/tutorials/gtktutorial/gtkevents/
This is a tweaked applicationmenu.py
#!/usr/bin/env python
import gtk
class ApplicationMenu:
def __init__(self):
window = gtk.Window()
menubar = gtk.MenuBar()
self.menu_file = gtk.Menu()
self.menu_edit = gtk.Menu()
self.menu_help = gtk.Menu()
item_open = gtk.MenuItem(Open)
item_save = gtk.MenuItem(Save)
item_quit = gtk.MenuItem(Quit)
self.menu_file.append(item_open)
self.menu_file.append(item_save)
self.menu_file.append(item_quit)
item_cut = gtk.MenuItem(Cut)
item_copy = gtk.MenuItem(Copy)
item_paste = gtk.MenuItem(Paste)
item_change_menus = gtk.MenuItem(Change Menus)
self.menu_edit.append(item_cut)
self.menu_edit.append(item_copy)
self.menu_edit.append(item_paste)
self.menu_edit.append(item_change_menus)
item_about = gtk.MenuItem(About)
self.menu_help.append(item_about)
item_file = gtk.MenuItem(File)
item_edit = gtk.MenuItem(Edit)
item_help = gtk.MenuItem(Help)
item_file.set_submenu(self.menu_file)
item_edit.set_submenu(self.menu_edit)
item_help.set_submenu(self.menu_help)
menubar.append(item_file)
menubar.append(item_edit)
menubar.append(item_help)
window.connect(destroy, lambda w: gtk.main_quit())
item_change_menus.connect(activate, self.menu_change_menus)
window.add(menubar)
window.show_all()
def menu_foo(self, widget):
print menu_foo clicked
def menu_change_menus(self, widget):
print menu_change_menus clicked
for widget in self.menu_edit.get_children():
self.menu_edit.remove(widget)
self.item_foo1 = gtk.MenuItem(foo1)
self.item_foo2 = gtk.MenuItem(foo2)
self.item_foo3 = gtk.MenuItem(foo3)
self.item_foo1.connect(activate, self.menu_foo)
self.item_foo2.connect(activate, self.menu_foo)
self.item_foo3.connect(activate, self.menu_foo)
self.menu_edit.append(self.item_foo1)
self.menu_edit.append(self.item_foo2)
self.menu_edit.append(self.item_foo3)
self.item_foo1.show()
self.item_foo2.show()
self.item_foo3.show()
self.menu_edit.show()
ApplicationMenu()
gtk.main()
On 05/11/2014 12:29 PM, Pierre Wieser wrote:
Hi all,
I am starting with a small app which will handle documents.
I want this app has two different menubars :
- a first one when there is no document
- another one when the document is opened.
I have tried to use gtk_application_set_menubar with two
different GMenuModel, but no luck: the GtkApplicationWindow
menubar never changes.
After having searched in the sources, I found that the GtkWidget
menubar is automatically rebuilt from a GMenu menubar_section.
But the menubar_section itself is initially built in real_realize,
thenonly rebuilt when some gtk-shell settings changes
(notify::gtk-shell-shows-menubar exactly, but this not relevant here).
So it appears to me that it is just impossible to replace the menubar.
Am I right ? Is it the expected behavior ?
As a side effect, I do not understand the rationale behind
gtk_application_set_menubar: why are we allowed to change the GMenuModel
if the visible GtkWidget is not updated ?
Thanks for some explanations..
Regards
Pierre
___
gtk-app-devel-list mailing list
gtk-app-devel-list@gnome.org
https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
___
gtk-app-devel-list mailing list
gtk-app-devel-list@gnome.org
https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
