def __init__(self):
wx.Frame.__init__(self, None, title='Simple Menu Test')
self.panel = wx.Panel(self)
self.panel.Sizer = wx.BoxSizer(wx.VERTICAL)
menu = SimpleMenu(self, skinkey='simplemenu', maxheight=10, width=100)
items = [
SimpleMenuItem('Test1'), #,self.DifferentMethodTest),
SimpleMenuItem('Test2'),
SimpleMenuItem('Test3'),
SimpleMenuItem(id=-1),
SimpleMenuItem('Test4')
]
menu.SetItems(items)
skin = 'button'
size = None #(100,100)#
type = 'menu' #None#'toggle'#
#menu=None#self.menu#
icon = None #wx.Bitmap('../../../res/skins/default/statusicons/mobile.png',wx.BITMAP_TYPE_PNG)#wx.Bitmap('../../res/skins/default/tinydigsby.png',wx.BITMAP_TYPE_PNG)
self.smb1 = UberButton(self.panel,
wx.NewId(),
"SMB",
skin,
icon=icon,
style=wx.HORIZONTAL,
size=size,
type=type,
menu=menu)
self.panel.Sizer.Add(self.smb1)
def __init__(self, parent, textctrl, skinkey, formatOptions):
ToolBar.__init__(self, parent, skinkey = None, alignment = wx.ALIGN_LEFT)
self.SetSkinKey(skinkey, FormattingBarSkinDefaults)
self.textctrl = textctrl
if sys.platform.startswith("win"):
textctrl.Bind(EVT_SELECTION_CHANGED, self.OnCursorMove)
textctrl.Bind(EVT_TEXT_FORMAT_CHANGED, self.OnCursorMove)
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
self.fontdd = FontDropDown(self, skinkey = self.skinTB['buttonskin'])
self.fontdd.SetMenuSkinKey(self.skinTB["menuskin"])
self.fontdd.Bind(wx.EVT_COMMAND_CHOICE_SELECTED, self.OnFontSelected)
icons = self.icons
self.msize = SimpleMenu(self, self.skinTB['menuskin'], maxheight = 10)
self.msize.SetItems(self.GenSizeItems(DEFAULT_SIZES)) #TODO: None default sizes
# self.msize.Bind(wx.EVT_COMMAND_CHOICE_SELECTED, self.OnSizeSelected)
self.bsize = UberButton(self, -1, '10', menu = self.msize, type = 'menu')
self.bsize.SetStaticWidth(self.skinFB['sizedropdownwidth'])
self.msize.SetWidth(self.skinFB['sizedropdownwidth'])
self.bbold = UberButton(self, -1, icon = icons['bold'], type = 'toggle')
self.bbold.Bind(wx.EVT_TOGGLEBUTTON, self.OnBoldButton)
self.bitalic = UberButton(self, -1, icon = icons['italic'], type="toggle")
self.bitalic.Bind(wx.EVT_TOGGLEBUTTON, self.OnItalicButton)
self.bunderline = UberButton(self, -1, icon = icons['underline'], type="toggle")
self.bunderline.Bind(wx.EVT_TOGGLEBUTTON, self.OnUnderlineButton)
self.bcolor = UberButton(self, -1, icon = icons['foregroundcolor'] )
self.bcolor.Bind(wx.EVT_BUTTON, self.OnColorButton)
self.bbgcolor = UberButton(self,-1, icon = icons['backgroundcolor'])
self.bbgcolor.Bind(wx.EVT_BUTTON, self.OnBGColorButton)
self.bemote = UberButton(self, -1, icon = icons['emote'])
self.bemote.Bind(wx.EVT_BUTTON, self.OnEmoteButton)
# import pdb
# pdb.set_trace()
self.AddMany([self.fontdd,
self.bsize,
self.bbold,
self.bitalic,
self.bunderline,
self.bcolor,
self.bbgcolor,
self.bemote])
self.initover = True
self.EnableFormattingButtons(formatOptions)
self.UpdateDisplay()
def FileMenu(self):
self._filemenu = SimpleMenu(self, self.menuskin)
self.send_file_item = SimpleMenuItem(_('Send File'),
lambda *a: self.OnSendFiles())
# if b and b.online:
self._filemenu.AppendItem(self.send_file_item)
self._filemenu.AppendItem(
SimpleMenuItem(_('Transfer History'),
lambda *a: FileTransferDialog.Display()))
return self._filemenu
def __init__(self):
wx.Frame.__init__(self,None,title='Extended Simple Menu Test')
self.panel=wx.Panel(self)
self.panel.Sizer=wx.BoxSizer(wx.VERTICAL)
menu=SimpleMenu(self, 'simplemenu',width=100)
submenu=SimpleMenu(menu, 'simplemenu',width=100)
submenu2=SimpleMenu(submenu, 'simplemenu',width=100)
subitems=[
SimpleMenuItem('Test5'),
SimpleMenuItem(id=-1),
SimpleMenuItem('Test6'),
SimpleMenuItem('Test7',menu=submenu2),
SimpleMenuItem('Test8')
]
submenu.SetItems(subitems)
items=[
SimpleMenuItem('Test1'),
SimpleMenuItem('Test2'),
SimpleMenuItem("Test3 is a submenu m'kay",menu=submenu),
SimpleMenuItem(id=-1),
SimpleMenuItem('Test4'),
]
items3=[
SimpleMenuItem('Test9'),
SimpleMenuItem('Test10'),
SimpleMenuItem('Test11'),
SimpleMenuItem('Test12'),
SimpleMenuItem('Test13'),
SimpleMenuItem('Test14'),
SimpleMenuItem('Test15'),
SimpleMenuItem('Test16'),
SimpleMenuItem('Test17')
]
submenu2.SetItems(items3)
menu.SetItems(items)
skin='button'
size=None#(100,100)#
type='menu'#None#'toggle'#
#menu=None#self.menu#
icon=wx.Bitmap('../../../res/skins/default/statusicons/mobile.png',wx.BITMAP_TYPE_PNG)#wx.Bitmap('../../res/skins/default/tinydigsby.png',wx.BITMAP_TYPE_PNG)
self.smb1=UberButton(self.panel,wx.NewId(),"SMB",skin,icon=icon,style=wx.HORIZONTAL,size=size,type=type,menu=menu)
self.panel.Sizer.Add(self.smb1)
self.Bind(wx.EVT_MENU,self.OnMenu)
def __init__(self, combo, OnLoseFocus):
self.combo = combo
# the "remove" menu contains every item
menu = combo.menu
self.remove_menu = SimpleMenu(menu,
combo.menuskin,
callback=self.OnRemove)
self.remove_item = SimpleMenuItem(_('Remove'), menu=self.remove_menu)
self.add_item = SimpleMenuItem(_('Add...'), method=self.OnAdd)
self.OnLoseFocus = OnLoseFocus
def setup_from_accts(self):
# add an "Add" menu containing each email account type
self.addList = addList = SimpleMenu(self.fromcombo.menu, 'simplemenu')
for emailtype in emailprotocols.keys():
addList.Append([
skinget('serviceicons.%s' % emailtype).Resized(16),
protocols[emailtype].name
],
method=lambda item, emailtype=emailtype:
add_email_account(emailtype))
# link to creating an email account
from gui.pref import prefsdialog
self.accounts_item = SimpleMenuItem(
_('Accounts...'), method=lambda *a: prefsdialog.show('accounts'))
# watch the email list for changes
pass
self._obs_link = profile.emailaccounts.add_list_observer(
self.on_email_accounts_changed, self.on_email_accounts_changed,
'enabled')
self.tocombo.Bind(EVT_WINDOW_DESTROY, lambda e:
(e.Skip(), self.unregister_observers()))
def show_extended_status_menu(self):
from gui.status import get_state_choices
m = SimpleMenu(self, skinkey=skin.get('%s.MenuSkin' % self.skinkey))
for status in get_state_choices():
statusname, statuslabel = status
def onclick(item, state=statusname):
self.change_state(
state
) #, change_text = self.status_state == self.GetValue())
m.AppendItem(
SimpleMenuItem(
[StatusMessage.icon_for(statusname), statuslabel],
method=onclick))
if m.GetCount() > 0:
m.Display(self.cbutton)
class FormattingBar(ToolBar, NewSkinModule):
initover = False
def __init__(self, parent, textctrl, skinkey, formatOptions):
ToolBar.__init__(self, parent, skinkey = None, alignment = wx.ALIGN_LEFT)
self.SetSkinKey(skinkey, FormattingBarSkinDefaults)
self.textctrl = textctrl
if sys.platform.startswith("win"):
textctrl.Bind(EVT_SELECTION_CHANGED, self.OnCursorMove)
textctrl.Bind(EVT_TEXT_FORMAT_CHANGED, self.OnCursorMove)
self.Bind(wx.EVT_CONTEXT_MENU, self.OnContextMenu)
self.fontdd = FontDropDown(self, skinkey = self.skinTB['buttonskin'])
self.fontdd.SetMenuSkinKey(self.skinTB["menuskin"])
self.fontdd.Bind(wx.EVT_COMMAND_CHOICE_SELECTED, self.OnFontSelected)
icons = self.icons
self.msize = SimpleMenu(self, self.skinTB['menuskin'], maxheight = 10)
self.msize.SetItems(self.GenSizeItems(DEFAULT_SIZES)) #TODO: None default sizes
# self.msize.Bind(wx.EVT_COMMAND_CHOICE_SELECTED, self.OnSizeSelected)
self.bsize = UberButton(self, -1, '10', menu = self.msize, type = 'menu')
self.bsize.SetStaticWidth(self.skinFB['sizedropdownwidth'])
self.msize.SetWidth(self.skinFB['sizedropdownwidth'])
self.bbold = UberButton(self, -1, icon = icons['bold'], type = 'toggle')
self.bbold.Bind(wx.EVT_TOGGLEBUTTON, self.OnBoldButton)
self.bitalic = UberButton(self, -1, icon = icons['italic'], type="toggle")
self.bitalic.Bind(wx.EVT_TOGGLEBUTTON, self.OnItalicButton)
self.bunderline = UberButton(self, -1, icon = icons['underline'], type="toggle")
self.bunderline.Bind(wx.EVT_TOGGLEBUTTON, self.OnUnderlineButton)
self.bcolor = UberButton(self, -1, icon = icons['foregroundcolor'] )
self.bcolor.Bind(wx.EVT_BUTTON, self.OnColorButton)
self.bbgcolor = UberButton(self,-1, icon = icons['backgroundcolor'])
self.bbgcolor.Bind(wx.EVT_BUTTON, self.OnBGColorButton)
self.bemote = UberButton(self, -1, icon = icons['emote'])
self.bemote.Bind(wx.EVT_BUTTON, self.OnEmoteButton)
# import pdb
# pdb.set_trace()
self.AddMany([self.fontdd,
self.bsize,
self.bbold,
self.bitalic,
self.bunderline,
self.bcolor,
self.bbgcolor,
self.bemote])
self.initover = True
self.EnableFormattingButtons(formatOptions)
self.UpdateDisplay()
def OnContextMenu(self, event):
from gui.uberwidgets.umenu import UMenu
m = UMenu(self)
m.AddItem(_('Hide Formatting Bar'), callback = lambda: wx.CallAfter(setpref, 'messaging.show_formatting_bar', False))
m.PopupMenu()
def OnFontSelected(self, event):
"""
Updates the button to the new font and applies it to the selection
or calls ApplyStlye
"""
self.textctrl.ApplyStyle(facename = self.fontdd.GetClientData(self.fontdd.GetSelection()).GetFaceName())
def OnSizeSelected(self, item):
"""
Updates the Size button to the new size and applies it to the selection
or calls ApplyStyle
"""
self.bsize.label = str(item.id)
self.textctrl.ApplyStyle(pointsize = item.id)
def OnBoldButton(self, event):
self.textctrl.ApplyStyle(bold = event.EventObject.IsActive())
def OnItalicButton(self, event):
self.textctrl.ApplyStyle(italic = event.EventObject.IsActive())
def OnUnderlineButton(self, event):
self.textctrl.ApplyStyle(underline = event.EventObject.IsActive())
def OnColorButton(self, event):
oldtextcolor = self.textctrl.GetFormat().GetTextColour()
self.textctrl.ApplyStyle(textcolor = wx.GetColourFromUser(self, oldtextcolor, _('Choose a foreground color')))
def OnBGColorButton(self, event):
oldbgcolor = self.textctrl.GetFormat().GetTextColour()
self.textctrl.ApplyStyle(bgcolor = wx.GetColourFromUser(self, oldbgcolor, _('Choose a background color')))
def OnEmoteButton(self, event):
self.DisplayEmotibox(self.bemote.ScreenRect)
def DisplayEmotibox(self, rect):
import hooks
hooks.notify('digsby.statistics.emoticons.box_viewed')
ebox = self.GetEmotibox()
# position and display the emotibox
ebox.Display(rect)
def GetEmotibox(self):
'Shares the emoticon box between all instances of this class.'
b = None
old_name, new_name = getattr(self, '_emotipack_name', None), pref('appearance.conversations.emoticons.pack', type = unicode, default = u'default')
self._emotipack_name = new_name
try:
b = self.__class__.emotibox
if not wx.IsDestroyed(b):
if old_name != new_name:
b.Destroy()
elif b.Parent is not self:
b.Reparent(self)
except AttributeError:
pass
if b is None or wx.IsDestroyed(b):
from gui.imwin.emoticons import get_emoticon_bitmaps
b = self.__class__.emotibox = UberEmotiBox(self, get_emoticon_bitmaps(self._emotipack_name), self.textctrl, maxwidth = 12)
else:
b.SetTextCtrl(self.textctrl)
return b
def OnCursorMove(self, event):
event.Skip()
wx.CallAfter(self.UpdateDisplay)
def UpdateDisplay(self):
if wx.IsDestroyed(self.textctrl):
return
selection = self.textctrl.GetSelection()
if selection[0] != selection[1]:
return
textattr = self.textctrl.GetFormat()
font = textattr.GetFont()
facename = font.GetFaceName()
self.fontdd.SetSelection(self.fontdd.FindString(facename, False))
self.bsize.SetLabel(str(font.GetPointSize()))
self.bbold.Active(font.GetWeight() == wx.FONTWEIGHT_BOLD)
self.bitalic.Active(font.GetStyle() == wx.FONTSTYLE_ITALIC)
self.bunderline.Active(font.GetUnderlined())
def EnableFormattingButtons(self, enabledict):
if enabledict is None:
return
default = enabledict['default'] if 'default' in enabledict else True
#TODO: fontdd should be disableable
buttons = [#('font', self.fontdd),
('size', self.bsize),
('bold', self.bbold),
('italic', self.bitalic),
('underline', self.bunderline),
('color', self.bcolor),
('bgcolor', self.bbgcolor),
('emote', self.bemote)]
for key, button in buttons:
button.Enable(enabledict[key] if key in enabledict else default)
def GenSizeItems(self, sizes = DEFAULT_SIZES):
"""
Sets the list of selectable sizes
If not set sizes default to ['8', '10', '12', '14', '18', '24', '36']
"""
return [SimpleMenuItem([str(size)], id=size, method = self.OnSizeSelected) for size in sizes]
def DoUpdateSkin(self, skin):
self.skinFB = skin
ToolBar.DoUpdateSkin(self, SkinProxy(skin['toolbarskin'], ToolBarSkinDefaults))
icons = self.icons = {}
icons['bold'] = skin['icons.bold']
icons['italic'] = skin['icons.italic']
icons['underline'] = skin['icons.underline']
icons['foregroundcolor'] = skin['icons.foregroundcolor']
icons['backgroundcolor'] = skin['icons.backgroundcolor']
icons['emote'] = skin['icons.emote']
iconsize = skin['iconsize']
for key in icons:
if icons[key] is not None:
icons[key] = icons[key].Resized(iconsize)
if self.initover:
self.bsize.SetStaticWidth(skin['sizedropdownwidth'])
self.msize.SetWidth(skin['sizedropdownwidth'])
self.bbold.SetIcon(icons['bold'])
self.bitalic.SetIcon(icons['italic'])
self.bunderline.SetIcon(icons['underline'])
self.bcolor.SetIcon(icons['foregroundcolor'])
self.bbgcolor.SetIcon(icons['backgroundcolor'])
self.bemote.SetIcon(icons['emote'])
def GetSkinProxy(self):
return self.skinFB if hasattr(self, 'skinFB') else None
class CapabilitiesBar(SimplePanel):
'''
A specialized UberBar used used in the infobox and the IM window
has a subbar with to/from combos.
'''
def __init__(self,
parent,
buddy_callback,
showCapabilities=True,
infoboxmode=False):
SimplePanel.__init__(self, parent)
self.buddy_callback = buddy_callback
self.Bind(wx.EVT_PAINT, lambda e: wx.PaintDC(self))
self.infoboxmode = infoboxmode
self._lastcaps = None
self.UpdateSkin()
self.Sizer = wx.BoxSizer(wx.VERTICAL)
# create delegates for callbacks
for action in ('OnSendFiles', 'OnSendFolder', 'OnViewPastChats',
'OnAlert', 'OnBlock', 'OnAddContact'):
setattr(self, action, Delegate())
# Create the uberbar for the capabilities.
self.cbar = bar = UberBar(self,
skinkey=self.capabilitiesskin,
overflowmode=True)
# FIXME: we should simply not allow the capabilities bar to be created for native mode
if not showCapabilities or nativeIMWindow:
self.cbar.Hide()
if not infoboxmode:
self.cbar.Bind(wx.EVT_CONTEXT_MENU,
lambda e: self.ActionsBarMenu.PopupMenu(event=e))
# Create all the buttons for the capabilities bar.
iconsize = skin.get('ActionsBar.IconSize')
icons = skin.get('ActionsBar.Icons')
for attr, title, tooltip in buttons:
icon = getattr(icons, attr).Resized(iconsize)
if attr == 'files':
# "files" has a dropdown menu
button = UberButton(bar,
-1,
title,
icon=icon,
type='menu',
menu=self.FileMenu)
# Change the label and action of the files button when it's overflowed into
# the menu on the right.
button.overflow_label = _('Send File')
button.overflow_callback = self.OnSendFiles
else:
# hack until I fix this :[ -kevin
if attr == 'video' and infoboxmode: continue
button = UberButton(bar, -1, title, icon=icon)
button.overflow_label = title
button.SetToolTipString(tooltip)
setattr(self, 'b' + attr, button)
bar.Add(button, calcSize=False)
bar.OnUBSize()
#TODO Add button logics
# if not self.infoboxmode:
# self.badd = UberButton(bar,-1,'',icon = getattr(icons, 'add').Resized(iconsize))
# bar.AddStatic(self.badd)
# self.badd.Bind(wx.EVT_BUTTON,lambda e: self.OnAddContact())
# Create multichat icon for the roomlist
if pref('messaging.groupchat.enabled', False) and not self.infoboxmode:
self.bmultichat = UberButton(
bar,
-1,
icon=skin.get('actionsbar.icons.roomlist').Resized(16),
type='toggle')
self.bmultichat.SetToolTipString(_('Group Chat'))
bar.AddStatic(self.bmultichat)
self.ihistory = SimpleMenuItem(_('View Past Chats'),
method=self.OnViewPastChats)
def show_prefs_notifications(a):
import gui.pref.prefsdialog as prefsdialog
prefsdialog.show('notifications')
self.ialert = SimpleMenuItem(_("Alert Me When..."),
method=show_prefs_notifications)
self.iblock = SimpleMenuItem(_("Block"), method=self.OnBlock)
if not self.infoboxmode:
self.iadd = SimpleMenuItem(_("Add Contact"),
method=self.OnAddContact)
bar.AddMenuItem(self.iadd)
bar.AddMenuItem(self.ihistory)
bar.AddMenuItem(self.ialert)
if not self.infoboxmode:
bar.AddMenuItem(SimpleMenuItem(id=-1))
bar.AddMenuItem(self.iblock)
self.Sizer.Add(bar, 0, wx.EXPAND)
# create the To/From bar
self.tfbar = tfbar = UberBar(self, skinkey=self.tofromskin)
self.tfbar.Hide()
tofrom_font = skin.get('tofrombar.font', default_font)
tofrom_color = skin.get('tofrombar.fontcolor', wx.BLACK)
talign = wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_RIGHT
self.to_label = ClearText(tfbar, _('To:'), alignment=talign)
self.to_label.Font = tofrom_font
self.to_label.FontColor = tofrom_color
self.from_label = ClearText(tfbar, _('From:'), alignment=talign)
self.from_label.Font = tofrom_font
self.from_label.FontColor = tofrom_color
self.cto = UberCombo(tfbar,
skinkey=self.tofromcomboskin,
typeable=False,
size=(100, 20),
minmenuwidth=200)
self.cfrom = UberCombo(tfbar,
skinkey=self.tofromcomboskin,
typeable=False,
size=(100, 20),
minmenuwidth=200)
tfbar.Add(self.to_label, calcSize=False)
tfbar.Add(self.cto, True, calcSize=False)
tfbar.Add(self.from_label, calcSize=False)
tfbar.Add(self.cfrom, True)
self.Sizer.Add(tfbar, 0, wx.EXPAND)
profile.prefs.link(action_icons_key, self.UpdateIcons)
self.cbar.overflowmenu.BeforeDisplay += self.ApplyCaps
ToCombo = property(lambda self: self.cto)
FromCombo = property(lambda self: self.cfrom)
def UpdateSkin(self):
'Tells the subbars what skins they should load.'
sget = skin.get
self.capabilitiesskin = sget('actionsbar.toolbarskin', None)
self.tofromskin = sget('tofrombar.toolbarskin', None)
self.menuskin = sget('%s.menuskin' % self.capabilitiesskin, None)
self.tofromcomboskin = sget("tofrombar.comboboxskin", None)
self.iconsize = sget('ActionsBar.IconSize')
self.icons = sget('ActionsBar.Icons')
if hasattr(self, 'to_label'):
tofrom_font = sget('tofrombar.font', lambda: default_font())
tofrom_color = sget('tofrombar.fontcolor', lambda: wx.BLACK)
self.to_label.Font = self.from_label.Font = tofrom_font
self.to_label.FontColor = self.from_label.FontColor = tofrom_color
if hasattr(self, 'cbar'): self.cbar.SetSkinKey(self.capabilitiesskin)
if hasattr(self, 'tfbar'): self.tfbar.SetSkinKey(self.tofromskin)
if hasattr(self, 'cto'): self.cto.SetSkinKey(self.tofromcomboskin)
if hasattr(self, 'cfrom'): self.cfrom.SetSkinKey(self.tofromcomboskin)
self.UpdateIcons()
def UpdateIcons(self, *a):
'Updates icon sizes for buttons.'
icons_pref = pref(action_icons_key)
textonly = icons_pref == 'text'
icons = self.icons
size = self.iconsize
#TODO: Add Button logics
# allbuttons = list(buttons)
# allbuttons.append(('add',''))
with self.Frozen():
for attr, title, tooltip in buttons:
icon = None if textonly else getattr(icons, attr).Resized(size)
button = getattr(self, 'b' + attr, None)
if button is not None:
button.SetIcon(icon)
button.SetAlignment(wx.VERTICAL if icons_pref ==
'above' else wx.HORIZONTAL)
button.SetLabel('' if icons_pref == 'icons' else title)
self.Parent.Layout()
self.Refresh()
def ShowToFrom(self, show=True):
'Show or hide the to/from bar.'
return self.tfbar.Show(show)
@property
def RoomListButtonShown(self):
bmultichat = getattr(self, 'bmultichat', None)
return bmultichat is not None and bmultichat.IsShown()
@property
def ToFromShown(self):
'Returns True if the To/From bar is shown.'
return self.tfbar.IsShown()
def ShowCapabilities(self, show=True):
'Show/Hide the capabilities bar.'
return self.cbar.Show(show)
#self.Layout()
def CapabilitiesIsShown(self):
'Returns True if the capabilities bar is shown.'
return self.cbar.IsShown()
def GetButton(self, button):
'Returns one of the butons by name.'
return getattr(self, 'b' + button, None)
def ApplyCaps(self, contact=None, convo=None):
'Those shows and hides options depending on the capabilities the Contact reports.'
if contact is None and convo is None:
convo = self.buddy_callback()
from common.Conversation import Conversation
if not isinstance(convo, Conversation):
contact = convo
convo = None
c = None
if convo is not None:
if convo.ischat:
c = set([caps.IM])
elif contact is None:
contact = convo.buddy
if c is None:
c = set(contact.caps)
if contact is not None:
c.add(('blocked', contact.blocked))
# early exit if capabilities are the same.
if c == self._lastcaps: return
buttons_caps = [('binfo', contact is not None and not any(
(contact.sms and contact.mobile, self.infoboxmode))),
('bim', caps.IM in c), ('bfiles', caps.FILES in c),
('bemail', caps.EMAIL in c), ('bsms', caps.SMS in c),
('bvideo', caps.VIDEO in c)]
for name, val in buttons_caps:
ctrl = getattr(self, name, None)
if ctrl is not None:
ctrl.Show(ctrl, val, False)
cbar = self.cbar
menu = cbar.overflowmenu
count = menu.spine.items.count
iblock = self.iblock
if caps.BLOCKABLE in c and not count(iblock):
cbar.AddMenuItem(SimpleMenuItem(id=-1))
cbar.AddMenuItem(iblock)
elif not caps.BLOCKABLE in c and count(iblock):
cbar.overflowmenu.RemoveItem(iblock)
if contact is not None:
if contact.blocked:
content = _('Unblock {name}')
else:
content = _('Block {name}')
iblock.content = [content.format(name=contact.name)]
self.set_groupchat_visibility(contact, convo)
i = len(menu.spine.items) - 1
if menu.GetItem(i).id == -1:
menu.RemoveItem(i)
# don't show the dropdown on the right for widgets.
self.cbar.overflowbutton.Show(not getattr(contact, 'iswidget', False))
self._lastcaps = c
cbar.GenWidthRestriction(True)
self.update_add_contact_shown(convo)
self.Parent.Layout()
def update_add_contact_shown(self, convo):
if not hasattr(self, 'iadd'):
return
ischat = convo is not None and convo.ischat
overflow = self.cbar.overflowmenu
if ischat:
if overflow.GetIndex(self.iadd) != -1:
overflow.RemoveItem(self.iadd)
else:
if overflow.GetIndex(self.iadd) == -1:
overflow.InsertItem(overflow.GetIndex(self.ihistory),
self.iadd)
def set_groupchat_visibility(self, contact, convo):
if not hasattr(self, 'bmultichat'):
return
proto = getattr(contact, 'protocol', getattr(convo, 'protocol', None))
groupchat = False
if proto is not None:
groupchat = getattr(proto,
'supports_group_chat', False) and getattr(
contact, 'supports_group_chat', False)
self.bmultichat.Show(groupchat)
@property
def FileMenu(self):
self._filemenu = SimpleMenu(self, self.menuskin)
self.send_file_item = SimpleMenuItem(_('Send File'),
lambda *a: self.OnSendFiles())
# if b and b.online:
self._filemenu.AppendItem(self.send_file_item)
self._filemenu.AppendItem(
SimpleMenuItem(_('Transfer History'),
lambda *a: FileTransferDialog.Display()))
return self._filemenu
# try:
# return self._filemenu
# except AttributeError:
# self._filemenu = self.build_file_menu()
# return self._filemenu
@property
def ActionsBarMenu(self):
try:
return self._actionsbarmenu
except AttributeError:
self._actionsbarmenu = self.build_actionsbar_menu()
return self._actionsbarmenu
def build_actionsbar_menu(self):
m = UMenu(self, onshow=self.update_actionsbar_menu)
c = self._actionsbar_checks = {}
for name, label in [('icons', _('Icons Only')),
('text', _('Text Only')),
('next', _('Icons Next to Text')),
('above', _('Icons Above Text'))]:
def cb(name=name):
with self.Frozen():
setpref(action_icons_key, name)
c[name] = m.AddCheckItem(label, callback=cb)
m.AddSep()
m.AddItem(
_('Hide Actions Bar'),
callback=lambda: setpref('messaging.show_actions_bar', False))
return m
def update_actionsbar_menu(self, menu):
p = pref(action_icons_key)
for name, item in self._actionsbar_checks.iteritems():
item.Check(p == name)
class ComboListEditor(object):
'''
Given an UberCombo and a list of strings, allows the combo to "edit"
the list.
'''
def __init__(self, combo, OnLoseFocus):
self.combo = combo
# the "remove" menu contains every item
menu = combo.menu
self.remove_menu = SimpleMenu(menu,
combo.menuskin,
callback=self.OnRemove)
self.remove_item = SimpleMenuItem(_('Remove'), menu=self.remove_menu)
self.add_item = SimpleMenuItem(_('Add...'), method=self.OnAdd)
self.OnLoseFocus = OnLoseFocus
def SetContentCallback(self, cb):
if not hasattr(cb, '__call__'): raise TypeError
self.content_cb = cb
def EditList(self,
seq,
selected_item=None,
add_cb=None,
remove_cb=None,
default=''):
self.default = default
if add_cb is not None: self.add_cb = add_cb
if remove_cb is not None: self.remove_cb = remove_cb
assert isinstance(seq, list), repr(list)
self.seq = list(seq)
self.menu_items = [SimpleMenuItem(self.content_cb(i)) for i in seq]
self.remove_menu.SetItems(list(self.menu_items))
if selected_item is not None:
self.selection = seq.index(selected_item)
else:
self.selection = -1 if len(seq) == 0 else 0
def Apply(self):
items = list(self.menu_items) # Normal Items
if len(self.menu_items):
items.append(SimpleMenuItem(id=-1)), # ---- a separator
items.append(self.add_item) # Add
if len(self.menu_items):
items.append(
self.remove_item) # Remove (if there are items to remove)
combo = self.combo
combo.SetCallbacks(selection=self.OnComboSelection, value=self.OnValue)
combo.menu.SetItems(items)
newval = self.menu_items[self.selection] if len(
self.menu_items) and self.selection != -1 else self.default
combo.ChangeValue(newval)
def OnComboSelection(self, item):
LOG('OnSelection: %r', item)
self.selection = self.menu_items.index(item)
self.combo.ChangeValue(item)
self.OnLoseFocus()
def GetValue(self):
return self.menu_items[
self.selection].GetContentAsString() if self.selection != -1 else (
None if not self.default else self.default)
def OnAdd(self, item):
'Invoked when the "Add" menu item is clicked.'
self.combo.EditValue('')
def OnValue(self, val):
wx.CallAfter(self.OnValueLater, val)
def OnValueLater(self, val):
# This method is called when the editable part of the combo loses focus.
# - if the combo is on screen, the user hit enter or otherwise caused this to happen.
# in this case, perform validation and display an error dialog if the validation fails
# - otherwise, maybe another app stole focus--some external event cause this to happen
# popping up a modal dialog would be bad, so just return the value to what it was before
if val == '' or not self.combo.IsShown(
) or not self.combo.Top.IsActive():
LOG(
"Val: %s\nCombo is ShownOnScreen: %s\nTop level parent is Active: %s",
val, self.combo.IsShownOnScreen(),
not self.combo.Top.IsActive())
if val == '': LOG('empty string, selection is %s', self.selection)
else:
LOG('combo not on screen, falling back to %s', self.selection)
# Restore the combo's value.
if self.combo.Top.IsActive():
self.OnLoseFocus()
return self.combo.ChangeValue(self.menu_items[
self.selection] if self.selection != -1 else self.default)
val = self.add_cb(val)
if val is None:
self.combo.EditValue()
else:
LOG('add_cb returned True')
self.seq.append(val)
self.menu_items.append(SimpleMenuItem(self.content_cb(val)))
self.remove_menu.AppendItem(SimpleMenuItem(self.content_cb(val)))
self.selection = len(self.menu_items) - 1
self.Apply()
def OnRemove(self, item):
'Invoked when one of the "remove" menu items is clicked.'
i = self.remove_menu.GetItemIndex(item)
assert len(self.menu_items) <= len(self.remove_menu)
if self.remove_cb(self.seq[i]):
LOG('removing item %d (selection is %s)', i, self.selection)
self.seq.pop(i)
self.remove_menu.RemoveItem(i)
self.menu_items.pop(i)
if i == self.selection:
l = len(self.menu_items)
if l:
i = i % len(self.menu_items)
newval = self.menu_items[i]
else:
i = -1
newval = self.default
self.combo.ChangeValue(newval)
elif i < self.selection:
i -= 1
self.selection = i
LOG('now selection is %s', self.selection)
self.Apply()