def Notify(self):
win = self.win
tabs = self.tabs
if wx.IsDestroyed(win):
self.Stop()
return
# (>")>[New IMs]<("<)
if not win.IsActive() and len(tabs):
tabNum = len(tabs)
if self.index >= tabNum:
self.index = 0
tab = tabs[self.index]
if not wx.IsDestroyed(tab):
win.SetTitle('*' + tab.label1)
self.index += 1
else:
tabs.remove(tab)
if self.shouldFlash:
FlashOnce(
win
) # hack until we figure out how to set the title without clearing the notify state
else:
self.Stop()
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 ShowDropMarker(self, dropmarker=None):
'Sets the new dropmarker and shows it.'
if not dropmarker:
if self.dropmarker and not wx.IsDestroyed(self.dropmarker):
self.dropmarker.Show(False)
return
if self.dropmarker and not wx.IsDestroyed(
self.dropmarker) and self.dropmarker is not dropmarker:
self.dropmarker.Show(False)
self.dropmarker = dropmarker
self.dropmarker.Show(True)
def _activateapp(message):
'''
Since windowless menus do not receive capture changed events--we use this as
an indicator to dismiss instead.
'''
is_active = message.data
vlist = None
if "_lastvlist" in dir(MenuListBox):
vlist = MenuListBox._lastvlist()
if vlist is not None and not wx.IsDestroyed(vlist) and not wx.IsDestroyed(
vlist.menu):
if vlist.menu and vlist.menu.Windowless and not is_active:
vlist.DismissRoot()
def WhenStateChange(self, acct, attr, old, new):
"""
When the account state changes this calls everything that sets up the
the elements of the panel and determines whether it shows or hides
"""
# An if self check becasue it's posible the callback could trigger between
# the time the object is destroyed and the observer is removed
account = self.account
#When in the WILL_RECONNECT state, registered to refresh every 1 second
from gui.toolbox.refreshtimer import refreshtimer
if account.offline_reason == OfflineReason.WILL_RECONNECT:
self.reason = lambda: profile.account_manager.state_desc(self.
account)
refreshtimer().Register(self)
else:
self.reason = profile.account_manager.state_desc(
account
) if account.state == ProtocolStatus.OFFLINE and account.offline_reason else _(
account.state)
refreshtimer().UnRegister(self)
self.stateicon = account.statusicon.ResizedSmaller(16)
if not wx.IsDestroyed(self):
self.MakeLink()
self.CalcLayout()
self.Refresh()
#Tells DetermineShow to delay the hide if state changed to ONLINE or OFFLINE
delayed = (account.state == ProtocolStatus.ONLINE) or (
account.state == ProtocolStatus.OFFLINE
and account.offline_reason == OfflineReason.NONE)
self.DetermineShow(delayed)
self.Parent.SelfSize()
self.GrandParent.Parent.Layout()
def on_clear_typing_timer(self):
'''
Called after a set period of time with no typing updates.
'''
if not wx.IsDestroyed(self):
self.on_typing(None)
def on_resize(e=None):
if hasattr(e, 'Skip'):
e.Skip()
if wx.IsDestroyed(self) or not _ad_panel_shown():
return
if _adposition() in ('left', 'right'):
maxw, maxh = AD_PANEL_MAXSIZE_V
cheight = self.ClientSize.height
ad_h = min(maxh, cheight)
if ad_h < maxh:
ad_h -= 2
zoom = float(ad_h) / maxh
ad_w = zoom * maxw
else:
maxw, maxh = AD_PANEL_MAXSIZE_H
cwidth = self.ClientSize.width
ad_w = min(maxw, cwidth)
if ad_w < maxw:
ad_w -= 2 # leave room for border on sides when smaller
zoom = float(ad_w) / maxw
ad_h = zoom * maxh
ad_panel.SetMinSize((ad_w, ad_h))
ad_panel.SetPageZoom(zoom)
ad_panel.Parent.Layout()
ad_panel.Parent.Refresh()
def OnShow(self, e):
'Invoked on EVT_SHOW'
# Don't leave menus stranded if the button is being hidden.
if not e.GetShow() and self.menu and not wx.IsDestroyed(
self.menu) and self.menu.IsShown():
self.menu.Hide()
def SetValue(self, value, default=None):
'Set a new display value. Calling the valuecallback'
assert threading.currentThread().getName() == 'MainThread'
if default != None:
self.defaultvalue = default
self.value = value
valuestring = ''
if isinstance(value, basestring):
valuestring = value
else:
for thing in value.content:
if isinstance(thing, basestring):
valuestring = thing
break
if wx.IsDestroyed(self.txtfld):
return
self.txtfld.SetValue(valuestring)
valuecallback = self.Parent.valuecallback
if valuecallback: wx.CallAfter(valuecallback, valuestring)
self.Refresh(False)
def OnPageTitleUpdated(self, message):
"""
Update the frame and notebook when a convo's name and/or typing status changes
"""
if not self.frame or wx.IsDestroyed(self.frame):
return
imwin, title, window_title = message.data
imwin.SetName(title)
assert getattr(self.frame.notebook, "_name", "") != "[unknown]"
page = None
for mypage in self.frame.notebook.Pages():
if mypage.Content is imwin:
page = mypage
if page is None or page.tab is not self.frame.notebook.ActiveTab:
return
if window_title is not None:
frame_title = window_title
else:
frame_title = title
if self.titletimer.IsRunning():
self.titletimer.title = frame_title
else:
self.frame.SetTitle(frame_title)
def OnStatusChanged(self, src, attr, old, new):
if wx.IsDestroyed(self.window):
log.warning(
"Warning: splash screen is Destroyed but still getting notified."
)
return
if self.cancelling and new != src.Statuses.OFFLINE:
src.disconnect()
if new in (src.Statuses.CONNECTING, src.Statuses.AUTHENTICATING,
src.Statuses.SYNC_PREFS, src.Statuses.AUTHORIZED):
self.window.EnableControls(False, SIGN_IN, False)
def f():
if self.cancelling or new == src.Statuses.OFFLINE:
if self.cancelling:
self.set_status('')
else:
self.set_status(_(src.offline_reason))
self.window.EnableControls(True, SIGN_IN, True)
else:
self.window.EnableControls(False, SIGN_IN)
self.set_status(_(new))
wx.CallAfter(f)
def on_pref_change(src, attr, old, new):
if wx.IsDestroyed(self):
return
build_ad_sizer(_adposition())
ad_panel.update_minsize()
on_resize()
ad_panel.refresh_campaign()
def CallAll(cls, func, *args, **kwargs):
'Calls func(obj, *a, **k) on all live instances of this class.'
import wx
try:
instances = cls._instances
except AttributeError:
return # no instances were created yet.
removeList = []
for wref in instances:
obj = wref()
if obj is not None and not wx.IsDestroyed(obj):
try:
func(obj, *args, **kwargs)
except TypeError:
print type(obj), repr(obj)
raise
else:
removeList.append(wref)
for wref in removeList:
try:
instances.remove(wref)
except ValueError:
pass # weakrefs can go away
def ApplyFrom(self):
fromcombo = self.fromcombo
if wx.IsDestroyed(fromcombo):
return
fromcombo.SetItems(self.from_menu_items)
fromcombo.SetValue(self.from_menu_item)
fromcombo.SetCallbacks(selection=self.OnFromBuddySelected, value=None)
def update(self):
try:
with self.view.Frozen():
self.view.Enabled = self.model.enabled
self.view.Value = self.model.checked
except Exception:
if not wx.IsDestroyed(self.view):
raise
def ApplyTo(self):
tocombo = self.tocombo
if wx.IsDestroyed(tocombo) or self.ischat:
return
tocombo.SetCallbacks(selection=self.OnToBuddySelected, value=None)
tocombo.SetItems(self.to_menu_items)
tocombo.SetValue(self.to_menu_item)
def update(self):
try:
# print 'syncing', self.model.enabled, self.model.value
with self.view.Frozen():
self.view.Enabled = self.model.enabled
self.view.Value = self.model.value
except Exception:
if not wx.IsDestroyed(self.view):
raise
def IsShown(self):
if not self.popup or wx.IsDestroyed(self.popup):
return False
try:
return self.popup.IsShown()
except AttributeError:
#TODO: how do we know if a native menu is being shown?
return False
def get_exc_dialog():
diag = getattr(sys, 'exc_dialog', None)
if diag is not None:
import wx
if wx.IsDestroyed(diag):
diag = None
if diag is None:
import gui.tracebackdialog
diag = sys.exc_dialog = gui.tracebackdialog.ErrorDialog()
return diag
def build_ad_sizer(adpos=None, layout_now=True):
if wx.IsDestroyed(self):
return
enabled = _adsenabled()
if adpos is None:
adpos = _adposition()
with self.Frozen():
self.SetSizer(None)
if not enabled:
minsize = IMFRAME_MINSIZE
elif adpos in ('left', 'right'):
minsize = IMFRAME_WITH_AD_MINSIZE_V
else:
minsize = IMFRAME_WITH_AD_MINSIZE_H
self.SetMinSize(minsize)
if enabled:
ad_panel.Show()
if not enabled:
ad_panel.Hide()
sz = wx.BoxSizer(wx.VERTICAL)
sz.Add(mainPanel, 1, wx.EXPAND)
elif adpos == 'top':
sz = wx.BoxSizer(wx.VERTICAL)
sz.Add((borderSize, borderSize)) # + (0 if glass() else 7)))
sz.Add(ad_panel, 0, wx.ALIGN_CENTER_HORIZONTAL)
sz.Add((borderSize, borderSize + extra_top))
sz.Add(mainPanel, 1, wx.EXPAND)
elif adpos == 'left':
sz = wx.BoxSizer(wx.HORIZONTAL)
sz.Add((extra_horizontal, 1))
sz.Add(ad_panel, 0, wx.ALIGN_CENTER_VERTICAL)
sz.Add((horiz_padding, 1))
sz.Add(mainPanel, 1, wx.EXPAND)
elif adpos == 'right':
sz = wx.BoxSizer(wx.HORIZONTAL)
sz.Add(mainPanel, 1, wx.EXPAND)
sz.Add((horiz_padding, borderSize))
sz.Add(ad_panel, 0, wx.ALIGN_CENTER_VERTICAL)
sz.Add((extra_horizontal, 1))
else: # == 'bottom':
sz = wx.BoxSizer(wx.VERTICAL)
sz.Add(mainPanel, 1, wx.EXPAND)
sz.Add((borderSize, borderSize + extra_top))
sz.Add(ad_panel, 0, wx.ALIGN_CENTER_HORIZONTAL)
sz.Add((borderSize, borderSize)) # + (0 if glass() else 7)))
self.SetSizer(sz)
if layout_now:
self.Layout()
def dismiss_old(self):
'Dismiss any currently visible root skinned UMenu.'
menuref = UMenu.last_menu
if menuref is None: return
menu = menuref()
if menu is not None and not wx.IsDestroyed(menu):
menu.Dismiss()
UMenu.last_menu = None
def update_count(self):
if wx.IsDestroyed(self):
print 'error: update_count still being called'
else:
if self.model.offline:
count = 0
elif self.show_pending:
count = self.model.length_including_pending
else:
count = self.model.length
self.SetItemCount(count)
self.RefreshAll()
def check_focus():
if wx.IsDestroyed(self):
return
is_foreground = self.Top.IsForegroundWindow()
rotater.has_focus = is_foreground and not self.IsIconized()
if rotater.has_focus:
if not self._did_show_ad:
self._did_show_ad = True
rotater.on_reload()
else:
rotater.trigger_event('focus')
def on_data_changed(self, *args):
'Invoked when the observable data list changes.'
if wx.IsDestroyed(self):
return
with self.Frozen():
sz = self.Sizer
rows = self.rows
oldrowcount = len(rows)
scrolly = self.GetScrollPos(wx.VERTICAL)
dataset = oset(self.data)
prevset = oset(row.data for row in rows)
oldset = prevset - dataset
newset = dataset - prevset
for i_, row in list(enumerate(rows)):
sz.Detach(row)
if row.data in oldset:
if i_ == self.Hovered:
self._hovered = -1
rows.remove(row)
row.ReleaseAllCapture()
row.on_close()
row.Destroy()
# Create a new row control for each data element, and add it to
# sizer.
for elem in newset:
control = self.row_control(self, elem)
rows.append(control)
idxs = {}
for i, d in enumerate(self.data):
idxs[d] = i
rows.sort(key=lambda r: idxs.get(r.data))
for row in rows:
sz.Add(row, *self.sizer_args)
self.Layout()
# Restore the old scroll position.
newrowcount = len(rows)
if oldrowcount != 0 and oldrowcount != newrowcount:
self.SetupScrolling(False, True, *self.scroll_sizes)
# on MSW, scrolling immediately doesn't work.
wx.CallAfter(self.Scroll, 0, scrolly)
def DoUpdateSkin(self, skin):
self.skinCML = skin
frame = self._frame
framesizer = frame.GetSizer()
if framesizer and not wx.IsDestroyed(framesizer):
frame.Sizer.Clear()
frame.SetSizer(skin["framesize"].Sizer(self))
self._lastSkinChange = default_timer()
def UpdateSkin(self):
'Updates frame size margins.'
s = self.skin = self.vlist.menu.skin
try:
if self.Sizer and not wx.IsDestroyed(self.Sizer):
self.Sizer.Clear()
except wx.PyDeadObjectError:
return
self.framesize = s.get('framesize', skin.ZeroMargins)
self.Sizer = self.framesize.Sizer(self.vlist)
self.bg = s.frame
def OnPageIconUpdated(self, message):
"""
Update the notebook when a convo's icon changes.
"""
page, icon = message.data
if not self.frame or wx.IsDestroyed(self.frame):
return
assert getattr(self.frame.notebook, "_name", "") != "[unknown]"
for mypage in self.frame.notebook.Pages():
# TODO: on windows, this comparison will never be True because
# we are comparing Pages and ImWinPanels.
if mypage == page and self.frame.notebook.ActiveTab == mypage.tab:
self.frame.SetFrameIcon(icon)
def update(self):
try:
# print 'syncing', self.model.enabled, self.model.selection, self.values[:]
with self.view.Frozen():
self.view.Enabled = self.model.enabled
self.view.Items = [val[1] for val in self.model.values]
self.view.SetSelection(self.model.selection)
#hack a size(?) event, roughly equivalent to the C function
# implementation of UpdateVisibleHeight()
#forces the list to not have a scrollbar (at least when going
# from 4 to 5 items)
self.view.Size = self.view.Size
except Exception:
if not wx.IsDestroyed(self.view):
raise
def SetItems(self, items):
'Set the menu to a list of items.'
if wx.IsDestroyed(self):
print >> sys.stderr, "WARNING: %r is destroyed" % self
return
with self.Frozen():
sp = self.spine
sp.items = items
sp.ItemCount = len(items)
if sp.IsShownOnScreen():
sp.RefreshAll()
def on_data_changed(self, src, *a):
'Invoked when the data object this row represents changes.'
if not self:
objget = lambda x: object.__getattribute__(self, x)
log.error(
'%r object has been deleted.',
objget('__class__'),
) #objget('data'))
if wx.IsDestroyed(self):
return self._cleanup()
with self.Frozen():
self.PopulateControls(self.data)
self.Refresh()
