if len(shell_list) <= 1:
shell_name, value = shell_list[0]
item.connect(
- 'activate', lambda a, v: handler(value), (value))
+ 'activate', lambda a, v: handler(v), (value))
else:
submenu = gtk.Menu()
submenu.set_name('popup menu')
subitem = gtk.MenuItem(shell_name)
subitem.set_name('popup menu item')
subitem.connect(
- 'activate', lambda a, v: handler(value), (value))
+ 'activate', lambda a, v: handler(v), (value))
subitem.show()
submenu.append(subitem)
return item
menuitem = self.ui_manager.get_widget(''.join(('/popup/', path)))
menuitem.set_submenu(ghost_menu)
+ def create_shell_menuitem(self, shell_name, value, handler):
+ item = gtk.MenuItem(shell_name)
+ item.set_name('popup menu item')
+ item.connect('activate', lambda a, v: handler(v), (value))
+ item.show()
+ return item
+
def __set_shell_menu(self):
- shell_list = self.request_parent('GET', 'get_shell_list')
+ shell_menulist = self.request_parent('GET', 'get_shell_menulist')
shell_menu = gtk.Menu()
- for i in range(len(shell_list)):
- shell_name, value, working = shell_list[i]
- item = gtk.MenuItem(shell_name)
- item.set_name('popup menu item')
- item.connect(
- 'activate',
- lambda a, v: self.request_parent('NOTIFY', 'select_shell', v),
- (value))
- item.show()
- if working:
- item.set_sensitive(False)
- shell_menu.append(item)
+ for item in shell_menulist:
+ if item.get_parent():
+ item.reparent(shell_menu)
+ else:
+ shell_menu.append(item)
menuitem = self.ui_manager.get_widget(''.join(('/popup/', 'Shell')))
menuitem.set_submenu(shell_menu)
if event_type == 'GET':
return result
- def select_sakura(self, item):
- if self.busy():
- gtk.gdk.beep()
- return
- self.request_parent('NOTIFY', 'change_sakura', self, item, 'manual')
-
def attach_observer(self, observer):
if observer not in self.__observers:
self.__observers[observer] = 1
def get_prefix(self):
return self.prefix
- def get_shell_list(self):
- shell_list = []
- set_type, i, j = self.current
- assert set_type == 'g'
- keys = sorted(self.surface_set.keys())
- for key in keys:
- name = self.surface_set[key][0]
- value = (set_type, i, key)
- working = 1 if key == j else 0
- shell_list.append((name, value, working))
- return shell_list
-
def stick_window(self, flag):
self.surface.window_stick(flag)
- def toggle_bind(self, args): ## FIXME
+ def toggle_bind(self, args):
self.surface.toggle_bind(args)
- def get_menu_pixmap(self): ## FIXME
+ def get_menu_pixmap(self):
path_background, path_sidebar, path_foreground = \
self.surface.get_menu_pixmap()
top_dir = os.path.join(self.get_prefix(), 'ghost', 'master')
self.enqueue_event('OnShellChanging', surface_name, surface_dir,
proc=proc)
- def select_balloon(self, widget, item):
- if not widget.active:
- return
+ def select_balloon(self, item, desc, balloon):
+ self.balloon_directory = item # save user's choice
if item == self.get_current_balloon_directory(): # no change
- # need reloadning?
- if self.balloon_directory != item:
- self.balloon_directory = item # save user's choice
- return
- desc, balloon = self.request_parent(
- 'GET', 'get_balloon_description', item)
- subdir = balloon['balloon_dir'][0]
- path = os.path.join(get_ninix_home(), 'balloon', subdir)
+ return # need reloadning?
+ assert item == balloon['balloon_dir'][0]
+ path = os.path.join(get_ninix_home(), 'balloon', item)
self.balloon.hide_all()
self.set_balloon(desc, balloon)
- if item == subdir:
- self.balloon_directory = subdir # save user's choice
self.balloon.set_balloon_default()
self.position_balloons()
name = desc.get('name', '')
self.ghosts = OrderedDict()
odict_baseinfo = ninix.home.search_ghosts()
for key, value in odict_baseinfo.items():
+ ## FIXME: this should be class object
item = {'baseinfo': value,
'menuitem': None,
+ 'shell_menuitem': None,
'instance': None,}
self.ghosts[key] = item
self.balloons = ninix.home.search_balloons()
if sakura.cantalk]
return working_list
- def getstring(self, name): ## FIXME
+ def getstring(self, name):
return self.__menu_owner.getstring(name)
- def stick_window(self): ## FIXME
+ def stick_window(self):
stick = self.__menu.get_stick()
self.__menu_owner.stick_window(stick)
- def toggle_bind(self, args): ## FIXME
+ def toggle_bind(self, args):
self.__menu_owner.toggle_bind(args)
- def select_shell(self, item): ## FIXME
+ def select_shell(self, item):
self.__menu_owner.select_shell(item)
- def select_balloon(self, widget, item): ## FIXME
- self.__menu_owner.select_balloon(widget, item)
+ def select_balloon(self, widget, item):
+ if not widget.active:
+ return
+ desc, balloon = self.get_balloon_description(item)
+ self.__menu_owner.select_balloon(item, desc, balloon)
def get_current_balloon_directory(self): ## FIXME
return self.__menu_owner.get_current_balloon_directory()
- def get_shell_list(self): ## FIXME
- return self.__menu_owner.get_shell_list()
-
- def select_sakura(self, item): ## FIXME
- self.__menu_owner.select_sakura(item)
+ def select_sakura(self, item):
+ if self.__menu_owner.busy():
+ gtk.gdk.beep()
+ return
+ self.change_sakura(self.__menu_owner, item, 'manual')
- def notify_site_selection(self, args): ## FIXME
+ def notify_site_selection(self, args):
self.__menu_owner.notify_site_selection(args)
- def close_sakura(self): ## FIXME
+ def close_sakura(self):
self.__menu_owner.close()
- def about(self): ## FIXME
+ def about(self):
self.__menu_owner.about()
- def vanish(self): ## FIXME
+ def vanish(self):
self.__menu_owner.vanish()
- def network_update(self): ## FIXME
+ def network_update(self):
self.__menu_owner.network_update()
def open_popup_menu(self, sakura, button, side):
def get_ghost_menulist(self):
return [value['menuitem'] for value in self.ghosts.values()]
+ def get_shell_menulist(self):
+ set_type, i, j = self.__menu_owner.current
+ shell_menuitems = self.ghosts[i]['shell_menuitem']
+ for key, item in shell_menuitems.items():
+ item.set_sensitive(not bool(key == j)) # not working
+ return list(shell_menuitems.values())
+
def __create_menuitem(self, i):
assert i in self.ghosts
set_type = 'g'
name = desc.get('name', i)
shell_list = []
surface_set = baseinfo[3]
+ shell_menuitems = OrderedDict()
for j in surface_set.keys():
value = (set_type, i, j)
shell_name = surface_set[j][0]
shell_list.append((shell_name, value))
+ menuitem = self.__menu.create_shell_menuitem(
+ shell_name, value, self.select_shell)
+ shell_menuitems[j] = menuitem
if not shell_list: # XXX
return None
start_menuitem = self.__menu.create_ghost_menuitem(
name, icon_path, shell_list, self.select_sakura)
menuitem = {
'Summon': start_menuitem,
- 'Change': select_menuitem
+ 'Change': select_menuitem,
}
- return menuitem
+ return menuitem, shell_menuitems
def update_ghost_odict(self, i, sakura):
self.ghosts[i]['instance'] = sakura
- self.ghosts[i]['menuitem'] = self.__create_menuitem(i)
- if self.ghosts[i]['menuitem'] is None:
+ menuitem = self.__create_menuitem(i)
+ if menuitem is None:
del self.ghosts[i]
+ return
+ self.ghosts[i]['menuitem'] = menuitem[0]
+ self.ghosts[i]['shell_menuitem'] = menuitem[1]
def get_balloon_list(self):
balloon_list = []
self.quit()
elif self.current_sakura == sakura.current:
self.select_current_sakura()
- self.set_menu_sensitive(i, True)
def close_all_ghosts(self):
for sakura in self.get_working_ghost():
sakura.enqueue_event('OnGhostChanging', name, method, proc=proc)
def stop_sakura(self, sakura, starter=None, *args):
+ set_type, i, j = sakura.current
sakura.finalize()
if starter is not None:
starter(*args)
+ self.set_menu_sensitive(i, True)
self.close_ghost(sakura)
def start_sakura(self, item, prev=None, vanished=0, init=0, temp=0):
if exists:
self.ghosts[ghost_dir]['baseinfo'] = ghost_conf[ghost_dir]
else:
+ ## FIXME: this should be class object
item = {'baseinfo': ghost_conf[ghost_dir],
'menuitem': None,
+ 'shell_menuitem': None,
'instance': None,}
self.ghosts[ghost_dir] = item
sakura = self.create_ghost(ghost_conf[ghost_dir])
OSDN Git Service
