コード例 #1
0
ファイル: imtabs.py プロジェクト: sgricci/digsby
class TitleBarTimer(wx.Timer):
    '''
    Manages titles of tab and window titles for conversations.

    Shows flashing strings like (New IM) and (5 New IMs).
    '''

    shouldFlash = prefprop('conversation_window.notify_flash')
    cyclePause = prefprop('conversation_window.unread_cycle_pause')

    def __init__(self, win, tabs):

        wx.Timer.__init__(self)

        self.win = win
        self.tabs = tabs
        self.index = 0

    def Start(self):
        self.title = self.win.Title

        wx.Timer.Start(self, self.cyclePause)

    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 Stop(self):
        wx.Timer.Stop(self)
        if not wx.IsDestroyed(self.win):
            self.win.SetTitle(self.title)
        self.index = 0
コード例 #2
0
class FakeProtocol(common.protocol):

    name = 'fake'
    NUM_BUDDIES = common.prefprop('fake.num_buddies', default=20)

    def __init__(self, username, password, hub, server=None, **options):
        common.protocol.__init__(self, username, password, hub)

        self.root_group = Group('Root', self, 'Root')
        self.buddies = ObservableDict()
        self.self_buddy = FakeBuddy('self', self)
        self.buddies['self'] = self.self_buddy
        self.conversations = {}

    def Connect(self, invisible=False):
        self.change_state(self.Statuses.ONLINE)
        g1 = Group('Foo', self, 'Foo')
        g2 = Group('Bar', self, 'Bar')
        self.buddies['foobar'] = FakeBuddy('foobar', self)
        #g1.append(Contact(self.buddies['foobar'], 'foobar'))
        self.root_group.append(g1)
        self.root_group.append(g2)

        for i in range(int(self.NUM_BUDDIES)):
            g = random.choice((g1, g2))
            buddy = FakeBuddy('FakeBuddy #%d' % (i % 3), self)
            buddy.status = random.choice(('away', 'available', 'offline'))
            g.append(buddy)

        self.root_group.notify()

    #needs to be added to Protocol NotImplemented
    def set_message(self, message, status, format=None, default_status='away'):
        pass

    #needs to be added to Protocol NotImplemented
    def set_buddy_icon(self, icondata):
        pass

    def Disconnect(self):
        self.change_state(self.Statuses.OFFLINE)

    @property
    def caps(self):
        return []

    def convo_for(self, contact):
        try:
            return self.conversations[contact.id]
        except KeyError:
            c = FakeConversation(self)
            self.conversations[contact.id] = c
            return c

    def incomming_message(self, buddy, message):
        self.conversations.values()[0].received_message(buddy, message)
コード例 #3
0
ファイル: adiummsgstyles.py プロジェクト: sgricci/digsby
            attrs = self.magicattrs
        except AttributeError:
            self.setup_string_substitution()
            attrs = self.magicattrs

        try:
            try:
                return attrs[attr](m, b) if args is None else attrs[attr](m, b,
                                                                          args)
            except KeyError:
                return extra[attr]
        except Exception:
            #print_exc() #uncomment me to find out why there are %strayvariables% in your HTML
            return '%' + attr + '%'

    show_tstamp = prefprop('conversation_window.timestamp', True)
    tstamp_fmt = prefprop('conversation_window.timestamp_format', '%#I:%M')

    def setup_string_substitution(self):
        # TODO: this should probably be done once, at the class level...not in a function

        icon = get_buddy_icon_url

        def strf(t, fmt=None):
            if not self.show_tstamp and not self.should_always_show_timestamp:
                return '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'

            fmt = self.tstamp_fmt if fmt is None else fmt

            for s, repl in strftime_replacements:
                fmt = fmt.replace(s, repl)
コード例 #4
0
ファイル: iminput.py プロジェクト: sgricci/digsby
class IMInput(FormattedInput, FormatPrefsMixin, SplitterEventMixin):
    def __init__(
        self,
        parent,
        value='',
        autosize=True,
        formatOptions=None,
        multiFormat=True,
        showFormattingBar=True,
        rtl=False,
        skin=None,
        entercallback=None,
        validator=wx.DefaultValidator,
    ):

        FormattedInput.__init__(self,
                                parent,
                                value=value,
                                autosize=autosize,
                                formatOptions=formatOptions,
                                multiFormat=multiFormat,
                                showFormattingBar=showFormattingBar,
                                rtl=rtl,
                                skin=skin,
                                validator=validator)

        self.LoadStyle('messaging.default_style')

        self.entercallback = entercallback

        self.tc.Bind(wx.EVT_KEY_DOWN, self.OnEnterKey)

        self.sendbutton = None
        if self.showSendButton:
            self.CreateSendButton()

    def ShowSendButton(self, show):
        sendbutton = self.sendbutton
        hasSendButton = sendbutton is not None

        if hasSendButton:
            self.spacer.Show(show)
            sendbutton.Show(show)
        elif show:
            self.CreateSendButton()

        self.Layout()

    def CreateSendButton(self):

        self.spacer = SpacerPanel(self, skinkey='inputspacer')
        self.inputsizer.Add(self.spacer, 0, wx.EXPAND)

        sendbutton = self.sendbutton = UberButton(
            self, label=_('Send'),
            skin='InputButton')  #wx.Button(self, label = _('Send'))
        self.inputsizer.Add(sendbutton, 0, wx.EXPAND)
        sendbutton.Bind(wx.EVT_BUTTON, lambda e: self.entercallback(self))

    shiftToSend = prefprop("messaging.shift_to_send", False)
    showSendButton = prefprop("messaging.show_send_button", False)

    def OnEnterKey(self, event):
        """
            This detects key presses, runs entercallback if enter or return is pressed
            Any other key continues as normal, then refreshes the font and size info
        """
        keycode = event.KeyCode

        shiftToSend = self.shiftToSend
        hasModifiers = event.HasModifiers()
        shiftIsDown = event.Modifiers == wx.MOD_SHIFT

        if keycode in (wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER):
            # if there is a enter callback and no modifiers are down or if
            # shift should send and shift is down, call the callback
            if self.entercallback and \
                    (not (shiftToSend or hasModifiers or shiftIsDown) or \
                     (shiftToSend and shiftIsDown)):
                return self.entercallback(self)

        event.Skip()
コード例 #5
0
ファイル: toaststack.py プロジェクト: sgricci/digsby
class PopupStack(list):
    'A popup stack is in charge of positioning popups for one corner of a display.'

    def __init__(self, monitor, position, padding=None, border=None):

        self.monitor = monitor

        self.corner = position
        assert position in valid_corners, position

        if padding is None:
            padding = (0, 10)
        if border is None:
            border = (10, 10)

        self.padding = Point(*padding)
        self.border = Point(*border)

        self.NextRect = self.Down if TOP & self.corner else self.Up
        self.OppositeRect = self.Up if TOP & self.corner else self.Down

    def __repr__(self):
        return '<PopupStack %s monitor %d (%d popups)>' % (alignment_to_string(
            self.corner), self.monitor, len(self))

    @property
    def ScreenRect(self):
        return screenArea(self.monitor)

    offset = prefprop('notifications.popups.offset', (0, 0))

    def Up(self, prevRect, newSize, user_action):
        border, padding = self.border, self.padding

        if prevRect is None:
            if LEFT & self.corner:
                pt = self.ScreenRect.BottomLeft + (border.x + padding.x +
                                                   self.offset[0],
                                                   -border.y - self.offset[1])
            else:
                pt = self.ScreenRect.BottomRight - (newSize.width + border.x +
                                                    padding.x + self.offset[0],
                                                    border.y + self.offset[1])
        else:
            pt = prevRect.TopLeft - Point(0, border.y + padding.y)

        r = RectPS(pt - Point(0, newSize.height), newSize)
        if AVOID_MOUSE and not user_action and r.Contains(GetMousePosition()):
            r.y -= r.Bottom - GetMousePosition().y + AVOID_MOUSE_PIXELS

        return r

    def Down(self, prevRect, newSize, user_action):
        border, padding = self.border, self.padding

        if prevRect is None:
            if LEFT & self.corner:
                pt = self.ScreenRect.TopLeft + (border.x + padding.x +
                                                self.offset[0],
                                                border.y + self.offset[1])
            else:
                pt = self.ScreenRect.TopRight - (newSize.width + border.x +
                                                 padding.x + self.offset[0],
                                                 -border.y - self.offset[1])
        else:
            pt = prevRect.BottomLeft + Point(0, border.y + padding.y)

        r = RectPS(pt, newSize)

        if AVOID_MOUSE and not user_action and r.Contains(GetMousePosition()):
            r.y += GetMousePosition().y - r.y + AVOID_MOUSE_PIXELS

        return r

    def InitialPos(self, size):
        return self.NextRect(None, size).Position

    def Add(self, popup):
        assert popup not in self
        self.append(popup)
        popup.OnClose += lambda userClose: self.Remove(popup,
                                                       user_action=userClose)
        self.DoPositions(popup)
        popup._infader = fadein(popup, 0, popup.opacity_normal, 30)

    def Remove(self, popup, user_action=False):
        try:
            self.remove(popup)
        except ValueError:
            pass
        self.DoPositions(user_action=user_action)

    def DoPositions(self, paging=None, user_action=False):
        prevRect = None

        for popup in self[:]:
            try:
                oldrect = popup.Rect
            except wx.PyDeadObjectError:
                self.remove(popup)
                log.critical('dead Popup object in %r' % self)
                continue

            quick = False
            desired = popup.DesiredSize

            if popup.Hover or popup.has_focus:
                rect = RectPS(popup.Position, desired)

                # if the popup is in one of the bottom corners and it's
                # expanding, keep the bottom of its rectangle in the same
                # place since that's where the interactable GUI is
                if paging is popup and BOTTOM & self.corner:
                    rect.y -= rect.height - oldrect.height
            else:
                rect = self.NextRect(prevRect,
                                     desired,
                                     user_action=user_action)

            popup._moved = True

            self.SetPopupRect(popup, rect, quick=paging is popup)
            prevRect = rect

    slidetime = prefprop('notifications.popups.slide_ms', 140)

    def SetPopupRect(self, popup, rect, quick=False):
        t = int(self.slidetime)
        if t == 0: quick = True

        oldrect = popup.Rect

        if quick:
            popup.SetRect(rect)
        else:
            if oldrect.Size != rect.Size:
                popup.SetRect(wx.RectPS(oldrect.Position, rect.Size))

            move_smoothly(popup, rect.Position, time=t)
コード例 #6
0
ファイル: renderers.py プロジェクト: sgricci/digsby
class GroupCellRenderer(Renderer):
    def __init__( self, parent ):
        Renderer.__init__(self, parent)

        layout_attrs = '''
        name_font_face
        name_font_size
        padding
        '''.strip().split()

        do(self.attrlink(attr) for attr in layout_attrs)

        self.UpdateSkin()

    def UpdateSkin(self):
        Renderer.UpdateSkin(self)
        s = self.skin

        s.margins          = skin.get('BuddiesPanel.GroupMargins')
        s.padding          = skin.get('BuddiesPanel.GroupPadding', lambda: Point(4,4))

        # Expanded/Collapsed icons next to group names
        g = lambda k, default = sentinel: skin.get('BuddiesPanel.GroupIcons.' + k, default)
        s.expanded         = g('Expanded',         lambda: None)
        s.expandedhover    = g('ExpandedHover',    lambda: s.expanded)
        s.expandedselected = g('ExpandedSelected', lambda: s.expanded)

        s.collapsed         = g('Collapsed',         lambda: None)
        s.collapsedhover    = g('CollapsedHover',    s.collapsed)
        s.collapsedselected = g('CollapsedSelected', s.collapsed)

        # Group backgrounds (default to Buddy backgrounds if not specified)
        g = lambda k, default: skin.get('BuddiesPanel.Backgrounds.' + k, default)
        s.bg         = g('Group',         lambda: g('Buddy'))
        s.hoverbg    = g('GroupHover',    lambda: g('BuddyHover'))
        s.selectedbg = g('GroupSelected', lambda: g('BuddySelected'))

        # Group font colors (default to Buddy font colors if not specified)
        f = s.fontcolors
        g = lambda k, default: skin.get('BuddiesPanel.FontColors.' + k, default)
        f.group         = g('Group',         lambda: g('Buddy',         lambda: syscol(wx.SYS_COLOUR_WINDOWTEXT)))
        f.grouphover    = g('GroupHover',    lambda: g('BuddyHover',    lambda: syscol(wx.SYS_COLOUR_WINDOWTEXT)))
        f.groupselected = g('GroupSelected', lambda: g('BuddySelected', lambda: syscol(wx.SYS_COLOUR_HIGHLIGHTTEXT)))

        self.calcsizes()

    def item_height( self, obj ):
        return int(self.group_height)

    def calcsizes(self):
        p = self.getpref
        margins = self.skin.margins
        padding = self.skin.padding

        # Main Font: contact's name
        self.mainfont        = safefont(p('name_font_face', None), try_this(lambda: int(p('name_font_size')), 10))
        self.mainfont_height = self.mainfont.LineHeight

        # group_height is reported via OnMeasureItem to VListBox
        self.group_height = int(self.mainfont_height) + margins.top + margins.bottom + (padding.y * 2)

        self.depth_indent = p('indent', 5)

    font_face    = prefprop('buddylist.layout.name_font_face', None)
    font_size    = prefprop('buddylist.layout.name_font_size', None)
    group_indent = prefprop('buddylist.layout.indent', 0)

    def Draw( self, dc, rect, selected, obj, depth, expanded, index, hover ):
        s = self.skin

        # apply margins
        rect = rect.AddMargins(wx.Rect(*s.margins)).AddMargins(wx.Rect(0, s.padding.y, 0, s.padding.y))

        # Group font is drawn with the same as the buddies.
        fontface = self.font_face
        font = safefont(fontface, try_this(lambda: int(self.font_size), 10), bold = True)
        dc.SetFont( font )

        # indent for depth
        rect = rect.Subtract(left = self.group_indent * depth)

        # Expander triangles.
        if isiterable( obj ):
            triangle = self.get_expander(selected, expanded, hover)

            if triangle is not None:
                dc.DrawBitmap(triangle, rect.x, rect.VCenter(triangle), True)
                rect = rect.Subtract(left = triangle.Width + s.padding.x)

        # decide on a foreground text color
        if selected: fg = s.fontcolors.groupselected
        elif hover:  fg = s.fontcolors.grouphover
        else:        fg = s.fontcolors.group
        dc.SetTextForeground( fg )

        # the actual text label
        dc.DrawTruncatedText(obj.display_string, rect, alignment = lmiddle)

    def get_expander(self, selected, expanded, hover):
        iconname = 'expanded' if expanded else 'collapsed'
        if selected: iconname += 'selected'
        elif hover:  iconname += 'hover'
        return getattr(self.skin, iconname, None)
コード例 #7
0
ファイル: adiummsgstyles.py プロジェクト: AlexUlrich/digsby
        try:
            attrs = self.magicattrs
        except AttributeError:
            self.setup_string_substitution()
            attrs = self.magicattrs

        try:
            try:
                return attrs[attr](m, b) if args is None else attrs[attr](m, b, args)
            except KeyError:
                return extra[attr]
        except Exception:
            #print_exc() #uncomment me to find out why there are %strayvariables% in your HTML
            return '%' + attr + '%'

    show_tstamp = prefprop('conversation_window.timestamp', True)
    tstamp_fmt  = prefprop('conversation_window.timestamp_format', '%#I:%M')

    def setup_string_substitution(self):
        # TODO: this should probably be done once, at the class level...not in a function

        icon = get_buddy_icon_url

        def strf(t, fmt = None):
            if not self.show_tstamp and not self.should_always_show_timestamp:
                return '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'

            fmt = self.tstamp_fmt if fmt is None else fmt

            for s, repl in strftime_replacements:
                fmt = fmt.replace(s, repl)
コード例 #8
0
class TabBar(SimplePanel, UberWidget):
    """
        Where the tabs live, handles all display and organization functionality
    """
    def __init__(self, parent, skinkey):
        SimplePanel.__init__(self, parent)

        self.tabs     = [] # a list of all the tabs
        self.rows     = [] # a list of all the visible row, each a list of all the tabs in that row
        self.rowindex = 0  # the first visible row
        self.tabindex = 0  # the first tab of the first visible row
        self.tabendex = 0  # the last tab of the last visible row

        events = [(wx.EVT_PAINT, self.OnPaint),
                  (wx.EVT_SIZE, self.OnSize),
                  (wx.EVT_BUTTON, self.OnButton),
                  (wx.EVT_MOUSEWHEEL, self.OnWheel),
                  (wx.EVT_MOTION,self.OnMotion)]

        for event, method in events: self.Bind(event, method)


        self.flagedrows = set()
        self.lastsize=self.Size

        self.rowheight=0#height of a row in pixels

        self.SetSkinKey(skinkey,True)

        #buttons for verticle alignment
        self.cupb = UberButton(self, CUPID, skin=self.scrollbuttonskin, icon=self.upicon)
        self.cupb.Show(False)

        self.cdownb = UberButton(self, CDOWNID, skin=self.scrollbuttonskin, icon=self.downicon)
        self.cdownb.Show(False)

        #the navigation box
        self.navi=Navi(self)


        self.dragorigin = None#when draging the tab that you are dragging
        self.dragtarget = None#when dragging the mouse is over and at that point released on

        # the arrow image shown when dragging tabs
        self.dropmarker=OverlayImage(self, self.dropmarkerimage)

        # self.dropmarker = Storage(Show = lambda v=True: None)
        self.dragside=None#was the tab droped on the left or right of the target tab

        #linking prefs
        link = profile.prefs.link #@UndefinedVariable
        link('tabs.rows',      self.Generate, False)
        link('tabs.tabbar_x',  self.Generate, False)
        link('tabs.hide_at_1', self.Generate, False)
        link('tabs.side_tabs', self.SkinRedirect, False)

        self.Top.Bind(wx.EVT_MENU, self.OnMenuEvent)

    side_tabs = prefprop('tabs.side_tabs')
    tab_rows = prefprop('tabs.rows', 2)

    def UpdateSkin(self):
        key = self.tabskin = self.skinkey
        g   = lambda k, default = sentinel: skin.get(key + '.' + k, default)
        sg   = lambda k, default = sentinel: skin.get('side' + key + '.' + k, default)

        elems = (('spacing', 'spacing',          2),
                 ('bg', 'backgrounds.bar'),
                 ('dropmarkerimage', 'dropmarker.image'),
#                 ('dropmarkeroverlay', 'dropmarker.overlay', 0),
                 ('dropmarkeroffset', 'dropmarker.offset', 0),
                 ('closebuttonskin', 'closebuttonskin', ''),
                 ('closeicon', 'icons.close', None),
                 ('scrollbuttonskin', 'scrollbuttonskin', ''),
                 ('lefticon', 'icons.left', ''),
                 ('righticon', 'icons.right', ''),
                 ('upicon', 'icons.up', ''),
                 ('downicon', 'icons.down', ''))

        for elem in elems:
            setattr(self, 'top' + elem[0], g(*elem[1:]))
            setattr(self, 'side' + elem[0], sg(elem[1],getattr(self,'top' + elem[0])))
            setattr(self, elem[0], getattr(self, ('side' if self.side_tabs else 'top') + elem[0]))


        if hasattr(self,'dropmarker'):
            self.dropmarker.SetImage(self.dropmarkerimage)
            self.dropmarker.SetRotation((self.side_tabs and not self.dropmarkerimage))

        navi = getattr(self, 'navi', None)
        if navi is not None:
            self.cdownb.SetSkinKey(self.scrollbuttonskin)
            self.cupb.SetSkinKey(self.scrollbuttonskin)
            self.cdownb.SetIcon(self.downicon)
            self.cupb.SetIcon(self.upicon)

            self.navi.closebutton.SetSkinKey(self.closebuttonskin)

            self.navi.closebutton.SetIcon(self.closeicon)

            scrollskin = self.scrollbuttonskin

            navi.prevb.SetSkinKey(scrollskin)
            navi.nextb.SetSkinKey(scrollskin)
            navi.upb.SetSkinKey(scrollskin)
            navi.downb.SetSkinKey(scrollskin)

            navi.prevb.SetIcon(self.lefticon)
            navi.nextb.SetIcon(self.righticon)
            navi.upb.SetIcon(self.upicon)
            navi.downb.SetIcon(self.downicon)

        wx.CallAfter(self.Generate)


    def SkinRedirect(self,val=None):
        elems = ('spacing',
                 'bg',
                 'dropmarkerimage',
                 #'dropmarkeroverlay',
                 'closebuttonskin',
                 'closeicon',
                 'scrollbuttonskin',
                 'lefticon',
                 'righticon',
                 'upicon',
                 'downicon'
                 )

        for elem in elems:
            setattr(self, elem, getattr(self,('side' if self.side_tabs else 'top') + elem))

        self.UpdateChildSkins()

    def UpdateChildSkins(self):
        self.cdownb.SetSkinKey(self.scrollbuttonskin,True)
        self.cupb.SetSkinKey(self.scrollbuttonskin,True)

        navi, sbs = self.navi, self.scrollbuttonskin
        navi.closebutton.SetSkinKey(self.closebuttonskin,True)
        navi.prevb.SetSkinKey(sbs, True)
        navi.nextb.SetSkinKey(sbs, True)
        navi.upb.SetSkinKey(sbs, True)
        navi.downb.SetSkinKey(sbs, True)

        self.UpdateChildrenIcons()

        for tab in self.tabs:
            tab.UpdateMode()

        self.Generate()

    def __repr__(self):
        return '<TabBar %r>' % self.tabs

    def OnDragStart(self, tab):
        'Catches the tab drag event and starts the tab dragging system.'

        self.NotifyDrag(tab)

    def OnMotion(self,event):
        'Positioning updates during drag and drop'

        if event.LeftIsDown() and (self.dragorigin or self.Manager.source):
            self.DragCalc(event.Position)

    def __getitem__(self, index):
        return self.tabs[index]

    def OnPaint(self, event):
        dc   = wx.PaintDC(self)
        rect = RectS(self.Size)
        if not self.side_tabs:
            rcount = min(len(self.rows), pref('tabs.rows', 2))
            height = self.tabs[0].Size.height

            y=0
            for unused_i in xrange(rcount):
                self.bg.Draw(dc, Rect(rect.x, y, rect.width, height))
                y += height

        else:
            self.bg.Draw(dc,rect)

    def Add(self, page, focus, resort = True):
        """
            Adds a tab to the bar.  Should only be used by parent NoteBook.
            page - page in PageContainer the tab is to be associated with
            focus - whether that tab should steal focus from current tab
        """
        tab = Tab(self, page, skinkey = self.tabskin)
        tab.Bind(wx.EVT_CONTEXT_MENU, self.ShowMenu)
        tab.Show(False)
        self.tabs.append(tab)

        if focus:
            wx.CallAfter(tab.SetActive, True)

        elif resort:
            if self.side_tabs:
                self.ReVgenerate()
            else:
                self.Regenerate(True)

        return tab

    def ShowMenu(self, e):
        self._menutab = e.EventObject

        try:
            menu = self._tabmenu
        except AttributeError:
            from gui.uberwidgets.umenu import UMenu
            menu = self._tabmenu = UMenu(self)
            menu.AddItem('Close &Other Tabs', id = CLOSE_OTHER_TABS)
            menu.AddSep()
            menu.AddItem('&Close Tab', id = CLOSE_TAB)

        menu.PopupMenu()

    def OnMenuEvent(self, e):
        '''Invoked when a tab context menu item is clicked.'''

        if e.Id == CLOSE_TAB:
            self._menutab.CloseTab()
        elif e.Id == CLOSE_OTHER_TABS:
            menutab = self._menutab

            # switch to that tab first
            menutab.active = True

            with self.Frozen():
                for tab in self.tabs[:]:
                    if tab is not menutab:
                        tab.CloseTab()
        else:
            e.Skip()

    def Generate(self, val=None):
        self.navi.closebutton.Show(pref('tabs.tabbar_x', False))

        if self.side_tabs:
            self.ReVgenerate(True)
        else:
            self.Regenerate()

    def ReVgenerate(self,total=False, safe=False, dotoggle=True):
        """
        It's like Doo... err.. Regenerate, only vertical
        """

#        print "Starting: Regenerate",self.Top.Title,'\n'#,'='*80,'\n','\n'.join(format_stack())
#        print '='*80

        #TODO: Should we be careful about the tab leaving the bar?
        tabs = self.tabs

        if not tabs: return

        do(tab.Show(False) for tab in self.tabs)
        for tab in self.tabs: tab.row = None
        del self.rows[:]

        # Safty precautions prevent list access errors
        if self.tabindex < 0 or self.tabindex >= len(tabs):
            self.tabindex = 0

        # Preset variables
        n = self.tabindex   # the first tab shown
        self.rowheight = tabs[0].GetMinHeight()
        area = self.Notebook.Size.height - 32 # Height in pixels of the tabbar

        # number of fully visible rows in the given area at the given height
        i = area//self.rowheight

        count = len(tabs)

        #one tab per row
        for r in xrange(count): tabs[r].row=r

        rows = self.rows
        size = self.Size

        #Sets navimode and position
        navi = self.navi
        navi.ShowNav(4)
        navi.Hide()
        navi.Position = wx.Point(size.width - navi.Size.width,0)

        # Totally reconstructs the list if it's told to or there are not tabs in the rows or
        # if there isn't one more tab than there is room for and there is enough room to fit
        # them all and number of tabs in the row equals the number of tabs
        if total or not rows or (i + 1 != len(rows[0])) and not (i > len(rows[0])) and len(rows[0]) == len(tabs):
            rows.append([])
            col = rows[0]

            #if all tabs fit
            if i >= count:
                n=0
                self.tabindex=0
                do(col.append(tab) for tab in tabs)
                av=col[0].MinSize.height
            #calculate and show range
            else:
                for t in xrange(n,n+i+1):
                    if t < len(tabs):col.append(tabs[t])

                # populate with earlier stuff
                while len(col) < i and n > 0:
                    n-=1
                    col.insert(0,tabs[n])

                if col: av = col[0].MinSize.height
        else:
            #just leave the new values the same as the old
            col = rows[0]
            av  = col[0].MinSize.height

        # Show all tabs in the bar
        count = 16
        for t in col:
            t.Size = (self.Size.width,av)
            t.Position = (0,count)
            count += av
            t.Show()

        self.tabindex=n
        endex = self.tabendex=n+len(col)

        if dotoggle:
            self.Toggle()

        cupb, cdownb = self.cupb, self.cdownb


        cupb.Enable(self.tabindex != 0)
        cdownb.Enable(endex < len(tabs) or tabs[endex - 1].Position.y +
                           tabs[endex-1].Size.height > size.height - 16)


        self.UpdateNotify()

    def Regenerate(self, safe = False, dotoggle=True):
        '''
        Regenerates layout information.

        safe is a flag to indicate if we should try to keep the currently active
        tab in view at all times. (This doesn't occur when scrolling, for
        instance.)
        '''

#        print "Starting: Regenerate",self.Top.Title,'\n','='*80,'\n','\n'.join(format_stack())
#        print '='*80
        # early exit for when the tabbar isn't visible.
        if not self.IsShown() and len(self.tabs) == 1:
            return

        with self.Frozen():
            self._Regenerate(safe = safe, dotoggle = dotoggle)

        self.Refresh(False)

    def _Regenerate(self, safe = False, dotoggle = True):
        self.cupb.Show(False)
        self.cdownb.Show(False)
        parentpage = self.Parent.pagecontainer

        # style is the number of rows (or 0 for single)
        style = self.tab_rows

        # Should we be careful about the tab leaving the bar?
        careful = not safe and parentpage.active

        # Hide all tabs preparation for refilling
        for tab in self.tabs:
            tab.Show(False)
            tab.row = None
        del self.rows[:]

        # navi set up, see if arrows are needed and placement
        tally = sum(tab.MinSize.width for tab in self.tabs) #total size of tabs

        navi = self.navi
        tabs = self.tabs
        rows = self.rows

        if not tabs: return

        # Tab alignment calculations

        # Saftey precautions prevent list access errors
        if self.tabindex < 0 or self.tabindex >= len(tabs):
            self.tabindex = 0

        # Preset variables
        n = self.tabindex   # the first tab shown
        i = n
        row = 0
        self.rowheight = tabs[0].MinHeight


        my_w, nav_w = self.Size.width, navi.Size.width

        # Decide what kind of navigation panel, if any, to use...
        if tally >= my_w - nav_w and not style:
            navi.ShowNav(1) # arrows left and right
        elif tally >= (my_w - nav_w):
            navi.ShowNav(3) # arrows up and down next to the X
        else:
            navi.ShowNav(0)

        #Where to put navigation panel.
        navi.Freeze()
        navi.Show(True)
        navi.Fit()
        navi.Position = wx.Point(self.Size.width-navi.Size.width,0)
        navi.Size = wx.Size(-1,self.Size.height)
        navi.Thaw()

        #More preparing vars
        area = self.Notebook.Size.width - navi.Size.width

        #While more tabs are not in a row
        while len(tabs) > i:
            tally = tabs[i].MinSize.width
            rows.append([])

            # Loop through each visible tab, fitting tabs on the right.
            while i < len(tabs) and tally < area:
                i += 1
                if i < len(tabs):
                    tally += tabs[i].MinSize.width

            #Be carefull that the active tab doesn't scroll off the bar
            if careful and not style:
                activeindex = tabs.index(parentpage.active.tab)
                change=False

                #add tabs until the active tab is visible
                while activeindex>=i and n!=i:
                    i += 1
                    tally += tabs[i].MinSize.width
                    change = True

                #Remove tab if more tabs than room
                if tally >= area and change:
                    tally -= tabs[n].MinSize.width
                    n += 1
                    self.tabindex=n




            # If extra space, fit tabs to the right of the row
            if not style: # if single row,
                while n > 0 and area - tally > tabs[n-1].MinSize.width:
                    n -= 1
                    self.tabindex = n
                    tally += tabs[n].MinSize.width


            # Injects tabs calculated to fit in that row into that row
            if range(n, i):
                rows[row] = [tabs[t] for t in xrange(n, i)]
                for tab in rows[row]:
                    tab.row=row
            else:
                rows[row].append(tabs[i])
                i += 1

            if not style: break # If we're in single row, break now.
            row += 1
            n = i
        # Row calculation

        if self.rowindex >= len(rows):
            self.rowindex = len(rows) - 1

        #cycle through visible rows
        row = self.rowindex
        visible = self.tab_rows or 1

        if careful and style:
            #print "Being Careful"
            active = parentpage.active.tab
            #print active
            for ir,r in enumerate(rows):
                #print ir,r
                if active in r:
                    if ir<row:
                        #print "moving index down"
                        row = self.rowindex = ir
                    elif ir >= row + visible:
                        #print "moving index up"
                        row = ir - (visible - 1)


        # If we're closing tabs above where is visible, keep the visible
        # index "where it is"
        if len(rows) - (row + 1) < visible and len(rows) >= visible:
            row = len(rows) - visible
            self.rowindex = row

        # Place tabs!
        while row < len(rows) and row < self.rowindex + visible and len( rows[row] ) != 0:

            # if this is a row that needs to be scrunched...
            if rows.index(rows[row]) == len(rows)-1 and \
                (style or len(rows[row]) == len(tabs)):

                for t in xrange(0,len(rows[row])):
                    thistab = rows[row][t]
                    thistab.SetSize(thistab.MinSize)
                    if not t:
                        # The first tab is set to it's minimum width at x: 0
                        thistab.SetPosition((0, self.rowheight*(row-self.rowindex)))
                    else:
                        # Every other tab is placed right next to the tab
                        # before it.
                        thistab.SetPosition((rows[row][t-1].Position.x \
                                             + rows[row][t-1].Size.width,
                                             self.rowheight*(row-self.rowindex)))
                    thistab.Show(True)

            # If there are more rows than the current row...
            elif len(rows) > row:
                # Get a list of tab indices, widest to smallest.
                ordered = [rows[row].index(t)
                           for t in sorted(rows[row],
                                           key=lambda o: o.MinSize.width,
                                                         reverse=True) ]
                length = len(ordered)
                reserved=0
                o=0 # o_O ?

                # Average width of tab if all tabs are the same size, and
                # fill up all the area.
                av = (area - reserved) / (length - o)
                mark = 0
                while o < length:
                    # Loop from "current" tab to the end
                    for t in xrange(o, length):
                        tab = rows[row][ordered[t]]

                        # If this tab is larger than average...
                        if tab.GetMinSize()[0] > av:
                            # Make it it's minimum, and keep track of it
                            tab.SetSize(tab.MinSize)
                            reserved += tab.MinSize.width
                            o += 1
                            mark = o

                            # If we're not on the last tab, recalc average
                            if (length - o):
                                av=(area-reserved)/(length-o)
                        else:
                            o += 1
                            break

                # For tabs less than the average, set them to average
                for t in xrange(mark, length):
                    tab = rows[row][ordered[t]]
                    tab.SetSize((av, tab.MinSize.height))

                # For every tab in the row
                for t, tab in enumerate(rows[row]):
                    if not t: # If it's the first tab:
                        if length==1:
                            # If the row is so small it can only fit one tab,
                            # make due.
                            tab.Size = wx.Size(area, tab.MinSize.height)
                        tab.Position = wx.Point(0, self.rowheight * (row - self.rowindex))
                    else:
                        tab.Position = wx.Point(rows[row][t-1].Position.x + rows[row][t-1].Size.width,
                                                self.rowheight * (row - self.rowindex))

                    tab.Show(True)
            row += 1
        if dotoggle:
            self.Toggle()

        # If total rows is less than total rows being shown, shrink the
        # tab area so that it's only just big enough.
        if len(rows) < style or not style:
            rows_shown = len(rows)
        else:
            rows_shown = style
        if  self.Parent.SashPosition != rows_shown * self.rowheight:#self.MinSize.height
            self.MinSize = wx.Size(-1, rows_shown * self.rowheight)
            self.Parent.SetSashPosition(self.MinSize.height)
#            self.Size=self.MinSize

        # Determine if the Navi needs to enable or show arrows
        navi.Enabler()
        #self.Parent.Layout()    # Relayout self
        self.tabendex = i-1     # final tab being shown

        self.UpdateNotify()

        navi.Size = wx.Size(-1,rows_shown * self.rowheight)

    def Remove(self, target):
        'Removes the tab specified from the bar.'

        index=self.tabs.index(target)
        self.tabs.remove(target)
        #if no more tabs close window
        if len(self.tabs)==0:
            self.Notebook.window.Close()
        else:
            #if index is between index and endex and bring one tab from the left
            if index>self.tabindex and index<self.tabendex and self.tabindex>0:
                self.tabindex-=1

            if self.side_tabs:
                self.ReVgenerate(total=True)
            else:
                self.Regenerate(safe = True)


    def OnSize(self, event):
        'ReLayout the tabs if the bar on event of a resize'
        event.Skip()

        if self.side_tabs and self.tabs:
            cupb   = self.cupb
            cdownb = self.cdownb
            size   = self.Size
            tabs = self.tabs
            endex = self.tabendex

            # position and size buttons
            cupb.Position = (0,0)
            cupb.Size = (size.width, 16)
            cupb.Show()
            cupb.Enable(self.tabindex != 0)

            cdownb.Position = (0, size.height - 16)
            cdownb.Size     = (size.width, 16)
            cdownb.Show()
            cdownb.Enable(endex < len(tabs) or tabs[endex - 1].Position.y +
                           tabs[endex-1].Size.height > size.height - 16)


        sz = self.Size
        if ((sz.width != self.lastsize.width and not self.side_tabs) or (sz != self.lastsize and self.side_tabs)) and self.IsShownOnScreen():
            self.lastsize = sz
            if self.side_tabs:
                self.ReVgenerate(dotoggle = False)
            else:
                self.Regenerate(False,dotoggle = False)

        try:
            wx.CallAfter(wx.CallAfter,self.Parent.pagecontainer.active.panel.input_area.expandEvent)
        except AttributeError:
            pass

        self.Refresh(False)


    def GetTabCount(self):
        """
            Returns the number of tabs in the bar
        """
        return len([t for t in self if t])

    def NextTab(self):
        self.SetNextActive(self.ActiveTab, wrap = True)

    def PrevTab(self):
        self.SetLastActive(self.ActiveTab, wrap = True)


    def SetNextActive(self, origin,wrap=False):
        """
            Sets the tab after the curent active
            -if it does not exist does the previbus
            -or the first if wrap is true
        """
        if origin in self.tabs:
            index=self.tabs.index(origin)
            if not index < len(self.tabs)-1 and wrap:
                self.tabs[0].SetActive(True)
            elif index < len(self.tabs)-1:
                self.tabs[index+1].SetActive(True)
            elif index>0:
                self.tabs[index-1].SetActive(True)
            self.Refresh(False)

    def SetLastActive(self, origin, wrap = False):
        """
            Sets the tab before the curent active
            -if it does not exist does the next
            -or the last if wrap is true
        """
        if origin in self.tabs:
            index=self.tabs.index(origin)
            if not index > 0 and wrap:
                self.tabs[len(self.tabs)-1].SetActive(True)
            elif index >0:
                self.tabs[index-1].SetActive(True)
            elif index<0:
                self.tabs[index+1].SetActive(True)
            self.Refresh(False)

    def SyncActive(self,atab):
        """
            Moves the index and endex so that the active tab is in the bar
        """
        if not atab: return

        if self.side_tabs:
            if atab < self.tabindex:
                self.tabindex=atab
                self.ReVgenerate(True)
            else:
                thetab=self.tabs[atab]
                while atab >= self.tabendex or thetab.Position.y+thetab.Size.height > self.Size.height-16:
                    self.tabindex+=1
                    self.ReVgenerate(True)
        else:
            style = self.tab_rows
            if atab < self.rowindex:
                self.rowindex=atab
                self.Regenerate()
            elif atab > self.rowindex+style-1:
                self.rowindex=atab-style+1
                self.Regenerate()

    def OnWheel(self,event):
        """
            Event that handles mouse wheeling,
            maps the events to SetNextActive and SetLastActive
        """
        if RectS(self.Size).Contains(event.Position):
            direction = event.GetWheelRotation()
            if direction<0:
                self.SetNextActive(self.ActiveTab, True)
            elif direction>0:
                self.SetLastActive(self.ActiveTab, True)

    @property
    def Notebook(self):
        return self.Parent

    @property
    def Manager(self):
        return self.Notebook.manager

    @property
    def ActiveTab(self):
        active = self.Notebook.pagecontainer.active
        if active is not None:
            return active.tab

    def OnButton(self,event):
        """
            The button events for vertical alignment for up and down
        """
        if event.GetId()==CUPID:
            if self.tabindex > 0:
                self.tabindex -= 1
                self.ReVgenerate(total = True)
        elif event.GetId()==CDOWNID:
            if self.tabendex<len(self.tabs) or self.tabs[self.tabendex-1].Position.y+self.tabs[self.tabendex-1].Size.height>self.Size.height-16:
                self.tabindex+=1
                self.ReVgenerate(total=True)

        self.UpdateNotify()

    def NotifyDrag(self, origin):
        """
            When a tab is dragged this is called to start the tabbar handling dragging
            origin - tab being dragged
        """
        # Lets the TabMan know a tab as been dragged
        self.dragorigin = origin
        origin.SetCursor(wx.StockCursor(wx.CURSOR_NO_ENTRY))
        self.Manager.Notify(self.Notebook)


    def DragCalc(self,point):
        """
            This does the dragging calculations for the tabs
        """

        sidetabs = self.side_tabs

        # if here is no local origin tab but there is a remote source identified in TabMan
        if not self.dragorigin and self.Manager.source:
            #setting a local drag origin
            master = self.Manager.source
            dragorigin=master.tabbar.dragorigin
            # announcing to TabMan it is expecting a tab
            self.Manager.Request(self.Notebook)
        # if there is a local origin use that
        else:
            dragorigin=self.dragorigin

        # if dragtarget is out of date find what you're dragging to
        if not self.dragtarget or not self.dragtarget.Rect.Contains(point):

            wap = wx.FindWindowAtPointer()
            self.dragtarget = wap if isinstance(wap,Tab) else None
            self.dragside   = None

        # if there is a tab as target
        if self.dragtarget and self.dragtarget != dragorigin:
            dtrect=self.dragtarget.Rect
            # data to decide what side the tab would be dropped on
            if not sidetabs:
                x  = point[0] - dtrect.x
                x2 = dtrect.width / 2
            else:
                x  = point[1] - dtrect.y
                x2 = dtrect.height / 2
            # make the left/top or right/bottom decision
            if x <= x2:#left/top
                if self.dragside!=False:
                    self.dragside=False
                    if not sidetabs:
                        self.DrawDropMarker(dtrect.x, dtrect.y)# + (dtrect.height // 2)
                    else:
                        self.DrawDropMarker(dtrect.x, dtrect.y)# + dtrect.width // 2

            elif not self.dragside:#right/bottom
                self.dragside=True
                if not sidetabs:
                    self.DrawDropMarker(dtrect.x+dtrect.width,dtrect.y)#+(dtrect.height//2)
                else: self.DrawDropMarker(dtrect.x,dtrect.y+dtrect.height)#+dtrect.width//2
            self.SetFocus()
        # if being dropped in the whitespace of the TabBar
        elif (dragorigin and self.dragtarget!=dragorigin) or (dragorigin==None and self.dragtarget==None) and self.Rect.Contains(point):
            # find what row the tab is being dropped in
            if not sidetabs:
                row=self.rows[(point[1]//self.rowheight)+self.rowindex]
                tab=row[len(row)-1]
                self.dragside=True
            # or in vertical if at the beginning or end
            else:
                if point.y>self.rowheight:
                    tab=self.rows[0][len(self.rows[0])-1]
                    self.dragside=True
                else:
                    tab=self.rows[0][0]
                    self.dragside=False
            dtrect=tab.Rect
            #Place marker
            if not sidetabs: self.DrawDropMarker(dtrect.x+dtrect.width,dtrect.y)#+(dtrect.height//2)
            elif self.dragside==True: self.DrawDropMarker(dtrect.x,dtrect.y+dtrect.height)#+dtrect.width//2
            else: self.DrawDropMarker(dtrect.x+dtrect.width/2,dtrect.y)
            self.SetFocus()
            #cleanup
            self.dragtarget=tab

        else:#if not in tabbar anymore don't show arrow
            self.dropmarker.Show(False)

    def DragFinish(self,new=False):
        """
        Ends dragging and does any rearranging if required
        """

        if not wx.IsDestroyed(self.dragorigin):
            self.dragorigin.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))

        if self.dragorigin and self.dragorigin.previewtabs:
            # Destroy the preview tab
            self.dragorigin.previewtabs.Stop()
            self.dragorigin.previewtabs = None

        rect       = RectPS(self.Notebook.ClientToScreen(self.Position), self.Size)
        parentrect = self.Notebook.window.Rect
        mousepos   = wx.GetMousePosition()
        manager    = self.Manager

        #if released out of the window...
        if not new and ((manager.destination and not parentrect.Contains(mousepos)) or not rect.Contains(mousepos)):
            if self.ActiveTab==self.dragorigin:
                self.SetNextActive(self.dragorigin)
            self.dragorigin.Show(False)

            #If no or invalid destination in manager create a new window and sets it destination
            dest = manager.destination
            if not dest or not dest.tabbar.Rect.Contains(dest.ScreenToClient(wx.GetMousePosition())):
                # FIXME: SWIG doesn't like subtracting a wx.Size from a wx.Point, so do it the hard way
                # until the SIP migration is finished.
                originsize = self.dragorigin.GetSize()
                newpoint = wx.Point(mousepos[0] - originsize[0], mousepos[1] - originsize[1])
                destination = self.Notebook.winman.NewWindow(newpoint, self.Notebook.window.GetSize()).notebook
            #else set the destination to the manager's destination
            else:
                destination = dest

            #clear tabman's destination
            manager.Request()

            # Grab a reference to the tab's page
            page = self.dragorigin.page

            # Make the tab "forget" about the page
            self.Notebook.did_remove(page.panel)
            del self.dragorigin.page
            del page.tab

            # Remove the tab from the tabs list, and destroy the wxWindow
            self.tabs.remove(self.dragorigin)

            self.dragorigin.Close()

            # remove page from this notebook and insert it into the target notebook
            #page.Parent.RemoveChild(page)
            destination.Insert(page, False)

            # cleanup
            manager.Notify()
            self.dragorigin=None

            # re-sort tabs
            if self.side_tabs:
                self.ReVgenerate(True)
            else:
                self.Regenerate(safe = True)

        # if released inside of the window
        # used both for moving within a window and as the last step of a
        # interwindow move in case of interwindow tab has already been moved to
        # this window at the end of the list and all that is left is to move it
        # to the correct position.
        elif self.dragtarget and self.dragorigin and self.dragorigin!=self.dragtarget and self.Rect.Contains(self.Notebook.ScreenToClient(mousepos)):
            #remove the tab from the list
            self.tabs.remove(self.dragorigin)

            #decide which side of the target the tab should be dropped
            pos = self.tabs.index(self.dragtarget) + (1 if self.dragside else 0)

            # Reinsert the tab in it's new position
            self.tabs.insert(pos, self.dragorigin)

            after = self.tabs[pos+1] if pos+1 < len(self.tabs) else None
            if after is not None:
                after = after.page.panel

            # call after so that windows are all in their correct places
            wx.CallAfter(self.Notebook.did_rearrange, self.dragorigin.page.panel, after)

#            # Resort
            if self.side_tabs:
                self.ReVgenerate(True)
            else:
                self.Regenerate()
        elif new:
            if self.side_tabs:
                self.ReVgenerate(True)
            else:
                self.Regenerate()

        #if there is a dragorigin run onMouseLeave on it to reset it's look
        if self.dragorigin:
            self.dragorigin.OnMouseLeave()

        #local cleanup
        self.dropmarker.Show(False)
        self.dragorigin=None
        self.dragtarget=None

        #destination and manager cleanup
        dest = manager.destination
        if dest:
            dest.tabbar.dragorigin=None
            dest.tabbar.dragtarget=None

        manager.Request()
        manager.Notify()

        if len(self.tabs)==0: self.Notebook.window.Close()

    def DrawDropMarker(self,x,y):
        """
        Places the marker for where to drop the tab
        x and y are center position, saves calculation that way
        """

#        if self.side_tabs:
#            self.dropmarker.SetSize((self.Size.width - self.dropmarkeroverlay, -1))
#        else:
#            self.dropmarker.SetSize((-1, self.rowheight - self.dropmarkeroverlay))
        self.dropmarker.Teleport(self.ClientToScreen((x, y+self.dropmarkeroffset)))

        if not self.dropmarker.IsShown():
            self.Manager.ShowDropMarker(self.dropmarker)

    def Toggle(self, switch = None):
        'Toggle whether the tabbar is hidden or shown.'

        if pref('tabs.hide_at_1', True) and len(self.tabs) <= 1 and not switch:
            self.Notebook.Split(False)

            #make sure the content of the IM win resizes if tabbaar hides
            self.ProcessEvent(wx.CommandEvent(wx.wxEVT_SIZE))
        else:
            self.Notebook.Split(True)


    def UpdateNotify(self):

        frows = self.flagedrows
        frows.clear()

        # Resort
        if self.side_tabs:
            tabs=self.tabs
            for i, tab in enumerate(tabs):
                if tab.notified:
                    frows.add(i)
                elif i in self.flagedrows:
                    frows.remove(i)

            self.cupb.SetNotify(len(frows) and min(frows) < self.tabindex)
            self.cdownb.SetNotify(len(frows) and (max(frows) >= self.tabendex or
                                                  tabs[max(frows)].Position.y + tabs[max(frows)].Size.height > self.Size.height - 16))
        else:
            for i, row in enumerate(self.rows):
                flaged = False
                for tab in row:
                    if tab and tab.notified:
                        flaged = True
                        frows.add(i)
            self.navi.upb.SetNotify(len(frows) and min(frows)<self.rowindex)
            self.navi.downb.SetNotify(len(frows) and max(frows)>self.rowindex + self.tab_rows - 1)
コード例 #9
0
class Protocol(StateMixin):
    __metaclass__ = ObservableActionMeta
    __slots__ = ['name',
                 'username',
                 'password',
                 'hub',
                 'self_buddy',
                 'buddies',
                 'rdv_sessions']

    name = 'AbstractProtocol'

    # Gives a possible "best-guess" email address for a contact.
    @classmethod
    def email_hint(cls, contact): return None

    # server-side ordering of buddylist?
    is_ordered = False
    contact_order = False
    supports_group_chat = False

    # Message Formatting Defaults
    message_format = 'html'
    message_fg = True
    message_bg = True
    message_sizes = [8, 10, 12, 14, 18, 24, 36]

    def __repr__(self):
        return '<%s %s (%s)>' % \
               (self.__class__.__name__, self.username, self.state)



    def __init__(self, username, password, msgHub):
        StateMixin.__init__(self)
        self.username, \
        self.password, \
        self.hub       = str(username), \
                         str(password), \
                         ThreadsafeGUIProxy(msgHub)

        self.self_buddy = None
        self.buddies = None
        self.rdv_sessions = observe.ObservableDict()
        self.state = self.Statuses.OFFLINE
        self.offline_reason = self.Reasons.NONE

        self.add_observer(self.connection_status_monitor, 'state')
        self.add_observer(self.connection_status_monitor, 'offline_reason')

    FAKEROOT_NAME = prefprop('buddylist.fakeroot_name', default='Contacts')

    @property
    def serviceicon(self):
        from gui import skin
        return skin.get('serviceicons.%s' % self.service)


    @property
    def service(self):
        '''An overridable property used for displaying to the user, which can
        differ from the "name," which is the impl. (like 'jabber').'''

        return self.name

    def _unregister_buddies(self):
        log.info('_unregister_buddies: %r', self)

        try:
            unregister = profile.account_manager.buddywatcher.unregister
        except AttributeError:
            unregister = lambda b: None

        for bdict in self.buddy_dictionaries():
            if bdict is None:
                continue

            for buddy in bdict.values():
                unregister(buddy)
                try:
                    buddy.setnotifyif('status', 'unknown')
                except Exception:
                    pass # jabber buddies...
                buddy.observers.clear()

            bdict.observers.clear()
            bdict.clear()

        self.remove_observer(self.connection_status_monitor, 'state', 'offline_reason')

    def silence_notifications(self, timeSecs = None):
        'silences notifications on this protocol for timeSecs seconds'

        old_silence_timer = getattr(self, '_silence_notifications_timer', None)
        if old_silence_timer is not None:
            old_silence_timer.stop()

        from common import silence_notifications
        self._silence_notifications_timer = silence_notifications(self, timeSecs)

    def connection_status_monitor(self, src, attr, old, new):
        assert src is self

        if new == self.Statuses.OFFLINE:
            self._unregister_buddies()

        from plugin_manager import plugin_hub
        plugin_hub.act('digsby.protocol.statechange.async', self, attr, old, new)

        state_log.critical('%r: %r changed from <%r> to <%r>', self, attr, old, new)

    def allow_message(self, buddy, mobj):
        if buddy is self.self_buddy:
            return True

        if mobj.type == 'outgoing':
            return True # don't ever block outgoing messages.

        if getattr(mobj, 'sms', False):
            return True #ticket #3869 don't filter sms (which are usually not on a buddy list, nor an allow list).

    def set_and_size_icon(self, icondata):
        '''
        Sets the buddy icon in the protocol.

        icondata should be raw image file data

        If the given data is too big (in bytes or size), the image
        is resized before being passed to the protocol.
        '''

        from gui.toolbox.imagefx import pil_to_white_gif, has_transparency

        img = Image.open(StringIO(icondata)) # will raise IOError if icondata isn't an image

        max     = getattr(self, 'max_icon_bytes', sys.maxint)
        formats = getattr(self, 'icon_formats', ['PNG', 'JPEG', 'BMP', 'GIF'])
        format  = img.format

        needsResize   = len(icondata) > max
        needsReformat = format not in formats

        log.info('set_and_size_icon')
        log.info('  %d bytes of icondata', len(icondata))
        log.info('  format: %s, formats: %r', format, formats)
        log.info('  needs:')
        log.info('    resize: %s', needsResize)
        log.info('    reformat: %s', needsReformat)

        if needsReformat:
            if has_transparency(img) and 'GIF' in formats:
                # img.getcolors returns None if there are more than 256 colors in the image
                # GIF is probably a good guess for images with less than 256 colors
                format = 'GIF'
            else:
                format = formats[0]

        if needsReformat or needsResize:
            if format == 'GIF':
                # reduces dithering by adapting image palette
                icondata = pil_to_white_gif(img)
                imgFile = StringIO(icondata)
                img = Image.open(imgFile)
                imgFile = StringIO(icondata)
            else:
                opts = {'PNG': {'optimize': True}} # for PNGs, optimize for space

                if format == 'BMP':
                    img = img.convert('RGB')

                imgFile = StringIO()
                img.save(imgFile, format, **opts.get(format, {}))
                icondata = imgFile.getvalue()

        if needsResize:
            # too big, we need to resize
            w, h = getattr(self, 'max_icon_size', (48, 48)); assert w == h
            log.info('set_icon got %d bytes but %s only allows %d, resizing to %dx%d...',
                     len(icondata), self.name, max, w, w)
            img = img.Resized(w)
            if format == 'GIF':
                icondata = pil_to_white_gif(img)
                imgFile = StringIO(icondata)

        if needsReformat or needsResize:
            log.info('encoded icon as %s, size %d: %s...', format, len(icondata), repr(icondata[:16]))

            if len(icondata) > max:
                return log.warning('still too big, not setting')

            icondata = imgFile.getvalue()

        import wx
        wx.CallAfter(lambda : self.set_buddy_icon(icondata))


    @property
    def caps(self):
        raise NotImplementedError('"caps" property (a sequence of Buddy '
                                  'capabilities) is not implemented in '
                                  '%s' % self.__class__.__name__)

    def simple_status(self, status_string):
        'Returns a simple status string. (available or away)'

        from common.statusmessage import simple
        return simple(status_string, self)


    def _set_status_object(self, statusobj):
        'Given a status object, sets the status message for this protocol.'

        acctstatus = statusobj.for_account(self)

        # apply default formatting if none was specified in the status message
        if acctstatus.format is None:

            import wx
            @wx.CallAfter
            def gui_thread(st=acctstatus):
                from common import profile
                if profile and profile.prefs:
                    from gui.uberwidgets.formattedinput import get_default_format
                    st = st.copy(editable=None)
                    st.format = get_default_format()

                netcall(lambda: self.set_message_object(st))

            return

        self.set_message_object(acctstatus)

    @callsback
    def set_message_object(self, message, callback = None):
        msg, status, format = message.message, message.status.lower(), message.format
        if message.editable:
            #needs a hook!
            from digsby_status.status_tag_urls import tag_status
            msg = tag_status(msg, self.service, message.status)
        self.set_message(msg, status, format=format)

    @property
    def is_connected(self):
        return self.state == self.Statuses.ONLINE

    def Connect(self):
        raise NotImplementedError

    def Disconnect(self):
        log.info('Protocol.Disconnect')

    def authorize_buddy(self, buddy_obj, allow=True, username_added=None):
        raise NotImplementedError

    def block_buddy(self, buddy_obj):
        raise NotImplementedError

    def unblock_buddy(self, buddy_obj):
        raise NotImplementedError

    def set_remote_alias(self, btuple, new_name):
        raise NotImplementedError

    def chat_with(self, buddyobj):
        raise NotImplementedError

    def send_message(self, bname, msg, formatting):
        raise NotImplementedError

    def send_typing_status(self, bname, status):
        raise NotImplementedError

    def send_im(self, buddyname, message):
        self.convo_for(self.get_buddy(buddyname)).send_message(message)

    def set_status_message(self):
        raise NotImplementedError

    def send_direct_im_req(self, *btuple):
        raise NotImplementedError

    @callsback
    def rejoin_chat(self, old_conversation, callback=None):
        '''
        given a Conversation object belonging to an "old," disconnected
        protocol, joins the same chat room on self (a new, connected protocol).
        '''
        if old_conversation.did_explicit_exit:
            return log.info('not rejoining chat: conversation was exited')

        _original_success = callback.success
        def success(convo):
            if old_conversation.did_explicit_exit:
                log.info('leaving chat: old convo was exited')
                convo.exit()
            else:
                _original_success(convo)
        callback.success = success

        self._do_rejoin_chat(old_conversation, callback=callback)

    @callsback
    def _do_rejoin_chat(self, old_conversation, callback=None):
        self.join_chat(room_name = old_conversation.chat_room_name, notify_profile=False, callback=callback)

    @callsback
    def make_chat_and_invite(self, buddies_to_invite, convo=None, room_name=None, server=None, notify=False, callback=None):
        log.info('make_chat_and_invite')
        log.info('  connection: %r', self)
        log.info('  buddies_to_invite: %r', buddies_to_invite)

        def success(convo):
            callback.success(convo)
            buds = filter(lambda b: b != self.self_buddy, buddies_to_invite)
            convo.add_pending_contacts(buds)
            for b in buds:
                self.invite_to_chat(b, convo)

        self.join_chat(room_name=room_name, server=server, success=success, error=callback.error, notify_profile=notify)

    @callsback
    def invite_to_chat(self, buddy, conversation, callback=None):

        log.warning('invite_to_chat: %r to %r', buddy, conversation)

        orig_error = callback.error
        def on_error(exc=None):
            with traceguard:
                if isinstance(exc, ChatInviteException):
                    name = buddy.name
                    if exc.reason == ChatInviteException.REASON_OFFLINE:
                        msg = _('Error inviting {name}: they are offline').format(name=name)
                    elif exc.reason == ChatInviteException.REASON_GROUPCHAT_UNSUPPORTED:
                        msg = _('Error inviting {name}: they do not support group chat').format(name=name)
                    conversation.system_message(msg)

            orig_error(exc)

        callback.error = on_error
        return conversation.invite(buddy, callback=callback)

    def send_chat_req(self, btuple, room_name, invitemessage):
        raise NotImplementedError

    def send_buddy_list_request(self, btuple):
        raise NotImplementedError

    def set_invisible(self, invisible):
        raise NotImplementedError

    def accept_file(self, file_obj):
        raise NotImplementedError

    def add_buddy(self, bname, group_id=None, pos=0, service=None):
        raise NotImplementedError

    def remove_buddy(self, btuple, group_id=None):
        raise NotImplementedError

    def move_buddy(self, buddy, to_group, from_group=None, pos=0):
        raise NotImplementedError

    def get_group(self, groupname):
        raise NotImplementedError, "should return a Group or None"

    def get_groups(self):
        'Returns a list of group names.'

        return [g.name for g in self.root_group]

    def get_buddy(self, buddyname):
        return self.buddies[buddyname]

    def get_protocol_buddy(self, buddy):
        'Given a buddy, returns the protocol-specific buddy object stored in this Protocol.'
        return self.get_buddy(buddy.name)

    def has_buddy_on_list(self,buddy):
        for group in self.root_group:
            for listbuddy in group:
                if buddy.name == listbuddy.name and buddy.service == listbuddy.service:
                    return True
        return False

    def has_buddy(self, buddyname):
        return buddyname in self.buddies

    def add_new_buddy(self, buddyname, groupname, service = None, alias = None):
        g     = self.get_group(groupname)

        def doit(*res):
            grp = self.get_group(groupname)
            buddy = self.get_buddy(buddyname)
            grp.add_buddy(buddyname, service = service)

            if alias is not None:
                profile.set_contact_info(buddy, 'alias', alias)

        if g is None:
            self.add_group(groupname, success = doit)
        else:
            doit()


    @callsback
    def move_buddy_creating_group(self, contact, groupname, fromgroupname, index = 0, callback = None):
        def do_move():
            self.move_buddy(contact, groupname, fromgroupname, index,
                            callback = callback)

        group = self.get_group(groupname)
        if group is None:
            self.add_group(groupname, success = lambda newgroup,*a,**k: netcall(do_move))
        else:
            do_move()


    def add_contact(self, contactname, group, service = None):
        self.add_buddy(contactname, group, service = service)

    @property
    def protocol(self):
        return self.name

    def should_log(self, messageobj):
        return True

    def when_reconnect(self, callback):
        return self.account.when_reconnect(callback)
コード例 #10
0
class MessageArea(FrozenLoopScrollMixin, ScrollWinMixin, WheelShiftScrollFastMixin, WheelScrollCtrlZoomMixin, WebKitWindow):
    def __init__(self, parent, header_enabled = True, prevent_align_to_bottom=False):
        super(MessageArea, self).__init__(parent)

        self.inited = False
        self.header_enabled = header_enabled
        self.prevent_align_to_bottom = prevent_align_to_bottom

        self.Bind(webview.EVT_WEBVIEW_BEFORE_LOAD, self._before_load)

    date_context_format = '%A, %B %d, %Y'

    show_fonts     = prefprop('appearance.conversations.show_message_fonts', True)
    show_colors    = prefprop('appearance.conversations.show_message_colors', True)
    show_emoticons = prefprop('appearance.conversations.emoticons.enabled', True)
    htmlize_links  = prefprop('appearance.conversations.htmlize_links', True)

    def _before_load(self, e):
        e.Skip()
        if e.NavigationType == webview.WEBVIEW_NAV_LINK_CLICKED:
            url = e.URL
            if url.startswith('digsby://'):
                from common import urlhandler
                handle_result = urlhandler.handle(url)
                if handle_result.cancel_navigation:
                    e.Cancel()
                else:
                    if url != handle_result.url:
                        e.SetURL(url)

    def init_content(self, theme, chatName = None, buddy = None, show_history = None, prevent_align_to_bottom=False):
        # grab initial theme contents
        self.theme = theme

        # the message area keeps a timestamp, updated with each message, to
        # know when to insert a "date status" line
        now = datetime.now()
        self.tstamp  = toutc(datetime(now.year, now.month, now.day))

        show_header = self.header_enabled and pref('appearance.conversations.show_header', False)
        initialContents = theme.initialContents(chatName, buddy, show_header, prevent_align_to_bottom=prevent_align_to_bottom)

        self.SetPageSource(initialContents, theme.baseUrl)

        if show_history is None:
            show_history = True

        if show_history and history_enabled() and buddy is not None:
            with traceguard:
                self.show_history(buddy)

        self.inited = True

    def show_history(self, buddy):
        num_lines = max(0, pref('conversation_window.num_lines', 5, int))

        if num_lines > 0:
            logsource = buddy
            if pref('conversation_window.merge_metacontact_history', False):
                from common import profile
                metacontact = profile.metacontacts.forbuddy(buddy)
                if metacontact: logsource = list(metacontact).pop()

            msgobjs   = reversed(list(takemany(num_lines, logsource.history)))
            self.replay_messages(msgobjs, buddy)

    def replay_messages(self, msgobjs, buddy, context = True):
        'Displays a sequence of message objects.'

        next         = False
        oldname      = None
        olddirection = None

        num_messages = 0
        skipped_messages = 0

        for msg in msgobjs:
            num_messages += 1

            if msg in quiet_log_messages.messages:
                skipped_messages += 1
                if __debug__: log.info('skipping message: %r', msg)
                continue

            # the theme needs to know which messages to glue together as "adjacent"--
            # so we check the buddy name and the direction attribute for changes.
            name        = msg.buddy.name
            direction   = msg.type
            next        = oldname == name and direction == olddirection

            msg.buddy = buddy_lookup(buddy, name)
            msg.content_type = 'text/html'

            # context means "history" here
            self.format_message(direction, msg, next, context = context)

            oldname = name
            olddirection = direction

        log.info('replay_messages: %d total messages (%d skipped) for buddy %r', num_messages, skipped_messages, buddy)

    def show_header(self, show):
        'Show or hide the message header.'

        return self.RunScript(self.theme.show_header_script(show))

    def date_status(self, dt):
        # "Status" messages are reused as a form of date context for displaying
        # old messages in the history, and for when an IM window is open for
        # more than a day.

        # displayed timestamps need to be converted from UTC->local
        format_dt = fromutc(dt)

        return S(message   = format_dt.strftime(self.date_context_format),
                 timestamp = dt,
                 buddy     = None,
                 type      = None)

    def format_message(self, messagetype, messageobj, next = False, context = False):
        '''
        messagetype    status, incoming, or outgoing
        messageobj     a storage with buddy, message, timestamp, conversation
        next           True if this message is from the same sender as the last one
        context        True if this message is being displayed as message history
        '''
        if messagetype != 'status':

            # don't show date for the first message in the window
            msgtime = messageobj.timestamp

            if msgtime is None:
                msgtime = datetime.utcnow()

            # do the timestamps differ enough to show a date context line?
            if should_show_time(self.tstamp, msgtime):
                self.theme.set_always_show_timestamp(True)
                try:
                    self.format_message('status', self.date_status(msgtime), next = False, context = context)
                finally:
                    self.theme.set_always_show_timestamp(False)

                # This can't be a "next" message, since we just showed a status line.
                next = False

            self.tstamp = msgtime

        content_type = getattr(messageobj, 'content_type', 'text/plain')

        if content_type == 'text/plain':
            messageobj.message = messageobj.message.encode('xml')
            messageobj.message = preserve_whitespace(messageobj.message)
            messageobj.content_type = 'text/html'

        # apply text transformations, including emoticons and stripping
        # colors and formatting (if enabled)
        show_colors = self.theme.allow_text_colors and self.show_colors
        show_emoticons = pref('appearance.conversations.emoticons.pack') if self.show_emoticons else None

        transforms = dict(emoticons = show_emoticons,
                          links     = self.htmlize_links,
                          spaces    = True)

        if not getattr(messageobj, 'linkify', True):
            transforms['links'] = False

        stripped, strip_values = strip(messageobj.message,
                                       formatting           = not self.show_fonts,
                                       colors               = not show_colors,
                                       plaintext_transforms = transforms)

        messageobj = messageobj.copy()
        messageobj.message = stripped

        if getattr(messageobj, 'has_autotext', False):
            extra = {}
        else:
            extra = dict(has_autotext = True, autotext = AUTORESP)

        # If there is one background color, pass it to the conversation theme
        if self.show_colors:
            extra.update(handle_colors(strip_values))

        # get the JS function and complete message (including theme elements)
        func, msg = self.theme.format_message(messagetype, messageobj, next, context, **extra)

        if func:
            script = "%s('%s');" % (func, js_escape(msg))
            self.RunScript(script)
コード例 #11
0
ファイル: formattedinput.py プロジェクト: sgricci/digsby
class FormattedInput(cgui.SimplePanel):
    '''
    An RTF2 based input box with a formatting bar and auto sizing,
    '''
    def __init__(self,
                 parent,
                 pos       = wx.DefaultPosition,
                 size      = wx.DefaultSize,
                 value     = '',
                 entercallback = None,
                 font      = True,
                 pointsize = True,
                 bold      = True,
                 italic    = True,
                 underline = True,
                 textcolor = True,
                 bgcolor   = True,
                 sizes     = DEFAULT_SIZES,
                 emots     = None,

                 singleFormat = False,
                 show_formatting_bar = True,
                 rtl_input = False,
                 prefmode = False,
                 outlined = False,
                 aimprofile = False,
                 autosize = True,
                 default_skin = False,

                 validator = None,

                 format = None,):

        cgui.SimplePanel.__init__(self, parent)

        self.prefmode   = prefmode
        self.aimprofile = aimprofile
        self.autosize   = autosize

        self.UseAppDefaultSkin = (self.prefmode or self.aimprofile) or default_skin

        self.initover = False
        self.entercallback = entercallback

        self.sizes = sizes
        self.emots = emots

        # create the Formatting bar, buttons, and menus
        self.Sizer = wx.BoxSizer(wx.VERTICAL)
        csizer = self.csizer = wx.BoxSizer(wx.VERTICAL)
        self.Sizer.Add(csizer, 1, wx.EXPAND | wx.ALL, 1 if outlined else 0)

        self.UpdateSkin()

        if validator is None:
            validator = LengthLimit(20480)

        if self.autosize:
            tc = self.tc = FormattedExpandoTextCtrl(self, style=txtFlags, value = value, validator=validator)
            tc.Bind(EVT_ETC_LAYOUT_NEEDED, self.expandEvent)
            tc.Bind(wx.EVT_SIZE, self.OnSize)
            if config.platform == 'win':
                tc.Bind(wx.EVT_COMMAND_TEXT_PASTE, self.OnPaste)
            tc.SetMaxHeight(100)

            loadedHeight = pref('conversation_window.input_base_height')
            baseHeight = self.tc.GetCharHeight() + getattr(self.tc, 'GetExtraHeight', lambda: 0)()

            tc.SetMinHeight(loadedHeight or baseHeight)

            if loadedHeight:
                log.info("input_base_height loaded as %s", loadedHeight)
            else:
                log.info("input_base_height not used, set to baseHeight as %s", baseHeight)

            tc.MinSize = wx.Size(tc.MinSize.width, tc.GetMinHeight())
#            wx.CallAfter(self.tc.HideScrollbars)
            self.expandEvent()
        else:
            tc = self.tc = FormattedTextCtrl(self, style = txtFlags, value = value, validator=validator)

        self.tc.LayoutDirection = wx.Layout_RightToLeft if rtl_input else wx.Layout_LeftToRight

        tc.Bind(wx.EVT_CONTEXT_MENU, lambda e: default_umenu(tc).PopupMenu(event = e))

        # bind textfield events
        tc.Bind(wx.EVT_KEY_DOWN,  self.OnKey)

        self.shownbuttons = dict(
            font      = font,
            pointsize = pointsize,
            bold      = bold,
            italic    = italic,
            underline = underline,
            textcolor = textcolor,
            bgcolor   = bgcolor)


        if config.platform != 'mac' and show_formatting_bar:
            self.construct_formatting_bar()
        else:
            self.formatbar = None

        csizer.Add(self.tc, 1, wx.EXPAND)
        self.single_format = singleFormat

        self.initover = True

        if format is None:
            wx.CallAfter(self.LoadStyle)
            profile.prefs.add_observer(self.WhenDefaultLayoutChange, 'messaging.default_style')
        else:
            self.SetFormatStorage(format)

        Bind = self.Bind
        if outlined:
            Bind(wx.EVT_PAINT,self.OnPaint)

        Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)

    def OnPaste(self, event):
        text = clipboard.get_text()
        if text is None:
            return

        # our rich text control adds a newline to the end of copied text--
        # strip one out if it's there
        if text.endswith('\n'):
            text = text[:-1]

        self.tc.WriteText(text)

    def OnSize(self, event):
        # this is an ugly hack, but unavoidable. For some reason, whenever this is called it
        # resets the Mac spell checker state. (i.e. all misspelled words are no longer underlined)
        # this code makes sure that doesn't happen.
        if config.platform == 'mac':
            self.tc.OnTextChanged(event)
            self.tc.MacCheckSpelling(True)

    def BindSplitter(self, splitter):
        splitter.Bind(wx.EVT_LEFT_DOWN, self.OnSplitterStart)
        splitter.Bind(wx.EVT_LEFT_UP, self.OnSplitterSet)
        self.sizeID = wx.EVT_SIZE
        #SWIG HAX: In Robin's bindings, wx.EVT_SIZE is a function, and wx.wxEVT_SIZE is the int id
        if not config.platform == "win":
            self.sizeID = wx.wxEVT_SIZE
        splitter.Connect(splitter.Id, splitter.Id, self.sizeID, self.OnFirstSplitterSize)

        self.splitter = splitter

    def OnFirstSplitterSize(self, event):

        #HAX: make sure the splitter lays out the first time it get's a real size

        event.Skip()

        splitter = self.splitter

        if splitter.Size.height and splitter.Size.width:
            splitter.Disconnect(splitter.Id, splitter.Id, self.sizeID)
            wx.CallAfter(self.expandEvent)

    def OnSplitterStart(self, event):
        event.Skip()
        tc = self.tc

        baseh = min(tc.GetMaxHeight(), tc.GetCharHeight() * tc.GetNumLines() + tc.GetExtraHeight())

        tc.MinSize = wx.Size(tc.MinSize.width, baseh)
        tc.SetMinHeight(baseh)
        self.MinSize = wx.Size(-1, (self.formatbar.Size.height if self.FormattingBarIsShown() else 0) + tc.MinSize.height)

    def OnSplitterSet(self,event):
        event.Skip()
        tc = self.tc

        baseh = min(tc.GetMaxHeight(), self.tc.GetCharHeight() * self.tc.GetNumLines() + self.tc.GetExtraHeight())
        h = tc.Size.height if tc.Size.height != baseh else 0

        log.info("input_base_height set to %s", h)

        setpref('conversation_window.input_base_height', h)
        tc.SetMinHeight(h)

    def OnPaint(self, event):
        'Draws an outline around the control.'
        dc = BufferedPaintDC(self)
        dc.Brush = wx.TRANSPARENT_BRUSH
        dc.Pen = wx.Pen(OUTLINE_COLOR)
        dc.DrawRectangleRect(RectS(self.ClientSize))

    def OnDestroy(self, event):
        event.Skip()
        profile.prefs.remove_observer(self.WhenDefaultLayoutChange, 'messaging.default_style')

    def expandEvent(self, e=None):
        height = (self.formatbar.Size.height if self.FormattingBarIsShown() else 0) + \
            max(self.tc.MinSize.height, self.tc.GetMinHeight())

        self.MinSize = wx.Size(-1, height)

        # If BindSplitter was called, we have .splitter
        if hasattr(self, 'splitter'):
            self.splitter.SetSashPosition(self.splitter.ClientSize.height - height)

    def on_fbar_context_menu(self, e):
        # TODO: why isn't the IM window's formatting bar its own subclass!?

        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 construct_formatting_bar(self):
        fb = self.formatbar = UberBar(self, skinkey = self.toolbarskin, alignment = wx.ALIGN_LEFT)

        if not self.prefmode and not self.aimprofile:
            fb.Bind(wx.EVT_CONTEXT_MENU, self.on_fbar_context_menu)

        self.fontdd = FontDropDown(fb, skinkey = fb.buttonskin)
        self.fontdd.Bind(wx.EVT_COMMAND_CHOICE_SELECTED, self.OnFontSelect)

        self.msize = SimpleMenu(self, self.menuskin, maxheight = 10) # TODO: max and min width?
        self.msize.SetItems(self.SetSizes(self.sizes))
        self.bsize = UberButton(fb, -1, '10', menu = self.msize, type = 'menu')
        self.bsize.SetStaticWidth(self.sizeddwidth)
        self.msize.SetWidth(self.sizeddwidth)
        self.bbold = UberButton(fb, -1, icon = self.bicon, type = 'toggle')
        self.bbold.Bind(wx.EVT_TOGGLEBUTTON, self.ToggleBold)

        self.bitalic = UberButton(fb, -1, icon = self.iicon, type="toggle")
        self.bitalic.Bind(wx.EVT_TOGGLEBUTTON, self.ToggleItalic)

        self.bunderline = UberButton(fb, -1, icon = self.uicon,  type="toggle")
        self.bunderline.Bind(wx.EVT_TOGGLEBUTTON, self.ToggleUnderline)

        self.bcolor = UberButton(fb, -1, icon = self.fcicon )
        self.bcolor.Bind(wx.EVT_BUTTON, self.OnColor)

        self.bbgcolor = UberButton(fb,-1, icon = self.bcicon)
        self.bbgcolor.Bind(wx.EVT_BUTTON, self.OnBGColor)

        self.bemote = UberButton(fb, -1, icon = self.eicon)
        self.bemote.Bind(wx.EVT_BUTTON, self.on_emote_button)

        self.EnableFormattingButtons(getattr(self, 'formatting_enabled', True))

        #Add all the buttons to the formating bar
        fb.AddMany([self.fontdd,
                    self.bsize,
                    self.bbold,
                    self.bitalic,
                    self.bunderline,
                    self.bcolor,
                    self.bbgcolor,
                    self.bemote])

        self.csizer.Insert(0, fb, 0, wx.EXPAND, 0)
        self.ShowButtons(**self.shownbuttons)

        self.UpdateDisplay()

        self.formatbar.Bind(wx.EVT_SIZE, lambda e: (e.Skip(), wx.CallAfter(self.expandEvent)))

    def on_emote_button(self, e):
        self.display_emotibox(self.bemote.ScreenRect)

    def display_emotibox(self, rect):
        ebox = self.get_emotibox()
        # position and display the emotibox
        ebox.Display(rect)

    def get_emotibox(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.tc, maxwidth = 12)
        else:
            b.SetTextCtrl(self.tc)

        return b

    def UpdateSkin(self):
        s = lambda name, d = None: skin.get('%sFormattingBar.%s' % ('AppDefaults.' if self.UseAppDefaultSkin else '',name),d)

        iconsize = self.iconsize = s('iconsize')

        icons = s('icons').get

        bicon   = self.bicon   =             icons('bold').Resized(iconsize)
        iicon   = self.iicon   =           icons('italic').Resized(iconsize)
        uicon   = self.uicon   =        icons('underline').Resized(iconsize)
        fcicon  = self.fcicon  =  icons('foregroundcolor').Resized(iconsize)
        bcicon  = self.bcicon  =  icons('backgroundcolor').Resized(iconsize)
        eicon   = self.eicon   =            icons('emote').Resized(iconsize)

        fontddwidth = self.fontddwidth = s('FontDropDownWidth')
        sizeddwidth = self.sizeddwidth = s('SizeDropDownWidth')
        menuskin    = self.menuskin    = s('MenuSkin', None)
        toolbarskin = self.toolbarskin = s('toolbarskin', None)

        if self.initover and getattr(self, 'formatbar', None) is not None:
            self.formatbar.SetSkinKey(toolbarskin)
            # new font drop down does not have SetMinWidth
            # self.fontdd.SetMinWidth(fontddwidth)
            self.bsize.SetStaticWidth(sizeddwidth)
            self.msize.SetWidth(sizeddwidth)
            self.bbold.SetIcon(bicon)
            self.bitalic.SetIcon(iicon)
            self.bunderline.SetIcon(uicon)
            self.bcolor.SetIcon(fcicon)
            self.bbgcolor.SetIcon(bcicon)
            self.bemote.SetIcon(eicon)

        wx.CallAfter(self.Layout)

    def __repr__(self):
        try:
            return '<%s under %r>' % (self.__class__.__name__, self.Parent)
        except Exception:
            return object.__repr__(self)

    def SetSingleFormat(self, singleformat = True):
        '''
        Sets this control to only have one style for all of its contents. The
        style used is the first one found.
        '''

        return

    def GetSingleFormat(self):
        return True#self.single_format

    SingleFormat = property(GetSingleFormat, SetSingleFormat, None, doc = SetSingleFormat.__doc__)

    def SaveStyle(self):
        style = self.GetStyleAsDict()
        from pprint import pformat
        print 'saving style:\n%s' % pformat(style)
        setpref('profile.formatting' if self.aimprofile else 'messaging.default_style',style)

    def GetStyleAsDict(self):

        tc = self.tc

        return dict(BackgroundColour = tuple(tc.BackgroundColour),
                     TextColour = tuple(tc.ForegroundColour),
                     Font = font_to_tuple(tc.Font))

    def WhenDefaultLayoutChange(self,src,pref,old,new):

#        if self.GetStyleAsDict() == old:
        self.LoadStyle()

    def LoadStyle(self):
        self.SetFormat(*load_pref_style('profile.formatting' if self.aimprofile else 'messaging.default_style'))


    def SetFormatStorage(self, format_storage):
        return self.SetFormat(*font_attrs_from_storage(format_storage))

    def SetFormat(self, font, fgc, bgc):
        tc = self.tc
        tc.Font = font
        tc.SetFont(font)
        tc.ForegroundColour = wx.BLACK
        tc.ForegroundColour = wx.Color(*fgc)
        tc.BackgroundColour = wx.Color(*bgc)
        self.UpdateDisplay()

    def ShowFormattingBar(self, val):
        'Shows or hides the formatting bar.'

        if val and self.formatbar is None:
            self.construct_formatting_bar()

        if self.formatbar is not None:
            self.csizer.Show(self.formatbar, val, True)
            self.Layout()

        if self.autosize:
            self.expandEvent()

    def FormattingBarIsShown(self):
        if getattr(self, 'formatbar', None) is not None:
            return self.formatbar.IsShown()

        return False

    def EnableFormattingButtons(self, enable):
        self.formatting_enabled = enable

        if hasattr(self, 'fontdd'): # the formatting bar might not have been constructed yet
            self.fontdd.Enable(enable)
            self.bsize.Enable(enable)
            self.bbold.Enable(enable)
            self.bitalic.Enable(enable)
            self.bunderline.Enable(enable)
            self.bcolor.Enable(enable)
            self.bbgcolor.Enable(enable)

    def ShowButtons(self,
                 font = True,
                 pointsize = True,
                 bold = True,
                 italic = True,
                 underline = True,
                 textcolor = True,
                 bgcolor = True):

        'Show or hide each button on the format bar.'

        self.fontdd.Show(font)
        self.bsize.Show(pointsize)
        self.bbold.Show(bold)
        self.bitalic.Show(italic)
        self.bunderline.Show(underline)
        self.bcolor.Show(textcolor)
        self.bbgcolor.Show(bgcolor)
        #self.bemote.Show(not self.prefmode)

    def GetStyleAsStorage(self):
        tc = self.tc
        font = tc.Font

        return Storage(
            backgroundcolor = tuple(tc.BackgroundColour),
            foregroundcolor = tuple(tc.ForegroundColour),
            family = FamilyNameFromFont(font),
            face = font.FaceName,
            size = font.PointSize,
            underline = font.Underlined,
            bold = font.Weight == wx.BOLD,
            italic = font.Style == wx.ITALIC)


    @property
    def Format(self):
        return self.GetStyleAsStorage()


    def GetHTML(self):
        'Does the necessary steps to convert the textfield value into HTML.'

        s = ''
        value = self.tc.Value

        s =  cgi.escape(value)

        s = s.replace('\n','<br>').replace('\t','&nbsp;&nbsp;')
        return s

    HTML = property(GetHTML)

    def GetValue(self):
        'Returns the string in the textfield.'

        return self.tc.GetValue()

    def SetValue(self, value):
        'Sets the string in the textfield.'

        return self.tc.SetValue(value)

    Value = property(GetValue, SetValue)

    @property
    def FontData(self):
        d = wx.FontData()
        tc = self.tc
        d.SetInitialFont(tc.GetFont())
        d.SetColour(tc.GetForegroundColour())
        return d

    def ShowModalFontDialog(self, e = None):
        '''
        Uses the native Mac font dialog to allow the user to select a font
        and a color.
        '''
        diag = wx.FontDialog(self, self.FontData)
        if wx.ID_OK == diag.ShowModal():
            font_data = diag.GetFontData()
            font = font_data.GetChosenFont()
            color = font_data.GetColour()

            tc = self.tc
            if color.IsOk():
                tc.ForegroundColour = color
            if font.IsOk():
                tc.Font = font

            if self.prefmode or self.aimprofile:
                wx.CallAfter(self.SaveStyle)

            tc.Refresh()
            tc.SetFocus()

    def CreateFontButton(self, parent, label = _('Set Font...')):
        '''
        Create a small button that will spawn a font dialog for setting
        the properties of this text control.
        '''
        font_button = wx.Button(parent, -1, label)
        font_button.SetWindowVariant(wx.WINDOW_VARIANT_SMALL)
        font_button.Bind(wx.EVT_BUTTON, self.ShowModalFontDialog)
        return font_button

    def OnColor(self, event = None):
        "Calls the color chooser for setting font color."

        newcolor = wx.GetColourFromUser(self, self.tc.ForegroundColour, _('Choose a foreground color'))
        self.update_color(newcolor)

    def update_color(self, newcolor):

        if newcolor.IsOk():
            self.tc.ForegroundColour = newcolor

        if self.prefmode or self.aimprofile:
            wx.CallAfter(self.SaveStyle)

        #Insure the focus goes back to the TextField
        self.tc.Refresh()
        self.tc.SetFocus()


    def OnBGColor(self,event):
        'Calls the color chooser for setting font background color.'

        newcolor = wx.GetColourFromUser(self, self.tc.BackgroundColour, _('Choose a background color'))
        self.update_bgcolor(newcolor)

    def update_bgcolor(self, newcolor):

        if newcolor.IsOk():
            self.tc.BackgroundColour = newcolor


        if self.prefmode or self.aimprofile:
            wx.CallAfter(self.SaveStyle)

        self.tc.Refresh()
        self.tc.SetFocus()


    def ApplyStyleGUIless(self, flag=None):
        tc = self.tc

        font     = tc.GetFont()
        fontsize = font.GetPointSize()

        weight = font.Weight == wx.FONTWEIGHT_BOLD
        style = font.Style == wx.FONTSTYLE_ITALIC
        underline = font.Underlined

        if flag == 'bold': weight = not weight
        if flag == 'italic': style = not style
        if flag == 'underline':  underline = not underline

        font= CopyFont(font,
                       pointSize = fontsize,
                       style     = wx.ITALIC if style else wx.NORMAL,
                       weight    = wx.FONTWEIGHT_BOLD if weight else wx.NORMAL,
                       underline = underline)

        # setting the font twices fixes a bug.
        tc.Font = font
        tc.SetFont(font)

        fgc = tc.ForegroundColour
        tc.ForegroundColour = wx.BLACK
        tc.ForegroundColour = fgc

        if self.prefmode or self.aimprofile:
            wx.CallAfter(self.SaveStyle)

        self.tc.SetFocus()

    shiftToSend = prefprop("messaging.shift_to_send", False)

    def OnKey(self, event):
        """
            This detects key presses, runs entercallback if enter or return is pressed
            Any other key continues as normal, then refreshes the font and size info
        """
        keycode = event.KeyCode


        shiftToSend = self.shiftToSend
        hasModifiers = event.HasModifiers()
        shiftIsDown = event.Modifiers == wx.MOD_SHIFT
        ctrlIsDown = event.Modifiers == wx.MOD_CONTROL

        if keycode in (wx.WXK_RETURN, wx.WXK_NUMPAD_ENTER):
            # if there is a enter callback and no modifiers are down or if
            # shift should send and shift is down, call the callback
            if self.entercallback and \
                    (not (shiftToSend or hasModifiers or shiftIsDown) or \
                     (shiftToSend and shiftIsDown)):
                return self.entercallback(self)
            else:
                event.Skip()

        if not ctrlIsDown:
            return event.Skip()

        if wxMSW:
            # make Ctrl+R and Ctrl+L modify the RTL setting of the rich edit
            # control, not just the alignment.
            from gui.toolbox import set_rich_layoutdirection
            if keycode == ord('R'):
                set_rich_layoutdirection(self.tc, wx.Layout_RightToLeft)
                return
            elif keycode == ord('L'):
                set_rich_layoutdirection(self.tc, wx.Layout_LeftToRight)
                return

        if keycode == ord('B'):
            if hasattr(self, 'bbold'):
                self.bbold.Active()
                self.ApplyStyle()
            else:
                self.ApplyStyleGUIless('bold')
            return

        elif keycode == ord('I'):
            if hasattr(self, 'bitalic'):
                self.bitalic.Active()
                self.ApplyStyle()
            else:
                self.ApplyStyleGUIless('italic')
            return

        elif keycode == ord('U'):
            if hasattr(self, 'bunderline'):
                self.bunderline.Active()
                self.ApplyStyle()
            else:
                self.ApplyStyleGUIless('underline')
            return

        event.Skip()

    def Clear(self):
        """
            Clears the text from the text field
        """
        tc = self.tc

        if 'wxMSW' in wx.PlatformInfo:
            # Clear() removes any alignment flags that are set in the text control, so
            # reset them
            alignment = cgui.GetRichEditParagraphAlignment(tc)
            tc.Clear()
            if cgui.GetRichEditParagraphAlignment(tc) != alignment:
                cgui.SetRichEditParagraphAlignment(tc, alignment)
        else:
            tc.Clear()

    def UpdateDisplay(self):
        """
            Update the values of Font and Size buttons and the states of
            the bold, italic, and underline buttons based on selection or
            cursor posirion
        """
        with self.tc.Frozen():

            tc = self.tc

            font     = tc.GetFont()
            fontface = font.GetFaceName()
            fontsize = font.GetPointSize()


            bold = font.Weight == wx.FONTWEIGHT_BOLD
            italic = font.Style == wx.FONTSTYLE_ITALIC
            underline = font.Underlined

            # Set Bold, Italic, and Underline buttons
            if self.formatbar is not None:
                self.bbold.Active(bold)
                self.bitalic.Active(italic)
                self.bunderline.Active(underline)

                i = self.fontdd.FindString(fontface, False)
                self.fontdd.SetSelection(i)

                self.bsize.SetLabel(str(fontsize))
                self.bsize.Refresh()

    def ToggleBold(self, event):
        """
            Toggles the bold value of the selection
            or calls Applystyle in no selection
        """
        self.ApplyStyle()

    def ToggleItalic(self, event):
        """
            Toggles the italics state of the selection
            or calls Applystyle in no selection
        """
        self.ApplyStyle()

    def ToggleUnderline(self,event):
        'Toggles underline state of selection or calls Applystyle in no selection.'

        self.ApplyStyle()

    def ApplyStyle(self):
        'Sets the style at the cursor.'

        tc = self.tc

        style     = self.bitalic.active
        weight    = self.bbold.active
        underline = self.bunderline.active

        font= CopyFont(self.fontdd.GetClientData(self.fontdd.GetSelection()),
                       pointSize = int(self.bsize.label),
                       style     = wx.ITALIC if style else wx.NORMAL,
                       weight    = wx.FONTWEIGHT_BOLD if weight else wx.NORMAL,
                       underline = underline)

        tc.Font = font
        tc.SetFont(font)

        fgc = tc.ForegroundColour
        tc.ForegroundColour = wx.BLACK
        tc.ForegroundColour=fgc

        if self.prefmode or self.aimprofile:
            wx.CallAfter(self.SaveStyle)

        self.tc.SetFocus()

    def OnFontSelect(self, event):
        """
            Updates the button to the new font and applies it to the selection
            or calls ApplyStlye
        """
        self.ApplyStyle()

    def OnSizeMenu(self,item):
        """
            Updates the Size button to the new size and apllies it to the selection
            or calls ApplyStyle
        """
        self.bsize.SetLabel(item.content[0])

        self.ApplyStyle()

    def SetSizes(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([size], method = self.OnSizeMenu) for size in sizes]
コード例 #12
0
ファイル: imtabs.py プロジェクト: sgricci/digsby
class ImFrame(wx.Frame):
    '''
    The frame around conversation tabs.
    '''

    WindowName = u'IM Window'

    def __init__(self, pos=None, size=None, startMinimized=False, posId=''):
        if pref('imwin.ads', type=bool, default=False):
            defaultSize = wx.Size(490, 470)
        else:
            defaultSize = wx.Size(470, 390)

        wininfo, placement = preLoadWindowPos(ImFrame.WindowName,
                                              uniqueId=posId,
                                              defaultPos=wx.Point(200, 200),
                                              defaultSize=defaultSize)
        wininfo['style'] |= wx.DEFAULT_FRAME_STYLE

        setPos = pos is not None
        setSize = size is not None

        if setPos or setSize:
            wininfo['style'] &= ~wx.MAXIMIZE

        if startMinimized:
            wininfo['style'] |= wx.ICONIZE
            self._starting_minimized = True  # see comment in imhub.py's frame_show function

        wininfo['style'] |= wx.FULL_REPAINT_ON_RESIZE

        wx.Frame.__init__(self,
                          parent=None,
                          name=ImFrame.WindowName,
                          **wininfo)

        self.on_engaged_start = Delegate()
        self.on_engaged_end = Delegate()
        self.on_sent_message = Delegate()

        # FIXME: Currently the IM window appearance is set by a load-time switch, as I want to first test
        # to ensure altering appearance.skin for Mac doesn't have other side-effects.
        if config.nativeIMWindow:
            import gui.imwin.imwin_native
            self.notebookPanel = gui.imwin.imwin_native.NativeNotebookPanel(
                self, -1)
            self.eventHandler = gui.imwin.imwin_native.NativeIMFrameEventHandler(
                self)
        else:
            preview = None
            if config.platform == 'win':
                preview = ImTabController
            self.notebookPanel = SkinnedNotebookPanel(self,
                                                      -1,
                                                      preview=preview)
            self.eventHandler = SkinnedIMFrameEventHandler(self)

        from gui.imwin.imwin_ads import construct_ad_panel
        ad_panel = construct_ad_panel(self, self.notebookPanel,
                                      self.notebookPanel.notebook.did_add)
        self.notebook.winman = TabWindowManager(
            lambda pos, size=None: ImFrame(pos=pos, size=size))

        if placement is not None and not (setPos or setSize):
            with traceguard:
                from gui.toolbox import SetWindowPlacement
                SetWindowPlacement(self, placement)

        if setPos:
            self.Position = pos
        if setSize:
            self.Size = size

        if not config.nativeIMWindow:
            self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

        self.posId = posId

        self.EnsureInScreen()
        if pos is not None:
            wx.CallAfter(self.EnsureNotStacked)

        # obey always on top and snapping prefs
        profile.prefs.link(IMWIN_ALWAYS_ON_TOP_PREF,
                           self.on_always_on_top,
                           callnow=not startMinimized)
        snap_pref(self)

        self.iconizecallbacks = set()

        Bind = self.Bind
        Bind(wx.EVT_ICONIZE, self.OnIconize)

        memory_event()

        def gainfocus(e):
            if e.Active:
                self._startengage()
            else:
                self._endengage()

            e.Skip()

        Bind(wx.EVT_ACTIVATE, gainfocus)

        self.register_hooks()

    def register_hooks(self):
        if getattr(ImFrame, 'did_register_hooks', False):
            return

        ImFrame.did_register_hooks = True
        ImFrame.engage_is_idle = False

        def goidle():
            ImFrame.engage_is_idle = True
            for win in all_imframes():
                win._endengage()
            return True

        def unidle():
            ImFrame.engage_is_idle = False
            for win in all_imframes():
                if win.IsActive():
                    win._startengage()
            return True

        def idle_ms(ms_idle_time):
            if not ImFrame.engage_is_idle and ms_idle_time > IMWIN_STAT_IDLE_TIME:
                goidle()
            elif ImFrame.engage_is_idle and ms_idle_time < IMWIN_STAT_IDLE_TIME:
                unidle()
            return 15 * 1000  #request check in 15 second intervals

        hooks.register('digsby.app.idle', idle_ms)

        # win7 taskbar hook
        import cgui
        if config.platform == 'win' and cgui.isWin7OrHigher():
            from gui.native.win.taskbar import set_overlay_icon, get_tab_notebook

            def icon_updated(imwin):
                get_tab_notebook(imwin.Top).InvalidateThumbnails(imwin)

                def later():
                    if wx.IsDestroyed(imwin): return
                    set_overlay_icon(im_badge(), tlw=imwin.Top)

                wx.CallLater(300, later)

            hooks.register('digsby.overlay_icon_updated', icon_updated)

    def _startengage(self):
        self._endengage()
        #CAS: crossplatform?
        self.start_time = default_timer()
        self.on_engaged_start()

    def _endengage(self):
        if hasattr(self, 'start_time'):
            diff = max(int(default_timer() - self.start_time), 0)
            del self.start_time
            hooks.notify('digsby.statistics.imwin.imwin_engage', diff)
            self.on_engaged_end()

    cycleTitle = prefprop('conversation_window.cycle_unread_ims')
    shouldFlash = prefprop('conversation_window.notify_flash')

    def OnIconize(self, event=None):
        self._didoniconize = True
        if event is not None:
            event.Skip()

        if event is not None and not event.Iconized(
        ) and not self.OnTop and pref(IMWIN_ALWAYS_ON_TOP_PREF, False):
            self.OnTop = True

        for callback in set(self.iconizecallbacks):
            try:
                callback()
            except PyDeadObjectError:
                self.iconizecallbacks.remove(callback)

    @property
    def notebook(self):
        if hasattr(self, "notebookPanel") and self.notebookPanel:
            return self.notebookPanel.notebook

        return None

    @property
    def AnyNotified(self):
        return any(iwin.Tab.notified for iwin in self)

    # FIXME: These iter methods aren't compatible with the native IM Window, and IMHO if we use
    # them somewhere we should replace them with a ImFrame.Tabs accessor rather than making the
    # frame itself an iterator for its tabs.
    def __iter__(self):
        if config.nativeIMWindow:
            assert True  # just assert so we know where we hit this from
        return iter(p.Content for p in self.notebook.Pages())

    def __getitem__(self, n):
        if config.nativeIMWindow:
            assert True  # just assert so we know where we hit this from
        return self.notebook.Pages()[n].Content

    def GetTabCount(self):
        return self.notebook.GetTabCount()

    def AddTab(self, ctrl, focus=None):
        return self.notebook.Add(ctrl, focus=focus)

    @bind('ImFrame.Tabs.CloseIfNotLast')
    def CloseTabIfNotLast(self):
        if self.notebook.GetTabCount() > 1:
            tab = self.notebook.ActiveTab
            self.notebook.CloseTab(tab)

    @bind('ImFrame.Tabs.CloseActive')
    def CloseActiveTab(self):
        tab = self.notebook.ActiveTab
        self.notebook.CloseTab(tab)

        if self.notebook.GetTabCount() < 1:
            self.Close()

    @bind('ImFrame.Tabs.NextTab')
    def NextTab(self):
        self.notebook.NextTab()

    @bind('ImFrame.Tabs.PrevTab')
    def PrevTab(self):
        self.notebook.PrevTab()

    @bind('ImFrame.ChatWindow.IncreaseTextSize')
    def IncreaseTextSize(self):
        self.ActiveMessageArea.IncreaseTextSize()

    @bind('ImFrame.ChatWindow.DecreaseTextSize')
    def DescreaseTextSize(self):
        self.ActiveMessageArea.DecreaseTextSize()

    @bind('ImFrame.ChatWindow.ResetTextSize')
    def ResetTextSize(self):
        self.ActiveMessageArea.ResetTextSize()

    @property
    def ActiveMessageArea(self):
        # TODO: no.
        return self.notebook.ActiveTab.page.Content.message_area

    def CloseAndSaveState(self, e):
        # Confirm multiple tab close
        tabcount = self.GetTabCount()

        if e.CanVeto() and tabcount > 1 and pref(WARN_PREF, True):
            with CloseTabsDialog(self, tabcount, True) as diag:
                diag.CenterOnParent()
                res = diag.ShowModal()

                if not diag.WarnMe:
                    setpref(WARN_PREF, False)

                if res == wx.ID_CANCEL:
                    return False

        self.Hide()
        saveWindowPos(self, uniqueId=self.posId)  # Save our window position

        # Call each IMWin's on_close method.
        if not config.nativeIMWindow:
            for page in self.notebook.Pages():
                page.Children[0].on_close()

        memory_event()
        return True

    def __repr__(self):
        return '<%s %s>' % (self.__class__.__name__, id(self))

    def on_always_on_top(self, val):
        'Invoked when "conversation_window.always_on_top" preference changes.'

        self.OnTop = val

    def UpdateSkin(self):
        wx.CallAfter(self.Layout)
コード例 #13
0
ファイル: imtabs.py プロジェクト: sgricci/digsby
class SkinnedIMFrameEventHandler(wx.EvtHandler):
    '''
    A generic frame that can hold tabs. Sets up the TabManager and WinManager for uberbook

    TODO: move this logic/functionality to uberbook.py where it belongs
    '''
    def __init__(self, frame):
        wx.EvtHandler.__init__(self)

        self.frame = frame
        self.notebook = self.frame.notebookPanel.notebook

        self.mergetimer = None
        self.notifiedtabs = oset()
        self.titletimer = TitleBarTimer(self.frame, self.notifiedtabs)

        self.BindEventsToFrame()

    def BindEventsToFrame(self):
        Bind = self.frame.Bind
        Bind(wx.EVT_CLOSE, self.OnClose)
        Bind(wx.EVT_MOVE, self.OnMove)
        Bind(wx.EVT_SIZE, self.OnSize)
        Bind(wx.EVT_ACTIVATE, self.OnActivate)
        Bind(EVT_TAB_NOTIFIED, self.OnTabNotify)

        publisher = pubsub.Publisher()
        publisher.subscribe(self.OnPageTitleUpdated, 'tab.title.updated')
        publisher.subscribe(self.OnPageIconUpdated, 'tab.icon.updated')

    def OnClose(self, event):
        if self.frame.CloseAndSaveState(event):
            self.frame.Destroy()
        else:
            event.Veto()

    def OnActivate(self, e):
        # when window activates, focus the IM input area
        e.Skip()
        if e.GetActive():
            tab = self.notebook.ActiveTab
            if tab is not None:
                # ensure the active tab becomes unnotified
                tab.SetNotify(False)

                # focus the input area
                tab.page.Content.FocusTextCtrl()

        if self.titletimer.IsRunning():
            self.titletimer.Stop()

    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 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)

    flashTime = prefprop('conversation_window.flash_time')
    flashCount = prefprop('conversation_window.flash_count')

    def OnTabNotify(self, event):
        tab = event.tab

        if tab.notified:
            self.notifiedtabs.add(tab)
            notify_unread_message_hook()
        elif tab in self.notifiedtabs:
            self.notifiedtabs.remove(tab)
            notify_unread_message_hook()
            return
        else:
            return

        if not self.frame.cycleTitle:
            if self.frame.shouldFlash:
                Flash(self.frame,
                      timeout=self.flashTime,
                      count=self.flashCount)
            return

        if len(self.notifiedtabs) and not self.frame.IsActive():
            if not self.titletimer.IsRunning():
                self.titletimer.Start()
        elif self.titletimer.IsRunning():
            self.titletimer.Stop()

    def OnMove(self, event):
        event.Skip(True)

        # check if we need to move to a window underneath
        if pref('messaging.tabs.enabled', True):

            mt = self.mergetimer
            if mt is None:
                self.mergetimer = wx.CallLater(10,
                                               self.notebook.StartWindowDrag)
            else:
                mt.Start(10)

        event.Skip(True)

    def OnSize(self, event):
        mt = self.mergetimer
        if mt is not None:
            # cancel the move check if we're resizing the top left corner
            mt.Stop()

        event.Skip(True)
コード例 #14
0
ファイル: umenu.py プロジェクト: sgricci/digsby
class MenuListBox(SkinVListBox):
    'VListBox acting as a view for a wxMenu.'

    def __init__(self, parent, menu):
        SkinVListBox.__init__(self,
                              parent,
                              style=wx.NO_BORDER | wx.FULL_REPAINT_ON_RESIZE
                              | wx.WANTS_CHARS)

        self.menu = menu
        self.UpdateSkin()

        self.timer = wx.PyTimer(self._on_submenu_timer)

        Bind = self.Bind
        Bind(wx.EVT_MOUSE_EVENTS, self._mouseevents)
        Bind(wx.EVT_MOUSE_CAPTURE_CHANGED, self._capturechanged)
        Bind(wx.EVT_LISTBOX, self._listbox)
        Bind(wx.EVT_KEY_DOWN, self._keydown)

        self.mouseCallbacks = {
            wx.wxEVT_MOTION: self._motion,
            wx.wxEVT_RIGHT_DOWN: self._rdown,
            wx.wxEVT_LEFT_DOWN: self._ldown,
            wx.wxEVT_LEFT_UP: self._lup
        }

        MenuListBox._lastvlist = ref(self)

    def reassign(self, menu):
        self.menu = menu

    menuOpenDelayMs = prefprop('menus.submenu_delay', 250)

    def __repr__(self):
        return '<%s for %r>' % (self.__class__.__name__, self.menu)

    @property
    def ParentPopup(self):
        pmenu = self.menu._parentmenu
        return None if pmenu is None else pmenu.popup.vlist

    def CalcSize(self):
        'Calculates the width and height of this menu.'

        self.SetItemCount(len(self.menu))

        height = 0
        dc = wx.MemoryDC()
        dc.Font = self.font
        s = self.skin
        padx = self.padding[0]
        iconsize = s.iconsize
        subw = s.submenuicon.Width
        sepheight = s.separatorimage.Size.height
        itemheight = self.itemheight
        textExtent = dc.GetTextExtent

        labelw = accelw = 0

        for item in self.menu:
            if item.Kind == ITEM_SEPARATOR:
                height += sepheight
            else:
                height += itemheight

                # keep the heights for the widest label and accelerator
                labelw = max(labelw, textExtent(item.Label)[0])
                accelw = max(accelw, textExtent(item.AccelText)[0])

        # store an x coordinate for where to draw the accelerator
        self.accelColumnX = padx + iconsize + padx + padx + labelw + padx

        # sum those biggest widths with the other elements to come up with a total width
        width = self.accelColumnX + padx + max(accelw, subw) + padx
        self.MinSize = self.Size = (wx.Size(width, height))

    def OnDrawItem(self, dc, rect, n):
        'Invoked by VListBox to draw one menu item'

        item = self.menu[n]
        kind = item.Kind
        s = self.skin
        iconsize = s.iconsize
        submenuicon = s.submenuicon
        padx = self.padding.x
        selected = self.IsSelected(n)

        drawbitmap, drawlabel = dc.DrawBitmap, dc.DrawLabel

        if kind == ITEM_SEPARATOR:
            s.separatorimage.Draw(dc, rect, n)
        else:
            dc.Font = self.font

            if not item.IsEnabled(): fg = 'disabled'
            elif selected: fg = 'selection'
            else: fg = 'normal'
            dc.TextForeground = getattr(s.fontcolors, fg)

            grect = Rect(*rect)
            grect.width = padx + iconsize + padx

            # icon bitmap
            bmap = item.Bitmap
            if bmap and bmap.Ok():
                bmap = bmap.ResizedSmaller(iconsize)
                drawbitmap(bmap, grect.HCenter(bmap), rect.VCenter(bmap), True)

            # checks and radio circles
            if item.IsCheckable() and item.IsChecked():
                # if there is a menu icon, show the check in the bottom right
                # otherwise center it
                if bmap: checkx = grect.Right - s.checkedicon.Width
                else: checkx = grect.HCenter(s.checkedicon)

                if kind == ITEM_CHECK:
                    drawbitmap(s.checkedicon, checkx,
                               rect.VCenter(s.checkedicon), True)
                elif kind == ITEM_RADIO:
                    drawbitmap(s.checkedicon, checkx,
                               rect.VCenter(s.checkedicon), True)

            # main label
            rect.Subtract(left=iconsize + 3 * padx)
            drawlabel(item.Label,
                      rect,
                      indexAccel=item.Text.split('\t')[0].find('&'),
                      alignment=ALIGN_CENTER_VERTICAL)

            # submenu icon
            rect.Subtract(right=submenuicon.Width + padx)
            if item.SubMenu is not None:
                drawbitmap(submenuicon, rect.Right, rect.VCenter(submenuicon),
                           True)

            # accelerator text
            acceltext = item.AccelText
            if acceltext:
                rect.x = self.accelColumnX + padx
                drawlabel(acceltext, rect, alignment=ALIGN_CENTER_VERTICAL)

    def OnDrawBackground(self, dc, rect, n):
        s = self.skin
        bgs = s.backgrounds

        bgname = 'selection' if self.menu[
            n].Kind != ITEM_SEPARATOR and self.IsSelected(n) else 'item'
        bg = getattr(bgs, bgname, None)
        if bg: bg.Draw(dc, rect, n)

    def PaintMoreBackground(self, dc, rect):
        'Invoked by SkinnedVList, used to draw the gutter.'

        # draw a gutter down the length of the menu
        g = self.skin.backgrounds.gutter
        if g:
            g.Draw(
                dc,
                Rect(rect.x, rect.y, self.skin.iconsize + self.padding.x * 2,
                     rect.height))

    def OnMeasureItem(self, n):
        item = self.menu[n]
        kind = item.Kind

        if kind == ITEM_SEPARATOR:
            return self.sepheight
        else:
            return self.itemheight

    def OnPopup(self):
        parentless = self.TopMenu == self.menu

        if parentless:
            # call ReleaseCapture here on windows to prevent the control that
            # spawned this menu from keeping capture--another right click
            # should open a new menu, not the same menu (see #1995)
            if wxMSW:
                ReleaseCapture_win32()

            if self.menu.Windowless:
                if not hasattr(self, 'traytimer'):
                    self.traytimer = UMenuTrayTimer(self)
                self.traytimer.Start(50)

        if not self.menu._parentmenu:
            self._grabkeyboard()

        if wx.LeftDown():
            self._leftbuttondown = True

        if not self.HasCapture():
            self.CaptureMouse()
        self.SetCursor(StockCursor(CURSOR_DEFAULT))
        self.SetFocus()

    def Dismiss(self):

        if hasattr(self, 'traytimer'):
            self.traytimer.Stop()

        if self.menu._childmenu:
            self.menu._childmenu.Dismiss()
            self.menu._childmenu = None

        while self.HasCapture():
            self.ReleaseMouse()

        self.Parent.Hide()

        m = self.menu
        if m._parentmenu is None:

            if hasattr(self, 'focusHandler'):
                self.focusHandler.close()
                del self.focusHandler

            wx.CallAfter(self.menu.OnDismiss)

        else:
            m._parentmenu._childmenu = None

    def DismissRoot(self):
        self.TopMenu.Dismiss()

    @property
    def TopMenu(self):
        m = self.menu
        while m._parentmenu is not None:
            m = m._parentmenu

        return m

    def UpdateSkin(self):
        self.SetMargins(wx.Point(0, 0))
        s = self.skin = self.menu.skin
        self.sepheight = s.separatorimage.Size.height

        try:
            self.font = s.font
        except KeyError:
            self.font = default_font()

        self.fontheight = s.font.Height

        try:
            self.padding = s.padding
            assert isinstance(self.padding.x, int) and isinstance(
                self.padding.y, int)
        except Exception:
            self.padding = wx.Point(3, 3)

        self.itemheight = int(self.fontheight + self.padding.y * 2)

        self.Background = s.backgrounds.menu

    @property
    def Window(self):
        return self.menu.Window

    def _grabkeyboard(self):
        if 'wxMSW' in wx.PlatformInfo:
            f = wx.Window.FindFocus()
        elif "wxGTK" in wx.Platform:
            f = self
        else:
            f = None
        if f:
            self.focusHandler = FocusHandler(self, f)

    def _showsubmenu(self, i, highlight=False):
        item = self.menu[i]
        submenu = item.SubMenu
        child = self.menu._childmenu

        if child is submenu:  # early exit if menu is already open
            return

        if child is not None:  # dismiss the current child submenu if there is one
            if child: child.Dismiss()
            self.menu._childmenu = None

        # open the new submenu if there is one
        if i != -1 and submenu is not None:
            r = self.ClientRect
            r.Y = self.GetItemY(i)
            r.Height = self.OnMeasureItem(i)
            self.menu._childmenu = submenu
            submenu._parentmenu = self.menu
            submenu._parentindex = i
            submenu.PopupMenu(r.ToScreen(self), submenu=True)
            if highlight: submenu.popup.vlist.Selection = 0

    def _on_submenu_timer(self):
        'Invoked after a certain duration of mouse hover time over a menu item.'

        i = self.Selection
        if i != -1 and self.IsShown() and FindWindowAtPointer() is self:
            self._showsubmenu(i)

    def _listbox(self, e):
        '''
        Invoked on listbox selection (i.e., the mouse moving up or down the
        list.
        '''

        self.timer.Start(self.menuOpenDelayMs, True)

    def _emit_menuevent(self, id, type=wx.wxEVT_COMMAND_MENU_SELECTED):
        event = wx.CommandEvent(type, id)
        self.menu.Handler.AddPendingEvent(event)

    # mouse handling

    def _mouseevents(self,
                     e,
                     wxEVT_MOTION=wxEVT_MOTION,
                     FindWindowAtPoint=FindWindowAtPoint,
                     UberButton=UberButton):
        rect = self.ClientRect
        pt_original = pt = e.Position

        if not rect.Contains(pt):
            menu = self.ParentPopup

            # forward mouse events to Parent, since we're capturing the mouse
            oldmenu = self
            while menu:
                pt = menu.ScreenToClient(oldmenu.ClientToScreen(pt))

                if menu.ClientRect.Contains(pt):
                    e.m_x, e.m_y = pt
                    return menu._mouseevents(e)

                oldmenu, menu = menu, menu.ParentPopup

            # when mousing over a menubar, we need to trigger other buttons
            try:
                button = self.TopMenu._button
            except AttributeError:
                # not in a menubar
                pass
            else:
                if e.GetEventType() == wxEVT_MOTION:
                    ctrl = FindWindowAtPoint(self.ClientToScreen(e.Position))
                    if ctrl is not None:
                        if getattr(self, '_motionswitch', -1) is ctrl:
                            # use _motionswitch to make sure the mouse actually /moves/
                            # over the button, and we're not just receiving an event for when
                            # it appears.
                            self._motionswitch = None
                            self.DismissRoot()
                            ctrl.menu._showquick = True
                            ctrl.OnLeftDown()
                        elif isinstance(
                                ctrl,
                                UberButton) and ctrl.menubarmode and hasattr(
                                    ctrl, 'menu'):
                            # check to see if the button being hovered over is for a menu
                            # on the same menubar
                            if ctrl.Parent is button.Parent and not ctrl is button:
                                self._motionswitch = ctrl

        e.m_x, e.m_y = pt_original
        try:
            cb = self.mouseCallbacks[e.EventType]
        except KeyError:
            pass
        else:
            cb(e)

    def _motion(self, e):
        # changes selection as mouse moves over the list
        p = e.Position
        i = self.HitTest(p) if self.ClientRect.Contains(p) else -1
        s = self.Selection

        if i != s:
            # if we're a submenu and our parent's selection doesn't point to us,
            # make it so
            p = self.ParentPopup
            if p is not None:
                pi = getattr(self.menu, '_parentindex', None)
                if pi is not None and p.Selection != pi:
                    p.Selection = pi

            self.SetSelection(i)
            self._emit_lbox_selection(i)

    @property
    def LeafMenu(self):
        s = self.menu

        while s._childmenu:
            s = s._childmenu

        return s

    def _keydown(self, e):
        # keys always go to the deepest child menu
        self = self.LeafMenu.popup.vlist

        code = e.KeyCode
        i, j, m = self.Selection, -1, self.menu

        if code == wx.WXK_DOWN:
            j = (i + 1) % len(m)
            while j != i and m[j].Kind == wx.ITEM_SEPARATOR:
                j = (j + 1) % len(m)

        elif code == wx.WXK_UP:
            if i == -1: i = len(m)
            j = (i - 1) % len(m)
            while j != i and m[j].Kind == wx.ITEM_SEPARATOR:
                j = (j - 1) % len(m)

        elif code == wx.WXK_RETURN:
            return self._activate_item(i, submenu=True, highlight=True)

        elif code == wx.WXK_RIGHT:
            if i == -1:
                pass  # skip menus
            elif m[i].SubMenu is not None:
                self.timer.Stop()
                return self._showsubmenu(i, highlight=True)

            # see if the top level menu has a "_next" menu
            while m._parentmenu:
                m = m._parentmenu
            next = getattr(m, '_next', None)

            if next is not None:
                wx.CallAfter(self.DismissRoot)
                next._showquick = True
                wx.CallAfter(next._button.OnLeftDown)

        elif code == wx.WXK_ESCAPE:
            self.Dismiss()

        elif code == wx.WXK_LEFT:
            if m._parentmenu:
                self.Dismiss()
            else:
                prev = getattr(self.menu, '_prev', None)
                if prev is not None:
                    wx.CallAfter(self.DismissRoot)
                    prev._showquick = True
                    wx.CallAfter(prev._button.OnLeftDown)

        elif code < 256:
            self._on_char(unichr(e.UnicodeKey))

        if j != -1:
            self.SetSelection(j)

    def _on_char(self, char):
        '''
        Pressing a printable character on an opened menu...
          a) there is an underlined character--pressing the key immediately activates that item
          b) there is one item that begins with that key--it is immediately activated
          c) there are multiple items beginning with that key--pressing the key repeatedly cycles
             selection between them
        '''
        char = char.lower()
        items = []

        # Find the first shortcut key preceeded by an &
        for item in self.menu:
            amp_char = GetAmpChar(item)
            if amp_char is not None and char == amp_char.lower():
                return self._activate_item(item, submenu=True, highlight=True)

        # Instead, find all menu items whose first character begins with the
        # one we're looking for.
        items = []

        # Get a range of indexes. If there's already a selection, rotate the
        # range so that we see items underneath the selection first.
        for i in rotated(range(0, len(self.menu)), -self.Selection - 1):
            item = self.menu[i]
            label_text = item.GetItemLabelText()
            if label_text and label_text[0].lower() == char:
                items.append(i)

        if len(items) == 1:
            # only one item--activate it immediately
            self._activate_item(items[0], submenu=True, highlight=True)
        elif len(items) > 1:
            # more than one item--select the first.
            self.SetSelection(items[0])

    def _rdown(self, e):
        p, rect = e.Position, self.ClientRect

        # right mouse click outside of any menu dismisses them all
        if not rect.Contains(p): return self.DismissRoot()

    def _ldown(self, e):
        p, rect = e.Position, self.ClientRect

        # a mouse click outside of a menu causes all the menus to close from
        # the top
        if not rect.Contains(p):
            return self.DismissRoot()

        i = self.HitTest(p)

        if i != -1:
            if self.menu[i].SubMenu is not None:
                # if clicking a submenu item, show the submenu
                self.timer.Stop()
                return self._showsubmenu(i)

    def _lup(self, e):
        p = e.Position

        i = self.HitTest(e.Position)
        if self.ClientRect.Contains(p):
            self._activate_item(i)
        else:
            ctrl = FindWindowAtPointer()
            if not isinstance(ctrl, UberButton) or not ctrl.type == 'menu':
                self.DismissRoot()

    def _activate_item(self, i, submenu=False, highlight=False):
        'Triggers item i (or item at position i).'

        if isinstance(i, int):
            if i == -1: return
            item = self.menu[i]
        else:
            item = i
            i = self.menu.IndexOf(item)

        if submenu:
            if item.SubMenu is not None:
                # if clicking a submenu item, show the submenu
                self.timer.Stop()
                if not self.Selection == i:
                    self.SetSelection(i)
                return self._showsubmenu(i, highlight=highlight)

        if item.Kind != ITEM_SEPARATOR and item.IsEnabled(
        ) and item.SubMenu is None:
            # clicking anything else that's enabled and not a separator
            # emits an event.
            if item.IsCheckable(): item.Check(not item.IsChecked())
            self._emit_menuevent(item.Id)
            self.DismissRoot()

    def _capturechanged(self, e):
        # MouseCaptureChangeEvent never seems to have the captured window...so this
        # hack (check for the active window later) will have to do.

        def active():
            try:
                if self.menu.Windowless or not hasattr(self.menu.Window.Top,
                                                       'IsActive'):
                    return True  # wx.GetApp().IsActive()
                else:
                    return self.menu.Window.Top.IsActive()
            except Exception:
                print_exc()
                return True

        if not active():
            wx.CallAfter(lambda: self.DismissRoot())
コード例 #15
0
class SpellCheckTextCtrlMixin(object):
    def __init__(self):

        #these hold a set of information for the last time the field has been
        #spellchecked to check against to prevent redundant checks
        self.lastvalue = self.Value
        self.lastcharcount = len(self.Value)
        self.lastinsertion = self.InsertionPoint
        self.lastcurrentword = None
        self.needscheck = False
        self.lastkeycode = None
        self.lastchar = None

        self.regex_ignores = []

        self.spellcheckon = frozenset(punc + ' ')
        self.spellerrors = dict()

        Bind = self.Bind
        Bind(wx.EVT_KEY_DOWN, self.OnKey)
        Bind(wx.EVT_TEXT, self.OnText)
        Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)

        WM_PAINT = 0x000F  #Native Windows Paint Message, thanks MSDN or a source file, I don't remember
        BindWin32 = self.BindWin32
        BindWin32(WM_PAINT, self.WMPaint)

        wx.CallAfter(self.SpellCheckAll)

        link = profile.prefs.link
        link('messaging.spellcheck.enabled', self.UpdateEnablement)
        link('messaging.spellcheck.engineoptions.lang', self.UpdateEnablement)
        link('messaging.spellcheck.engineoptions.keyboard',
             self.UpdateEnablement)
        self.UpdateEnablement()

    def HasSpellingErrors(self):
        return bool(self.spellerrors)

    def AddRegexIgnore(self, regex):
        self.regex_ignores.append(regex)

    def RemoveRegexIgnore(self, regex):
        try:
            self.regex_ignores.remove(regex)
        except ValueError:
            return False
        else:
            return True

    def UpdateEnablement(self, *a):
        """
            Updates the display and spell errors when the spellcheck options are changed
        """

        #FIXME: Need a way to un-observe after and object is destroyed
        if not wx.IsDestroyed(self):
            spenabled = self.spenabled = pref('messaging.spellcheck.enabled')

            if spenabled:
                self.SpellCheckAll()
            else:
                self.spellerrors.clear()
                self.Refresh()

        else:
            log.error(
                'UpdateEnablement observer called on a SpellCheckTextCtrlMixin that has been destroyed'
            )

    def WMPaint(self, hWnd, msg, wParam, lParam):
        wx.CallAfter(self.PostPaint)

    spsize = 2  #The thickness of the line
    spstyle = wx.DOT  #The type of line used for spellcheck

    def PostPaint(self):
        """
            After the text is done painting, draw the spellcheck markup over it
        """

        try:
            # text control must implement GetReqHeight
            bottom = self.GetReqHeight()
        except AttributeError:
            return

        dc = wx.ClientDC(self)

        dc.Brush = wx.TRANSPARENT_BRUSH  #@UndefinedVariable
        dc.Pen = wx.Pen(wx.RED, self.spsize, self.spstyle)  #@UndefinedVariable

        lastline = self.GetNumberOfLines() - 1

        Point = wx.Point
        PosXY = lambda i: self.PositionToXY(i)[1:]
        XYPos = self.XYToPosition
        IndexToCoords = self.IndexToCoords
        value = self.Value

        for word in self.spellerrors:
            wordlen = len(word)
            for i in self.spellerrors[word]:

                i1 = i
                start = IndexToCoords(i)
                end = IndexToCoords(i + wordlen)

                if PosXY(i)[1] != lastline:
                    ymod = IndexToCoords(XYPos(0,
                                               PosXY(i)[1] + 1))[1] - start.y
                else:
                    ymod = (bottom - start.y) - 8 + IndexToCoords(0).y

                points = []
                while start.y != end.y:
                    r1 = PosXY(i1)[1]
                    i2 = XYPos(0, r1 + 1)
                    e1 = i2 - 1

                    lineend = self.IndexToCoords(e1) + Point(
                        dc.GetTextExtent(value[e1])[0], 0)
                    points.append((start, lineend))

                    i1 = i2
                    start = IndexToCoords(i1)

                points.append((start, end))

                for s, e in points:
                    dc.DrawLine(s.x, s.y + ymod, e.x, e.y + ymod)

    def AddSpellError(self, word, index, refresh=True):
        """
            Adds a misspelled word, or another index of that word to the dictionary of misspelled
            words for lookup later
        """

        if not word in self.spellerrors:
            self.spellerrors[word] = []

        if not index in self.spellerrors[word]:
            self.spellerrors[word].append(index)

        if refresh: self.Refresh()

    def UpdateSpellErrorIndexes(self):
        """
            Offsets all the spellerror indexes by the number of characters that
            have been typed since the last check if the index is higher then the
            last insertion index
        """

        lastinsert = self.lastinsertion
        lastcount = self.lastcharcount

        deltachar = len(self.Value) - lastcount
        spellerrors = self.spellerrors

        for word in spellerrors:
            for n in list(spellerrors[word]):
                if n > lastinsert:
                    i = spellerrors[word].index(n)
                    spellerrors[word][i] = n + deltachar

        self.Refresh()

    def ClearSpellErrors(self):
        """
            Clears all the spell errors
            Note that this does not update the display
        """

        self.spellerrors.clear()

    def RemoveExpiredSpellError(self, start, end, value=None):
        """
            This does various checks to try and dismiss marked errors that are no longer valid
        """

        if value is None:
            value = self.Value

        #URLs are not misspelled so lets get them out of the string
        #urllessWords
        purewords = [
            word for word in value.split() if not self.ignore_word(word)
        ]
        #purewords = ' '.join(urllessWords)

        #validate all the words in the spellerrors dictionary
        for word in set(self.spellerrors):
            wordlen = len(word)

            #if the word is't in the splash zone, don't bother checking it
            if not any(start <= i <= end for i in self.spellerrors[word]):
                continue

            #Remove the mark if the word is in the dictionary or no longer in the textctrl
            if word not in purewords or self.Check(word):
                self.spellerrors.pop(word)

                continue

            #if the word is still marked wrong but the number of instances have changed validate individual indexes
            elif len(self.spellerrors[word]) != purewords.count(word):
                for i in list(self.spellerrors[word]):
                    if value[i:i + wordlen] != word:
                        self.spellerrors[word].remove(i)

        self.Refresh()

    kb_shortcut_fixes = prefprop('messaging.spellcheck.kb_shortcut_fixes',
                                 default=False)

    def OnKey(self, e):
        """
            Key press event handling
            records last key code and the unicode character for that key
        """

        e.Skip()

        if not self.spenabled:
            return

        if self.kb_shortcut_fixes and \
                e.GetModifiers() == wx.MOD_CMD and e.KeyCode == wx.WXK_SPACE:
            e.Skip(False)
            return self.ReplaceWordWithBestSuggestion()

        self.lastchar = e.UnicodeKey
        self.lastvalue = self.Value
        self.lastcharcount = len(self.lastvalue)

        wx.CallAfter(self.PostOnKey)

    def PostOnKey(self):
        """
            Activates spellcheck on last change if a
            navigation or other non-editing key is hit
        """
        val = self.Value
        charcount = len(val)
        if self.needscheck and charcount and val == self.lastvalue:
            self.SpellCheckLastChange()

        self.lastinsertion = self.InsertionPoint
        self.lastcurrentword = self.GetCurrentWord()

    def OnText(self, event):
        """
            Text insertion event, flags the textfield as dirty if the text actually changed
        """

        event.Skip()

        if not self.spenabled or self.Value == self.lastvalue:
            self.Refresh()
            return

        self.needscheck = True

        self.UpdateSpellErrorIndexes()

        charcount = len(self.Value)

        if abs(charcount - self.lastcharcount) == 1:
            keypressed = unichr(self.lastchar) if self.lastchar else None
            currentword = self.GetCurrentWord()

            if ((keypressed in self.spellcheckon)
                    or self.lastcurrentword in self.spellerrors
                    and currentword != self.lastcurrentword):
                self.SpellCheckLastChange()
        else:
            self.SpellCheckAll()

    def UpdateLasts(self):
        """
            Updates variables used to determine if the string should be checked again
        """
        pass

    def Check(self, word):
        '''Returns True if a word should be considered spelled correctly.'''

        return self.ignore_word(word) or spellchecker.Check(word)

    def ignore_word(self, word):
        if word and isurl(word):
            return True

        for regex in self.regex_ignores:
            if regex.match(word):
                return True

        return False

    def SpellCheckAll(self):
        """
            Clears all the errors and re-spellchecks the entire text field
        """

        self.ClearSpellErrors()

        val = self.Value
        span = [word for word in val.split() if not self.ignore_word(word)]
        words = tokenizer_re.split(' '.join(span))

        index = 0

        for word in words:
            word = word.strip(string.punctuation)
            correct = self.Check(word)

            index = val.find(word, index)

            if not correct: self.AddSpellError(word, index, False)

            index += len(word)

        self.needscheck = False

        self.Refresh()

    def OnLeftDown(self, event):
        """
            Event handler to trigger spellcheck on click
        """
        event.Skip()

        if not self.spenabled:
            return

        charcount = len(self.Value)

        if charcount and self.needscheck:
            self.SpellCheckLastChange()

        self.lastinsertion = self.InsertionPoint
        self.lastcurrentword = self.GetCurrentWord()

    def GetCurrentWord(self):
        """
            Get word at cursor position
        """
        return self.GetWordAtPosition(self.InsertionPoint)

    def GetWordRangeAtPosition(self, ip):
        """
            For suggestion menu, only returns the word range using punctuation
            as a word breaking character
        """
        s = self.Value

        # for misspellings like "audio/vedio" we will underline
        # only "vedio." make sure that if you right click it, you
        # get only "vedio" -- the word the cursor is under.
        split_on = word_splitting_chars

        end = FindAny(s, split_on, ip)
        if end == -1: end = len(s)

        start = max(rFindAny(s, split_on, 0, end), 0)
        return start, end

    def GetWordAtPosition(self, ip):
        """
            For suggestion menu, only returns the word range using punctuation
            as a word breaking character
        """
        start, end = self.GetWordRangeAtPosition(ip)
        word = self.Value[start:end].split()
        if word:
            return word[0].strip(string.punctuation)

    def AddWordToDictionary(self, word):
        """
            Add a word, duh
        """
        spellchecker.Add(word)

        self.SpellCheckAll()

    def HitTestSuggestions(self, pos):
        """
            Returns the word under the mouse
        """
        result, col, row = self.HitTest(pos)
        if result == wx.TE_HT_UNKNOWN:
            return -1, []

        i = self.XYToPosition(col, row)
        return i, self.GetSuggestionsForPosition(i)

    def GetSuggestionsForPosition(self, i):
        if i == -1: return []

        word = self.GetWordAtPosition(i)

        if word and word in self.spellerrors:
            return spellchecker.Suggest(word)
        else:
            return []

    def AdjustSpellerrorIndex(self, index, diff):
        """
            This offsets all spellerror index that are highr than index by diff
        """
        spellerrors = self.spellerrors

        for word in spellerrors:
            for n in list(spellerrors[word]):
                if n > index:
                    i = spellerrors[word].index(n)
                    spellerrors[word][i] = n + diff

    def ReplaceWord(self, position, new_word):
        """
            Replaces the word at the position with the new word, and spell checks he area
        """
        oldip = self.InsertionPoint

        old_value = self.Value
        i, j = self.GetWordRangeAtPosition(position)

        old_word = old_value[i:j]

        # Since GetWordRangeAtPosition returns punctuation and whitespace...
        l = len(old_word)
        old_word = old_word.lstrip(nonword_characters)
        i += l - len(old_word)

        l = len(old_word)
        old_word = old_word.rstrip(nonword_characters)
        j -= l - len(old_word)

        self.Replace(i, j, new_word)

        diff = (len(new_word) - len(old_word))
        self.AdjustSpellerrorIndex(position, diff)
        self.InsertionPoint = oldip + diff

        #        self.UpdateSpellErrorIndexes()

        self.SpellCheckLastChange(position)
        self.ProcessEvent(wx.CommandEvent(wx.EVT_TEXT[0], self.Id))

    def ReplaceWordWithBestSuggestion(self, pos=None):
        '''Replaces the word at pos with the spellchecker's best suggestion. Has no
        effect if there are no suggestions.

        If pos is None, the cursor position is used.'''

        pos = pos if pos is not None else self.InsertionPoint
        suggestions = self.GetSuggestionsForPosition(pos)
        if suggestions:
            self.ReplaceWord(pos, suggestions[0])

    # {'word': [1, 56, 34]}

    def SpellCheckLastChange(self, ip=None):
        """
            Figure out a splash area for the last edit and spellcheck everything in it
        """

        # find the start and the end of the possibly relevant area
        val = self.Value
        end = val.find(' ', ip or self.lastinsertion)
        if end != -1: end = val.find(' ', end + 1)
        if end == -1: end = len(val)
        start = val.rfind(' ', 0, end)
        start = val.rfind(' ', 0, start)
        start = max(start, 0)
        start = val.rfind(' ', 0, start)
        start = max(start, 0)

        self.RemoveExpiredSpellError(start, end, value=val)

        # filter out irrelevant words
        span = [
            word for word in val[start:end].split()
            if not self.ignore_word(word)
        ]
        words = tokenizer_re.split(' '.join(span))

        # check all the words
        index = start
        for word in words:
            if not word: continue

            word = word.strip(string.punctuation)
            correct = self.Check(word)

            index = val.find(word, index, end)
            if not correct: self.AddSpellError(word, index)
            index += len(word)

        self.needscheck = False

    def AddSuggestionsToMenu(self, menu):
        return add_spelling_suggestions(self, menu)
コード例 #16
0
ファイル: UberButton.py プロジェクト: sgricci/digsby
class UberButton(UberWidget, wx.PyControl):
    '''
    Skinnable buttons.

    Also acts as a wrapper for wx.Bitmap button to draw native looking buttons
    with icons and labels can be also used to make menu buttons and checkbox
    like toggle buttons.
    '''
    def __init__(self,
                 parent,
                 id=-1,
                 label='',
                 skin=None,
                 icon=None,
                 pos=wx.DefaultPosition,
                 size=None,
                 style=HORIZONTAL,
                 type=None,
                 menu=None,
                 menubarmode=False,
                 onclick=None):
        """
        Usage:
            UberButton(parent,id,label,skin,icon,pos,size,style,type,menu)
            -skin  - instead of detecting skins presence lke most UberGUI
                     this takes the skin as an argument from the parent
                     this allows different skins to be set to different
                     buttons at the same time
                     if not assigned will look OS native

            -icon  - The icon to show up on the button
                     Note: the button resizes to fit the icon, not vice versa

            -pos   - position of the button

            -size  - size of the button, this is actualy ignored and will
                     likely be adjusted to affect restraint size later

            -style - wx.HORIZONTAL - Icon centered over label centered on button
                     wx.VERTICAL - Icon spaced from left with label to the right

            -type  - None - normal button
                     combo - no behavior changes, only changes the drawing code
                             on native butons
                     toggle - button toggles True and False, needs visual
                              notification in native mode
                     menu - does not return an event, adds a dropdown icon
                            to the rightside of the button, when toggled on
                            displays the menu associated to it
            -menu  - the menu to drop down when the button is clicked if
                     type is menu
        """

        wx.PyControl.__init__(self,
                              parent,
                              id=id,
                              pos=pos,
                              style=wx.NO_BORDER | wx.FULL_REPAINT_ON_RESIZE)

        if type == "combo":
            UberWidget.__init__(self, 'COMBOBOX')
        else:
            UberWidget.__init__(self, "button")

        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

        self.label = label
        if label:
            self.RegAccel(label)

        self.notified = False
        self.active = False
        self.isdown = False
        self.hovered = False

        self.state = 1
        self.menu = menu if type == 'menu' else None
        if menu is not None and hasattr(menu, 'OnDismiss'):
            menu.OnDismiss += lambda: self.AddPendingEvent(
                wx.MenuEvent(wx.wxEVT_MENU_CLOSE, menu.Id))

        if icon:
            self.icon = icon
            self.MakeDicon()
        else:
            self.icon = None

        self.style = style
        self.type = type
        self.menubarmode = menubarmode
        self.ssize = wx.Size(0, 0)
        self.staticwidth = None

        if size:
            self.autoscale = False
        else:
            self.autoscale = True

        self.native = None
        self.Sizer = wx.BoxSizer(HORIZONTAL)

        self.SetSkinKey(skin, True)

        Bind = self.Bind
        Bind(wx.EVT_MOVE, lambda e: self.Refresh()),
        Bind(wx.EVT_PAINT, self.OnPaint),
        Bind(wx.EVT_SET_FOCUS, lambda e: self.Refresh()),
        Bind(wx.EVT_KEY_DOWN, self.OnKeyDown),
        Bind(wx.EVT_KEY_UP, self.OnKeyUp),
        Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus),
        Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown),
        Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDown),
        Bind(wx.EVT_LEFT_UP, self.OnLeftUp),
        Bind(wx.EVT_ENTER_WINDOW, self.OnMouseIn),
        Bind(wx.EVT_LEAVE_WINDOW, self.OnMouseOut),
        Bind(wx.EVT_MOTION, self.OnMotion),
        Bind(wx.EVT_MENU_CLOSE, lambda e:
             (self.Active(False), self.OnMouseOut()))
        Bind(wx.EVT_SHOW, self.OnShow)

        if onclick is not None:
            if not hasattr(onclick, '__call__'):
                raise TypeError('onclick must be callable')
            self.Bind(wx.EVT_BUTTON, lambda e: (e.Skip(), onclick()))

    def __repr__(self):
        try:
            return '<UberButton \'%s\'>' % self.label
        except:
            return '<UberButton %s>' % id(self)

    def SetAlignment(self, alignment):
        self.style = alignment
        self.Calcumalate()

    def GetAlignment(self):
        return self.style

    Alignment = property(GetAlignment, SetAlignment)

    #    def SetSize(self,size = None):
    #
    #        self.autoscale = not size
    #
    #        wx.Window.SetSize(self,size or self.ssize)
    #
    #    Size = property(wx.Window.GetSize,SetSize)

    def SetStaticWidth(self, width=None):
        """This forces the button to not auto resize it's width."""

        self.staticwidth = width
        self.Calcumalate()

    def OnMotion(self, event):
        """Ensures mouse release."""

        if self.native:
            event.Skip()
            return

        r = RectS(self.Size)
        if self.HasCapture() and not event.LeftIsDown() and \
            not r.Contains(event.Position):
            self.ReleaseAllCapture()

    @property
    def KeyCatcher(self):
        try:
            return self.Top._keycatcher
        except AttributeError:
            k = self.Top._keycatcher = KeyCatcher(self.Top)
            return k

    def UpdateSkin(self):
        'Simply gets a skin and sets it all up.'

        key = self.skinkey
        native = not key

        if native and self.uxthemeable:
            self.rendernative = True
            self.destroy_native()
            self.OpenNativeTheme()

            skinget = skin.get

            self.menuicon = skinget('appdefaults.dropdownicon')
            self.padding = (5, 5)
            self.margins = Margins([0, 0, 0, 0])
            self.Font = default_font()

            self.fontcolors = [wx.BLACK] * 7

            self.backgrounds = NATIVE_BACKGROUNDS
            self.Cut()

        elif native:
            if not self.native:
                self.native = wx.Button(self, style=wx.BU_EXACTFIT)
                self.native.SetLabel(self.label)
                self.Sizer.Add(self.native, 1, wx.EXPAND)
                self.Layout()
                self.Cut()

        else:
            self.rendernative = False
            self.destroy_native()
            skinget = skin.get
            skinroot = skin.get(key)
            #s = lambda k, default = sentinel: skinget('%s.%s' % (key, k), default)

            s = skinroot.get
            self.menuicon = s('menuicon', skinget('appdefaults.dropdownicon'))
            self.padding = s('padding', (5, 5))
            self.margins = s('margins', Margins([0, 0, 0, 0]))
            self.Font = s('font', default_font())

            fc = skinroot.get('fontcolors', {})
            s = fc.get
            self.fontcolors = [
                s('disabled', Color(125, 125, 125)),
                s('normal', wx.BLACK),
                s('active', wx.BLACK),
                s('hover', wx.BLACK),
                s('activehover', wx.BLACK),
                s('down', wx.BLACK),
                s('notify', wx.WHITE)
            ]

            bgs = skinroot.get('backgrounds', {})

            def s(key, default):
                try:
                    return bgs[key]
                except:
                    return default()

            disabled = s(
                'disabled', lambda: SkinGradient(
                    'vertical', [Color(125, 125, 125),
                                 Color(237, 237, 237)]))
            normal = s(
                'normal', lambda: SkinGradient(
                    'vertical', [Color(200, 255, 200),
                                 Color(85, 255, 85)]))
            active = s(
                'active', lambda: SkinGradient(
                    'vertical', [Color(200, 255, 238),
                                 Color(85, 255, 238)]))
            hover = s('hover', lambda: normal)
            activehover = s('activehover', lambda: active)
            down = s(
                'down', lambda: SkinGradient('vertical', [
                    Color(0, 125, 0), Color(00, 204, 00)
                ]))
            notify = s(
                'notify', lambda: SkinGradient(
                    'vertical', [Color(255, 255, 200),
                                 Color(255, 255, 85)]))

            self.backgrounds = [
                disabled, normal, active, hover, activehover, down, notify
            ]

        self.Calcumalate()
        self.Refresh()

    def destroy_native(self):
        '''Destroys the native peer button, if there is one.'''

        if self.native:
            self.native.Show(False)
            self.Sizer.Detach(self.native)
            self.native.Destroy()
            self.native = None

    def Enable(self, switch=True):
        """
        Enables or disables the button
        Enables by default
        (maybe change to toggle?)
        """
        if not self.native:
            wx.PyControl.Enable(self, switch)
            if switch:
                events = [(wx.EVT_LEFT_DOWN, self.OnLeftDown),
                          (wx.EVT_LEFT_DCLICK, self.OnLeftDown),
                          (wx.EVT_LEFT_UP, self.OnLeftUp),
                          (wx.EVT_ENTER_WINDOW, self.OnMouseIn),
                          (wx.EVT_LEAVE_WINDOW, self.OnMouseOut)]
                do(self.Bind(event, method) for (event, method) in events)

            else:
                events = [
                    wx.EVT_LEFT_DOWN, wx.EVT_LEFT_DCLICK, wx.EVT_LEFT_UP,
                    wx.EVT_ENTER_WINDOW, wx.EVT_LEAVE_WINDOW
                ]
                do(self.Unbind(event) for event in events)

            self.state = (1 if switch else 0)

            if self.ScreenRect.Contains(wx.GetMousePosition()):
                self.GetHover()
            else:
                self.ReleaseHover()

        else:
            self.native.Enable(switch)

        self.Refresh()

    def SetMenuBarMode(self, switch=None):
        """
        This turns on menubarmode

        This effects
            - the showing of the dropmenu icon
            - Ampersan denoted underlining
            - Informing a menubar about focus events
            - and some size and mouse capture logic differences logic
        """
        if switch:
            self.menubarmode = switch
        else:
            self.menubarmode = not self.menubarmode

    def MakeDicon(self):
        'Greys out an icon.'

        self.dicon = self.icon.Greyed.WXB

    def SetIcon(self, icon=None):
        """
        Changes icon for the button
        if no arguments speified or None, removes the icon from the button
        """
        if icon:
            self.icon = icon
            self.MakeDicon()
        else:
            self.icon = self.dicon = None

        self.Calcumalate()
        self.Refresh()

    def SetNotify(self, switch):
        self.notified = switch
        self.Refresh()

    def RegAccel(self, label=""):
        #        oldLabel = self.label
        #        i = oldLabel.find('&')
        #        if i != -1 and i < len(oldLabel) - 1 and oldLabel[i+1] != '&':
        #            self.KeyCatcher.RemoveDown('alt+%s' % oldLabel[i+1], self.FakeClick)

        i = label.find('&')
        if i != -1 and i < len(label) - 1 and label[i + 1] != '&':
            #            print self, 'adding alt+%s' % label[i+1]
            self.KeyCatcher.OnDown('alt+%s' % label[i + 1], self.FakeClick)

    def SetLabel(self, label=""):
        """
        Changes icon for the button
        if no arguments speified or an empty string, removes the label from the button
        """

        self.RegAccel(label)

        self.label = label
        if self.native:
            self.native.SetLabel(label)
        self.Calcumalate()
        self.Refresh()

    def GetLabel(self):
        return self.label

    Label = property(GetLabel, SetLabel)

    def FakeClick(self, event=None):
        if self.type == 'toggle':
            # If this button is a toggle button, we need to switch
            # states and throw a different type of command event.
            self.Active()
            self.SendButtonEvent(wx.wxEVT_COMMAND_TOGGLEBUTTON_CLICKED)
        if self.type == 'menu' and not self.active:
            self.CallMenu()
        elif not self.type == 'menu':
            self.SendButtonEvent()

    def Calcumalate(self):
        """
        Calculates the positioning of all content of the button and
        sets the size of the button based off of these calculations
        """
        if self.native:
            self.Size = self.MinSize = self.native.BestSize
            #self.Fit()
            self.Parent.Layout()
            ApplySmokeAndMirrors(self)
            return

        label = DeAmp(self.label)

        if self.icon:
            iconwidth, iconheight = self.icon.Width, self.icon.Height
        else:
            iconwidth, iconheight = (0, 0)
        if label != '':
            labelwidth, labelheight = GetTextExtent(
                label, self.Font)[0], self.Font.Height
        else:
            labelwidth, labelheight = (0, 0)

        self.labelsize = Size(labelwidth, labelheight)

        margins = self.margins

        sx, sy = self.padding
        swidth = 0
        sheight = 0

        #icon & label caclulations
        if self.icon and label != '':
            if self.style == HORIZONTAL:
                swidth += iconwidth + labelwidth + 3 * sx
                if iconheight > labelheight:
                    sheight += iconheight + 2 * sy
                    iy = sy
                else:
                    sheight += labelheight + 2 * sy
                    iy = sy + labelheight // 2 - iconheight // 2

                self.iconcurser = wx.Point(sx, iy)
                self.labelcurser = wx.Point(
                    self.iconcurser.x + iconwidth + sx,
                    self.iconcurser.y + iconheight / 2 - labelheight / 2)

                if self.menu and not self.menubarmode and self.menuicon:
                    swidth += self.menuicon.Width + sx

                self.ssize = Size(margins.left + swidth + margins.right,
                                  margins.top + sheight + margins.bottom)

            elif self.style == VERTICAL:
                labelwin = labelwidth > iconwidth
                if labelwin:
                    swidth += labelwidth + 2 * sx
                else:
                    swidth += iconwidth + 2 * sx
                sheight += iconheight + labelheight + 3 * sy

                lx = sx
                if labelwin:
                    self.iconcurser = wx.Point(
                        lx + labelwidth / 2 - iconwidth / 2, sy)
                    self.labelcurser = wx.Point(
                        lx, self.iconcurser.y + iconheight + sy)
                else:
                    self.iconcurser = wx.Point(lx, sy)
                    self.labelcurser = wx.Point(
                        lx + iconwidth / 2 - labelwidth / 2,
                        self.iconcurser.y + iconheight + sy)

                if self.menu and not self.menubarmode:
                    swidth += self.menuicon.Width + sx

                self.ssize = Size(margins.left + swidth + margins.right,
                                  margins.top + sheight + margins.bottom)

        # Just icon caclulations
        elif self.icon:
            swidth += iconwidth + 2 * sx
            sheight += iconheight + 2 * sy

            self.iconcurser = wx.Point(sx, sy)

            if self.menu and not self.menubarmode:
                swidth += self.menuicon.Width + sx

            self.ssize = Size(margins.left + swidth + margins.right,
                              margins.top + sheight + margins.bottom)

        # Just label caclulations
        elif label != '':
            swidth += labelwidth + 2 * sx
            sheight += labelheight + 2 * sy

            self.labelcurser = wx.Point(sx, sy)

            if self.menu and not self.menubarmode:
                swidth += self.menuicon.Width + sx

            self.ssize = Size(margins.left + swidth + margins.right,
                              margins.top + sheight + margins.bottom)

        elif self.menu is not None and not self.menubarmode:
            swidth += self.menuicon.Width
            sheight += self.menuicon.Height

            self.ssize = Size(swidth + 2 * sx + margins.x,
                              sheight + 2 * sy + margins.y)
        else:
            self.ssize = Size(16, 16)

        if self.staticwidth:
            self.ssize.width = self.staticwidth

        self.MinSize = self.ssize
        self.InvalidateBestSize()

        self.Parent.Layout()

    def DoGetBestSize(self):
        self.CacheBestSize(self.ssize)
        return self.ssize

    side_tabs = prefprop('tabs.side_tabs', False)

    def OnPaint(self, event):
        "Draws the button's background."

        # excape if native
        if self.native:
            event.Skip()
            return

        rect = RectS(self.Size)

        parent, grandparent = self.Parent, self.GrandParent
        if parent.__class__.__name__ == "Tab" and self.side_tabs:
            #Clipping the button for when partualy hidden
            cliptangle = RectS(self.Size)
            sy = self.Rect.y
            sw, sh = self.Size
            py = parent.Position.y
            pph = grandparent.Size.height - 16

            if parent.Position.y + parent.Size.height > grandparent.Size.height-16 and \
               sy + sh + py > pph:
                cliptangle = Rect(0, 0, sw, pph - (sy + py))
                dc = wx.PaintDC(self)
                dc.SetClippingRect(cliptangle)
        else:
            dc = AutoBufferedPaintDC(self)

        # actual drawing of background
        currentstate=5 if self.isdown else \
                     6 if self.state and self.notified else \
                     self.state+(self.hovered*2) if self.state else \
                     0

        if self.rendernative:

            nrect = rect if self.type == 'combo' else rect.Inflate(1, 1)
            #wx.RendererNative.Get().DrawPushButton(self,dc,nrect,self.backgrounds[currentstate])
            part = 1
            state = self.backgrounds[currentstate]
            self.DrawNativeLike(dc, part, state, nrect)
        else:
            background = self.backgrounds[currentstate]
            from cgui import SplitImage4
            if isinstance(background, SplitImage4):
                ApplySmokeAndMirrors(self, background.GetBitmap(self.Size))
            else:
                ApplySmokeAndMirrors(self)
            background.Draw(dc, rect)

        #TODO: Backgroundless icon buttons

        if not (self.type == 'combo' and self.rendernative):
            self.DrawContent(dc)

    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 DrawContent(self, dc):
        'Draws the contents of the button to the DC provided.'
        offset = ((self.Size.width / 2 - self.ssize[0] / 2) if
                  (not self.menu or self.label != '' and self.icon
                   and self.style == VERTICAL or self.label == '')
                  and not (self.label != '' and self.icon
                           and self.style == HORIZONTAL) else 0,
                  self.Size.height / 2 - self.ssize[1] / 2)
        ml, mt, mr, mb = self.margins

        #Draw Icons
        if self.icon:
            dc.DrawBitmap(self.icon if self.IsEnabled() else self.dicon,
                          self.iconcurser[0] + offset[0] + ml,
                          self.iconcurser[1] + offset[1] + mt, True)
        #Draw Labels
        if self.label != '':

            dc.Font = self.Font

            #Set the font color
            currentstate = 6 if  self.state and self.notified else \
                           5 if self.isdown else \
                           self.state + (self.hovered * 2) if self.state else \
                           0

            dc.TextForeground = self.fontcolors[currentstate]

            dc.Font = self.Font
            labelcurser = self.labelcurser

            loffset = (max(offset[0], 0), max(offset[1], 0))
            w = min(
                self.labelsize.x, self.Rect.Width - labelcurser.x -
                loffset[0] - self.padding[0] - mr -
                ((self.menuicon.Width + self.padding[0])
                 if self.menu and not self.menubarmode else 0)) + 2
            lrect = Rect(labelcurser.x + loffset[0] + ml,
                         labelcurser.y + loffset[1] + mt, w, self.labelsize[1])

            #            dc.Pen=wx.Pen(wx.Color(0,255,0))
            #            dc.Brush=wx.TRANSPARENT_BRUSH
            #            dc.DrawRectangleRect(lrect)

            dc.DrawLabel(TruncateText(self.label.replace('&', ''), w, None,
                                      dc),
                         lrect,
                         LEFT_VCENTER,
                         indexAccel=self.label.find('&'))

        #Lastly draw the dropmenu icon if there is a menu
        if self.type == 'menu' and not self.menubarmode:
            dc.DrawBitmapPoint(
                self.menuicon,
                wx.Point(
                    self.Size.width - self.menuicon.Width - self.padding[0] -
                    mr, (self.Size.height -
                         (mt + mb)) / 2 + mt - self.menuicon.Height / 2), True)

    def Active(self, switch=None):
        """
        Used for menu and toggle buttons.

        Toggles active state or sets it to the provided state.
        """

        if self.state:
            old_active = self.active
            self.active = not self.active if switch is None else switch
            self.state = 2 if self.active else 1

            if old_active != self.active:
                self.Refresh(False)

    def IsActive(self):
        return self.active

    def OnKillFocus(self, event):
        """
        Part of an attempted tab-traversal fix, might work, might not.
        """

        if self.native:
            event.Skip()
            self.Refresh()
            return

        if self.isdown:
            self.OnMouseOut(event)
        self.Refresh()

    def OnKeyDown(self, event):
        """
        Used to allow spacebar to emulate mousedown
        """

        if self.native:
            event.Skip()
            self.Refresh()
            return

        if event.KeyCode == wx.WXK_SPACE:
            if not self.isdown and not wx.LeftDown(): self.OnLeftDown(event)
        else:
            event.Skip()
            self.Refresh()

    def OnKeyUp(self, event):
        """
        Allow spacebar to emulate mouse up
        """

        if self.native:
            event.Skip()
            self.Refresh()
            return

        if event.KeyCode == wx.WXK_SPACE:
            if self.isdown and not wx.LeftDown(): self.OnLeftUp(event)
        else:
            event.Skip()

    def OnLeftDown(self, event=None):
        'Left mouse down handling.'

        if self.native:
            self.isdown = True
            event.Skip()
            self.Refresh()
            return

        if self.isdown:
            self.OnMouseOut(event)
            return

        self.isdown = True

        if not self.HasCapture():
            self.CaptureMouse()

        self.SetFocus()

        if self.type == 'menu':
            if not self.active:
                self.CallMenu()
            elif self.menu:
                self.Active(False)
                self.menu.Dismiss()

        self.Refresh()

    def SendButtonEvent(self, type=None):
        """
        fakes a button event
        """
        eventType = type or wx.wxEVT_COMMAND_BUTTON_CLICKED
        evt = wx.CommandEvent(eventType, self.Id)
        evt.EventObject = self
        self.AddPendingEvent(evt)

    def OnLeftUp(self, event):
        'Left mouse up handling.'

        if self.native:
            self.isdown = False
            event.Skip()
            self.Refresh()
            return

        self.ReleaseAllCapture()

        if self.isdown:
            self.isdown = False

            #If mouse is released over the button
            if (event.m_x >= 0 and event.m_x <= self.Size.x and event.m_y >= 0
                    and event.m_y <= self.Size.y) or hasattr(
                        event, 'KeyCode') and event.KeyCode == wx.WXK_SPACE:
                if self.type == 'toggle':
                    # If this button is a toggle button, we need to switch
                    # states and throw a different type of command event.
                    self.Active()
                    self.SendButtonEvent(wx.wxEVT_COMMAND_TOGGLEBUTTON_CLICKED)
                elif not self.type == 'menu':
                    self.SendButtonEvent()

            self.Refresh()

    def GetHover(self):
        """
        Mouse over detection for hover state and menubar mouse over open
        """

        self.hovered = True
        self.Refresh()

        event = UberEvents.UBOver(source=self)
        self.Parent.AddPendingEvent(event)

    def OnMouseIn(self, event):
        "Mouse over handling."

        if not event.LeftIsDown() or self.menubarmode:
            self.GetHover()

        if self.native:
            event.Skip()
            return

        elif self.HasCapture():
            # Mouse left is still down, has come back to our rectangle: depress
            self.isdown = True
            self.Refresh()

    def OnMouseOut(self, event=None):
        'Mouse out handling.'

        self.isdown = False

        if self.native:
            event.Skip()
            return

        if self.menubarmode:
            self.ReleaseAllCapture()

#        if not self.menubarmode:
        self.ReleaseHover()

        self.Refresh()

    def ReleaseHover(self):
        'Un-hover the button.'

        self.hovered = False
        self.Refresh()

        event = UberEvents.UBOut(source=self)
        self.Parent.AddPendingEvent(event)

    def CallMenu(self):
        'Click (down then up) handling.'

        self.Active()
        if self.active:
            event = wx.MenuEvent(wx.wxEVT_MENU_OPEN, -1)
            event.SetEventObject(self.menu)
            self.Top.ProcessEvent(event)
            self.ReleaseAllCapture()
            self.menu.Display(self)

    def GetValue(self):
        return self.active

    def SetValue(self, v):
        self.active = v
        self.Refresh()

    Value = property(GetValue, SetValue)

    def AcceptsFocusFromKeyboard(self):
        return not self.menubarmode

    def AcceptsFocus(self):
        return not self.menubarmode
コード例 #17
0
ファイル: imwin_ctrl.py プロジェクト: sgricci/digsby
class ImWinCtrl(object):
    '''
    IM window logic.

    - incoming messages and new conversations go to the "message" function
    - the on_mode_change[d] functions are called when changing modes
    '''
    def __init__(self):
        # "controllers" in charge of the contents of the To/From combos
        self.IMControl = IMControl(self, self.capsbar, self.To, self.From)
        self.IMControl.OnSelection += self.FocusTextCtrl
        self.IMControl.OnSwitchContact += lambda c: self.set_conversation(
            c.protocol.convo_for(c))

        self.EmailControl = EmailControl(self.To, self.From)
        self.EmailControl.OnLoseFocus += lambda: self._emailpanel.subject_input.SetFocus(
        )

        self.SMSControl = SMSControl(self.To, self.From)
        self.SMSControl.OnLoseFocus += self.FocusTextCtrl

        self.controllers = {
            'im': self.IMControl,
            'email': self.EmailControl,
            'sms': self.SMSControl
        }

        self.mode = None
        self.convo = None

        self.typing = None  # buddy's typing state
        self.typing_status = None  # your typing state
        self.typing_timer = None  # timer for keeping track of your typing state
        self.clear_typing_timer = wx.PyTimer(self.on_clear_typing_timer)

        self.GetButton('im').Bind(
            EVT_BUTTON, lambda e: self.set_mode('im', toggle_tofrom=True))

        for mode in ('email', 'sms', 'info'):
            self.GetButton(mode).Bind(EVT_BUTTON,
                                      lambda e, mode=mode: self.set_mode(mode))

        self.GetButton('video').Bind(EVT_BUTTON, lambda e: self.on_video())

        multichat = self.GetButton('multichat')
        if multichat is not None:
            multichat.Bind(wx.EVT_TOGGLEBUTTON,
                           lambda e: self.toggle_roomlist())

    send_typing = prefprop('privacy.send_typing_notifications', True)
    typed_delay = prefprop('messaging.typed_delay', 5)

    def message(self, messageobj, convo=None, mode='im', meta=None):
        "Called by imhub.py with incoming messages."

        info('%r', self)
        info_s('  messageobj: %r', messageobj)
        info('       convo: %r', convo)
        info('        mode: %r', mode)
        info('        meta: %r', meta)

        assert wx.IsMainThread()

        if messageobj is None:
            # starting a new conversation--no message
            self.set_conversation(convo)
            self.set_mode(mode)
            self.IMControl.SetConvo(convo)
            if convo.ischat:
                self.show_roomlist(True)

        elif (messageobj.get('sms', False) or getattr(convo.buddy, 'sms', None)
              ) and not profile.blist.on_buddylist(convo.buddy):
            # an incoming SMS message
            if self.convo is None:
                self.set_conversation(convo)

            if self.mode != 'sms':
                self.set_mode('sms')

            # just show it
            self.show_message(messageobj)
        else:
            convo = messageobj.conversation

            if self.mode is None:
                self.set_mode(mode)
            self.show_message(messageobj)
            self.set_conversation(convo)
#            self.IMControl.SetConvo(convo)

    def set_mode(self, mode, toggle_tofrom=False):
        with self.Frozen():
            oldmode = getattr(self, 'mode', None)
            self.on_mode_change(oldmode, mode, toggle_tofrom)
            self.show_controls(mode)
            self.on_mode_changed(mode)

    Mode = property(attrgetter('mode'), set_mode)

    def on_mode_change(self, oldmode, mode, toggle_tofrom=False):
        'Invoked before the GUI is shown for a new mode.'

        # To/From showing and hiding
        if oldmode != mode and mode in ('email', 'sms'):
            self.ShowToFrom(True)
        elif mode == 'info':
            self.ShowToFrom(False)

        # Enabling/disabling formatting buttons
        if mode == 'sms' and oldmode != 'sms':
            wx.CallAfter(
                lambda: self.input_area.tc.SetMaxLength(SMS_MAX_LENGTH))
        elif oldmode == 'sms' and mode != 'sms':
            wx.CallAfter(lambda: self.input_area.tc.SetMaxLength(0))

        # If going to IM, Email, or SMS--show that mode's to/from combo
        for m in ('im', 'email', 'sms'):
            if mode == m and oldmode != m:
                wx.CallAfter(self.controllers[mode].Apply)
                break

        # If going to IM mode...
        if mode == 'im':
            # toggle if clicking IM button
            #   or
            # ask IM control if there is more than one choice for the To/From choices.
            if self.convo.ischat:
                self.ShowToFrom(False)
            elif oldmode != 'im':
                self.ShowToFrom(self.IMControl.HasChoices)
            elif toggle_tofrom:
                self.ShowToFrom(not self.capsbar.ToFromShown)

            #show = self.IMControl.HasChoices if oldmode != 'im' else not self.capsbar.ToFromShown
            #self.ShowToFrom(show)

        if oldmode is not None:
            self.GetButton(oldmode).Active(False)

        self.GetButton(mode).Active(True)

    def on_mode_changed(self, mode):
        'Invoked after the GUI is shown for a new mode.'

        if mode in ('im', 'sms'):
            self.on_message_area_shown()
            if self.IsActive():
                # for some reason, if we don't use wx.CallAfter on Mac, the call happens to early.
                if sys.platform.startswith('darwin'):
                    wx.CallAfter(self.FocusTextCtrl)
                else:
                    self.FocusTextCtrl()

        elif mode == 'info':
            self.set_profile_html(self.Buddy)
            self.profile_html.SetFocus()  # so mousewheel works immediately

        elif mode == 'email':
            self._emailpanel.subject_input.SetFocus()

    def on_send_message(self):
        if getattr(self, 'on_send_message_' + self.mode, lambda a: None)():
            self.Top.on_sent_message(self.mode, self)

    def on_send_message_im(self):
        'Invoked when enter is pressed in the message input box during IM mode.'

        val = self.input_area.GetFormattedValue()

        # Early exit if there is no message to send.
        if not val.format_as('plaintext'):
            return

        self.history.commit(val.format_as('plaintext'))

        # If the user has selected different to/from accounts, change
        # our conversation object.
        if self.set_conversation_from_combos():
            self.convo.send_message(val)
            self.ClearAndFocus()
            return True

    def on_send_email(self, *a):
        'Invoked when the "Send" button is pressed. (For Emails)'

        to, frm = self.EmailControl.ToEmail, self.EmailControl.FromAccount

        if to is None:
            return wx.MessageBox(
                _('Please add an email address for this buddy by '
                  'clicking the "To:" box.'),
                _('Compose email to {name}').format(name=self.Buddy.name))

        epanel = self._emailpanel

        def success(*a):
            log.info('Email send success')
            # store history
            profile.blist.add_tofrom('email', to, frm)

            epanel.Clear()
            epanel.SetStatusMessage(_('Message Sent'))
            epanel.send_button.Enable(True)
            epanel.openin.Enable(True)

            import hooks
            hooks.notify('digsby.statistics.email.sent_from_imwindow')

        def error(*a):
            log.info('Email send error')
            epanel.SetStatusMessage(_('Failed to Send Email'))
            epanel.send_button.Enable(True)
            epanel.openin.Enable(True)

        epanel.SetStatusMessage(_('Sending...'))
        epanel.send_button.Enable(False)
        epanel.openin.Enable(False)

        subject = self._get_email_subject()
        body = self._get_email_body()

        frm.OnClickSend(to=to,
                        subject=subject,
                        body=body,
                        success=success,
                        error=error)

    def _get_email_subject(self):
        return self._emailpanel.subject_input.Value

    def _get_email_body(self):

        body = self._emailpanel.email_input_area.Value
        if pref('email.signature.enabled', type=bool, default=False):
            footer = u'\r\n' + pref(
                'email.signature.value',
                type=unicode,
                default=
                u'\r\n_______________________________________________________________'
                '\r\nSent using Digsby - http://email.digsby.com')
        else:
            footer = ''

        return body + footer

    def on_send_message_sms(self):
        'Invoked when enter is pressed in the message input box during SMS mode.'

        # Early exit if there is no message to send.
        if not self.input_area.Value: return

        to, frm = self.SMSControl.ToSMS, self.SMSControl.FromAccount
        if to is None:
            MessageBox(_('Please add an SMS number first.'),
                       _('Send SMS Message'))
        elif frm is None:
            MessageBox(
                _('You are not signed in to any accounts which can send SMS messages.'
                  ), _('Send SMS Message'))
        else:

            message = self.input_area.Value

            def on_success():
                self.show_message(
                    Message(buddy=frm.self_buddy,
                            message=message[:SMS_MAX_LENGTH],
                            conversation=self.convo,
                            type='outgoing'))
                self.ClearAndFocus()

            def on_error(errstr=None):
                if errstr is not None:
                    more = '\n' + _(
                        'The error message received was:') + '\n\t%s' % errstr
                else:
                    more = ''

                MessageBox(
                    _('There was an error in sending your SMS message.') +
                    more,
                    _('Send SMS Message Error'),
                    style=wx.ICON_ERROR)

            # Check the length--even though we limit the number of characters in SMS mode, the input box
            # may already have had too many characters.
            if len(message) > SMS_MAX_LENGTH:
                sms_line1 = _(
                    'Only the first {max_length:d} characters of your message can be sent over SMS:'
                ).format(max_length=SMS_MAX_LENGTH)
                sms_line2 = _('Do you want to send this message now?')

                if wx.NO == wx.MessageBox(u'%s\n\n"%s"\n\n%s' %
                                          (sms_line1, message, sms_line2),
                                          _('Send SMS - Character Limit'),
                                          style=wx.YES_NO):
                    return

            import hooks
            hooks.notify('digsby.statistics.sms.sent')
            frm.send_sms(to,
                         message[:SMS_MAX_LENGTH],
                         success=on_success,
                         error=on_error)

    def on_edit_email(self):
        '''
        Uses the email account's mail client to edit the currently entered email.

        Invoked when the "Edit In..." button is clicked in the email panel.
        '''

        to, frm = self.EmailControl.ToEmail, self.EmailControl.FromAccount

        if to is not None and frm is not None:
            frm.OnComposeEmail(to=to,
                               subject=self._emailpanel.subject_input.Value,
                               body=self._emailpanel.email_input_area.Value)

    def set_conversation_from_combos(self):
        '''
        If our current conversation doesn't match the to and from accounts
        chosen by the combos, obtains a new conversation.

        Returns False if there are no accounts to send the IM with.
        '''
        if self.ischat:
            return self.convo.protocol.connected

        to, frm = self.IMControl.Buddy, self.IMControl.Account

        # If IMControl's Account object is None, all accounts which can message
        # the buddy we're talking to have signed off. We can't send the message.
        if frm is None: return False

        convo = self.convo
        if convo.protocol is not frm or convo.buddy is not to:
            log.info(
                'asking protocol %r for a new convo for buddy %r with service %r',
                frm, to, to.service)
            convo = frm.convo_for(to)
            log.info('got conversation %r with buddy/service %r %r:', convo,
                     convo.buddy, convo.buddy.service)
            self.set_conversation(convo)

        return True

    def on_close(self):
        if getattr(self, '_closed', False):
            log.warning(
                'FIXME: imwin_ctrl.on_close was called more than once!!!')
            return

        self._closed = True

        del self.capsbar.buddy_callback
        del self.capsbar

        import hooks
        hooks.notify('digsby.overlay_icon_updated', self)

        from plugin_manager import plugin_hub

        plugin_hub.act('digsby.im.conversation.close.async', self.convo)

        self.unlink_observers()
        if self.convo is not None:
            self.unwatch_conversation(self.convo)
            try:
                self.convo.explicit_exit()
            except Exception:
                print_exc()

    @property
    def Conversation(self):
        return self.convo

    @property
    def Buddy(self):
        return self.IMControl.Buddy

    @property
    def SMS(self):
        return self.SMSControl.get_contact_sms()

    def set_conversation(self, convo, meta=None):
        if convo is self.convo:
            return

        # watch/unwatch
        shouldShowToFrom = False
        if self.convo is not None:
            self.unwatch_conversation(self.convo)
            self.convo.exit()
            if not self.convo.ischat:
                shouldShowToFrom = True

        self.convo = convo
        self.watch_conversation(convo)

        if self.is_roomlist_constructed():
            self.roomlist.SetConversation(convo)

        contact = meta if meta is not None else convo.buddy

        self.capsbar.ApplyCaps(convo=convo)
        self.IMControl.SetConvo(convo, meta)
        if shouldShowToFrom and not self.convo.ischat:
            self.ShowToFrom(shouldShowToFrom)

        self.EmailControl.SetContact(contact)
        self.SMSControl.SetContact(contact)
        self.update_icon()
        self.update_title()

        self.choose_message_formatting()
        self.convo.play_queued_messages()

        if convo.ischat:

            @wx.CallAfter
            def after():
                self.show_roomlist(True)

    def _update_caps_and_title(self, *a):
        @wx.CallAfter
        def after():
            self.capsbar.ApplyCaps(convo=self.convo)
            self.update_title()

            if self.convo.ischat and not getattr(
                    self, 'roomlist_has_been_shown', False):
                log.info("showing roomlist...")
                self.toggle_roomlist()

    def watch_conversation(self, convo):

        from plugin_manager import plugin_hub

        plugin_hub.act('digsby.im.conversation.open.async', convo)

        convo.typing_status.add_observer(self.typing_status_changed)
        convo.add_observer(self._update_caps_and_title, 'ischat')

        buddy = convo.buddy

        buddy.add_observer(self.buddy_status_changed, 'status')
        buddy.add_observer(self.buddy_info_changed)

        if convo.ischat:
            convo.room_list.add_observer(self.chat_buddies_changed)
            convo.conversation_reconnected.add_unique(
                self.on_conversation_reconnected)

        convo.protocol.add_observer(self._on_convo_proto_state_change, 'state')

        #profile.account_manager.buddywatcher.watch_status(buddy, self.on_status_change)

    def on_conversation_reconnected(self, convo):
        @wx.CallAfter
        def gui():
            log.warning('on_conversation_reconnected: %r', convo)
            self.set_conversation(convo)
            convo.system_message(_('Reconnected'))

    def chat_buddies_changed(self, *a):
        wx.CallAfter(self.update_title)

    def unwatch_conversation(self, convo=None):
        if convo is None: convo = self.convo
        if convo is not None:
            buddy = convo.buddy

            convo.remove_observer(self._update_caps_and_title, 'ischat')
            convo.typing_status.remove_observer(self.typing_status_changed)
            if buddy is not None:
                buddy.remove_observer(self.buddy_status_changed, 'status')
                buddy.remove_observer(self.buddy_info_changed)

            convo.room_list.remove_observer(self.chat_buddies_changed)
            convo.conversation_reconnected.remove_maybe(
                self.on_conversation_reconnected)

            convo.protocol.remove_observer(self._on_convo_proto_state_change,
                                           'state')
            #profile.account_manager.buddywatcher.unwatch_status(buddy, self.on_status_change)

    def _on_convo_proto_state_change(self, proto, attr, old, new):
        @wx.CallAfter
        def after():
            if self.convo.ischat and new == proto.Statuses.OFFLINE:
                # chats include roomlist count, and need to be updated on disconnect.
                self.update_title()

    def show_status(self, update, ondone=None):
        cb = lambda u=update: self.show_message(u, ondone)

        try:
            timer = self._statustimer
        except AttributeError:
            timer = self._statustimer = wx.PyTimer(cb)
        else:
            timer.SetCallback(cb)

        if not self._statustimer.IsRunning():
            self._statustimer.Start(250, True)

    @calllimit(1)
    def buddy_info_changed(self, *a):
        '''
        This method is called anytime the buddy's information changes.

        If we're in "info" mode, the HTML profile box is updated.
        '''
        if self.mode == 'info':
            self.set_profile_html(self.Buddy)

    def buddy_status_changed(self, *a):
        wx.CallAfter(self._buddy_status_changed)

    def _buddy_status_changed(self):
        if check_destroyed(self):
            return

        if self.convo.ischat:
            return

        # if the buddy's online status changes, we may need to add/remove the
        # Files button
        self.capsbar.ApplyCaps(self.Buddy)

        # if we're showing the buddy's status orb in the tab/window title,
        # update those icons now.
        if self.icontype == 'status':
            self.update_icon()

    def typing_status_changed(self, *a):
        "Called when the conversation's typing status changes."

        typing = self.convo.typing_status.get(self.convo.buddy, None)

        # this pref indicates how long after not receiving typing notifications
        # we wait until clearing them, in seconds. 0 means never clear.
        typing_clear_time_secs = pref(
            'messaging.typing_notifications.clear_after', default=30, type=int)
        if typing_clear_time_secs > 0:
            if typing is not None:
                self.clear_typing_timer.StartOneShot(1000 *
                                                     typing_clear_time_secs)
            else:
                self.clear_typing_timer.Stop()

        self.on_typing(typing)

    def on_typing(self, typing):
        self.typing = typing
        self.update_title()
        self.update_icon()

    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 choose_message_formatting(self):
        '''
        Gives a chance for both the conversation and the protocol to expose
        an attribute "message_formatting", which if set to 'plaintext'
        will cause us only to extract (and send as IMs) text from the input
        box, not HTML.
        '''
        plain = False
        conv = self.convo

        try:
            plain = conv.message_formatting == 'plaintext'
        except AttributeError:
            try:
                plain = conv.protocol.message_formatting == 'plaintext'
            except AttributeError:
                pass

        self.plainttext = plain

    def show_message(self, messageobj, ondone=None):
        "Shows a message object in the message area."

        c = messageobj.conversation
        b = messageobj.buddy
        t = messageobj.type

        # used to remember incoming<->outgoing for whether to "glue"
        # consecutive messages together visually
        buddyid = (b.idstr(), messageobj.type) if b is not None else None

        if buddyid is None:
            next = False
        else:
            next = getattr(self, 'last_buddy', None) == buddyid
        self.last_buddy = buddyid

        self.message_area.format_message(t, messageobj, next=next)

        if ondone is not None:
            #ondone()
            pass

    def set_profile_html(self, buddy):
        "Sets the HTML info window's contents to buddy's profile."

        profilewindow = self.profile_html

        # don't generate HTML for the same buddy twice.
        try:
            html = GetInfo(self.Buddy,
                           showprofile=True,
                           showhide=False,
                           overflow_hidden=False)
        except Exception:
            print_exc()
            html = buddy.name

        # freeze/thaw since HTML window is flickery when updating contents
        with self.Frozen():
            profilewindow.SetHTML(html)

    def on_text_changed(self, e):
        'Called when the main text input box changes.'

        e.Skip()

        # change conversations if we need to
        oldConvo = self.convo
        if not self.send_typing or self.Mode != 'im' or not self.set_conversation_from_combos(
        ):
            return

        # end typing notifications for the old conversation
        if oldConvo is not None and oldConvo is not self.convo:
            with traceguard:
                oldConvo.send_typing_status(None)

        txt = self.input_area.Value

        if len(txt) == 0:
            if self.typing_status != None:
                self.typing_status = None
                self.convo.send_typing_status(None)

            if self.typing_timer:
                self.typing_timer.Stop()
                self.typing_timer = None

        else:
            if self.typing_status != 'typing':
                self.typing_status = 'typing'
                self.convo.send_typing_status(self.typing_status)

            self.cancel_timer()
            self.typing_timer = PyTimer(self.send_typed)
            self.typing_timer.Start(self.typed_delay * 1000, True)

    def send_typed(self, *e):
        if self.typing_status != 'typed':
            self.typing_status = 'typed'
            self.convo.send_typing_status(self.typing_status)

    def cancel_timer(self):
        if self.typing_timer:
            self.typing_timer.Stop()
            self.typing_timer = None

    def on_message_area_shown(self):
        'Sets up the MessageStyle for the IM area.'

        if hasattr(self, 'message_area') and not self.message_area.inited:
            if hasattr(self, 'convo'):
                self.init_message_area(self.convo.name,
                                       self.convo.buddy,
                                       show_history=not self.convo.ischat)
            else:
                self.init_message_area('', None)

            self.input_area.tc.Bind(wx.EVT_TEXT, self.on_text_changed)

            from gui.imwin.imwindnd import ImWinDropTarget
            self.SetDropTarget(ImWinDropTarget(self))

    def on_video(self):

        import hooks
        hooks.notify('digsby.video_chat.requested')

        buddy = self.Buddy

        from gui.video.webvideo import VideoChatWindow

        if VideoChatWindow.RaiseExisting():
            self.convo.system_message(
                _('You can only have one audio/video call at a time.'))
            log.info('video window already up')
        else:
            log.info('requesting video chat')

            from digsby.videochat import VideoChat
            VideoChat(buddy)
コード例 #18
0
class BuddyList(WheelScrollMixin, BuddyListBase):
    'Main buddy list control.'

    # The amount of space given to "borders" between buddy list elements during
    # drag and drop.
    def __init__(self, parent, infobox, collapsed=None, keyhandler=None):
        # load expanded groups
        try:
            collapsed = eval(profile.localprefs[EXPANSION_STATE_KEY])
        except:
            collapsed = [
                u'OfflineGroup_Offline'
            ]  # TODO: actually run expanded_id on the offline group to obtain this string

        self.dragResult = wx.DragMove
        self.infobox_scrollers = set()

        # an empty group forms the root of the hierarchy
        model = TreeListModel(collapsed=collapsed)

        # store idle indices for a periodical refresh
        self.idle_indices = []
        self.idle_timer = wx.PyTimer(self.refresh_idle_buddies)

        # save expansion after EXPANSION_SAVE_TIME seconds
        def save_expansion():
            profile.localprefs[EXPANSION_STATE_KEY] = repr(
                list(model.collapsed))

        profile.PreDisconnectHooks.append(save_expansion)
        model.expansion_state_changed += delayed_call(
            save_expansion, EXPANSION_SAVE_TIME_SECS)
        model.expansion_state_changed += lambda: self.renderers_cache.clear()

        from jabber.JabberContact import JabberContact
        model.donotexpand += [MetaContact, JabberContact]

        super(BuddyList, self).__init__(parent, model)

        Bind = self.Bind
        Bind(wx.EVT_MOTION, self.motion)
        Bind(wx.EVT_ENTER_WINDOW, self.enter_window)
        Bind(wx.EVT_LEAVE_WINDOW, self.leave_window)
        Bind(wx.EVT_MIDDLE_UP, self.on_middle_up)
        self.BindWheel(self)
        Bind(wx.EVT_RIGHT_DOWN, self.on_right_down)
        Bind(wx.EVT_CONTEXT_MENU, self.on_context_menu)
        Bind(wx.EVT_LEFT_DOWN, self.on_left_down)
        Bind(wx.EVT_KEY_DOWN, self.__onkey)

        if keyhandler is not None:
            Bind(wx.EVT_CHAR, keyhandler)

        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)

        self.update_renderers()

        self.dragging_obj = None
        self.shownbuddies = defaultdict(list)

        with traceguard:
            self.SetDropTarget(BuddyListDropTarget(self))

        # On Mac OS X, we don't get mouse moved events when the
        # window is inactive or not focused, so poll the mouse state
        # whenever we enter the window
        self.mouse_tracker = None
        if config.platform == 'mac':
            self.mouse_tracker = wx.PyTimer(self.motion)

        blist = profile.blist

        # Observe changes to the buddylist structure.
        blist.add_observer(self.on_blist_update)

        self.infobox = infobox
        infobox.Befriend(self)

        top_bind = self.Top.Bind
        top_bind(wx.EVT_SHOW, self.on_frame_show_or_iconized)
        top_bind(wx.EVT_ICONIZE, self.on_frame_show_or_iconized)

    def on_frame_show_or_iconized(self, e):
        # Since this control is the only observer of the sorter, we can
        # add a hack that disables sorting when the buddylist isn't shown.
        #
        # When you bring the buddylist back, a sort will happen.
        e.Skip()
        frame = self.Top

        def later():
            visible = frame.IsShown() and not frame.IsIconized()
            profile.blist.set_sort_paused(not visible)

        # allow adjacent iconize/show to catch up
        wx.CallLater(50, later)

    @property
    def context_menu(self):
        try:
            return self._context_menu
        except AttributeError:
            self._context_menu = UMenu(self, _('BuddyList Popup'))
            return self._context_menu

    def on_blist_update(self, blist, *a):
        if not self: return
        self.set_root(blist.view)

    showing_idle = prefprop('buddylist.layout.extra_info')

    def PostPaint(self, dc):
        self.paint_add_link(dc)

        # reset the idle timer when painting
        if self.showing_idle in ('both', 'idle'):
            self.idle_timer.Start(IDLE_UPDATE_SECS * 1000)

        profile.blist.set_sort_paused(False)

        if not getattr(self, '_did_startup_time', False):
            self._did_startup_time = True
            import sys
            from time import clock
            sys._startup_time = clock()

            if getattr(getattr(sys, 'opts', None), 'measure') == 'startup':
                print 'startup time', sys._startup_time
                import os
                os._exit(0)

    def refresh_idle_buddies(self):
        for i in self.idle_indices:
            self.RefreshLine(i)

    def paint_add_link(self, dc):
        if len(self.model) == 0:
            amgr = profile.account_manager

            if amgr.accounts_loaded and len(amgr.accounts) == 0:
                try:
                    f = skin.get('BuddiesPanel.Fonts.AddAccountsLink',
                                 default_font)
                    f.SetUnderlined(True)

                    dc.SetTextForeground(
                        skin.get('BuddiesPanel.FontColors.AddAccountsLink',
                                 wx.BLUE))
                except Exception:
                    print_exc()
                    f = self.Font

                dc.SetFont(f)

                # Center an "Add Accounts" link in the client area.
                s = _('Add Accounts')

                w, h = dc.GetTextExtent(s)

                # position the link 1/4 down the list
                r = self.ClientRect
                r.Height = r.Height / 2
                x, y = r.HCenterW(w), r.VCenterH(h)

                dc.DrawText(s, x, y)
                self._linkrect = wx.Rect(x, y, w, h)

                # Draw a "Need Help?" link as well.
                help_string = _('Need Help?')
                w, new_height = dc.GetTextExtent(help_string)
                x, y = r.HCenterW(w), y + h * 1.5
                dc.DrawText(help_string, x, y)
                self._helplinkrect = wx.Rect(x, y, w, h)
                return

        try:
            del self._linkrect
            del self._helplinkrect
        except AttributeError:
            pass

    def set_root(self, root):
        return TreeList.set_root(self, root)

    def rename_selected(self):
        obj = self.SelectedItem
        if obj is not None:
            # check the action precondition
            if obj.rename_gui.action_allowed(obj):
                obj.rename_gui()

    def __onkey(self, e):
        c = e.KeyCode

        if c == wx.WXK_SPACE:
            self.RotateContact(not e.ShiftDown())
        elif c == wx.WXK_F2:
            self.rename_selected()
        elif c == wx.WXK_DELETE:
            self.delete_blist_item(self.SelectedItem)
        elif c in activate_keys:
            self.on_doubleclick()
        elif c == wx.WXK_HOME:
            self.SetSelection(0) if len(self.model) else None
        elif c == wx.WXK_END:
            self.SetSelection(len(self.model) - 1) if len(self.model) else None
        else:
            e.Skip(True)

    def UpdateSkin(self):
        self.dragimgs = S(
            bar=skin.get('BuddiesPanel.Dragimages.Bar'),  #TODO: stretch?
            box=skin.get('BuddiesPanel.Dragimages.Box'))

        for renderer in self.renderers.itervalues():
            renderer.UpdateSkin()

        bg = skin.get('BuddiesPanel.Backgrounds.List',
                      lambda: SkinColor(wx.WHITE))
        self.SetBackground(bg)

        self.RefreshAll()

    def update_renderers(self):
        import gui.buddylist.renderers as r

        self.UpdateSkin()

        contact_renderer = r.ContactCellRenderer(self)
        group_renderer = r.GroupCellRenderer(self)
        search_renderer = r.SearchCellRenderer(self)

        self.renderers.update(
            dict(Group=group_renderer,
                 DGroup=group_renderer,
                 SortGroup=group_renderer,
                 JabberContact=contact_renderer,
                 Contact=contact_renderer,
                 JabberResource=contact_renderer,
                 YahooContact=contact_renderer,
                 MetaContact=r.MetaContactCellRenderer(self),
                 SearchEntry=search_renderer,
                 SearchOptionsEntry=r.SearchCellOptionsRenderer(self),
                 SearchWebGroup=group_renderer))

    def dragon_allowed(self, i):
        'Is dragging on to the ith buddy allowed.'

        dragging = self.dragging_obj
        target = self.model[i]

        if isinstance(target, SpecialGroup):
            return False

        if isinstance(dragging, GroupTypes):
            return False

        from digsby import iswidget
        if iswidget(target):
            return False

        return True

    def on_middle_up(self, e):
        self.RotateContact(not e.ShiftDown())

    def RotateContact(self, forward=True):
        ib = self.infobox
        if forward:
            ib.SelectNext()
        else:
            ib.SelectLast()

    def _on_mousewheel(self, e):
        if e.RightIsDown():
            self._menu_ok = False
            ib = self.infobox
            rot = e.WheelRotation
            if rot < 0:
                ib.SelectNext()
            elif rot > 0:
                ib.SelectLast()
        else:
            # forward the mousewheel event to the infobox
            win = wx.FindWindowAtPointer()
            if isinstance(win, tuple(self.infobox_scrollers)):
                self.infobox.on_mousewheel(e)
            else:
                super(BuddyList, self)._on_mousewheel(e)

    def on_right_down(self, e):
        i = self.HitTest(e.Position)
        self.SetSelection(i)
        e.Skip()

    def on_context_menu(self, e):
        # ensure the selection is underneath the mouse cursor
        self.context_menu_event_selection(e)

        menu = self.context_menu
        menu.RemoveAllItems()

        i = self.GetSelection()

        if i != -1:
            obj = self.model[i]
            if hasattr(obj, '_disallow_actions'):
                return

            # The mouse is over a group or buddy
            import common.actions as actions
            actions.menu(self, self.model[i], self.context_menu)
        else:
            # The mouse is over an empty space in the buddylist
            #
            # Only show "Add Group" if you are connected to an IM account (other than Digsby)
            # OR if you have the "digsby.allow_add" preference set.
            if not any(x.allow_contact_add
                       for x in profile.account_manager.connected_accounts):
                return

            from gui.protocols import add_group
            menu.AddItem(_('&Add Group'), callback=add_group)

        menu.PopupMenu()

    def context_menu_event_selection(self, e):
        # EVT_CONTEXT_MENU has .Position == (-1, -1) when caused by the keyboard
        # if that's not the case, and the mouse is over an item that isn't
        # selected, select it.
        if e and e.Position != (-1, -1):
            # watch out! EVT_RIGHT_DOWN's event.Position is in client coordinates
            # but EVT_CONTEXT_MENU gets screen coordinates (at least on windows)
            self.SetSelection(self.HitTest(self.ScreenToClient(e.Position)))

    def open_convo_with_selected(self):
        'Opens a conversation window with the buddy currently selected.'

        i = self.GetSelection()
        if i != -1:
            obj = self.model[i]
            if self.can_chat(obj):
                chat_with(obj)
                self.infobox.DoubleclickHide()
                return True
            elif hasattr(obj, 'activate'):
                with traceguard:
                    obj.activate()
                return True

    def enter_window(self, e):
        if self.mouse_tracker:
            self.mouse_tracker.Start(10)

    def leave_window(self, e):
        if self.mouse_tracker:
            self.mouse_tracker.Stop()
        e.Skip()
        self.infobox.InvalidateDoubleclickHide()

    def can_chat(self, obj):
        return isinstance(obj, (Contact, MetaContact))

    def on_doubleclick(self, e=None):
        if not self.open_convo_with_selected():
            TreeList.on_doubleclick(self, e)

    activate_selected_item = on_doubleclick

    def expand_all(self):
        with self.save_selection():
            model = self.model
            isexp = model.is_expanded

            for i, obj in enumerate(model):
                if isinstance(obj, GroupTypes) and not isexp(i):
                    model.expand(obj)
                    return self.expand_all()

    def collapse_all(self):
        with self.save_selection():
            model = self.model
            isexp = model.is_expanded

            for i, obj in enumerate(model):
                if isinstance(obj, GroupTypes) and isexp(i):
                    model.collapse(obj)
                    return self.collapse_all()

    def on_left_down(self, e):
        self.drag_point = e.Position

        try:
            linkrect = self._linkrect
            helprect = self._helplinkrect
        except AttributeError:
            pass
        else:
            if linkrect.Contains(e.Position):
                import gui.pref.prefsdialog
                gui.pref.prefsdialog.show('accounts')
            elif helprect.Contains(e.Position):
                wx.LaunchDefaultBrowser(NEED_HELP_LINK)

        i = self.HitTest((e.GetX(), e.GetY()))

        if i == -1:
            self.SetSelection(-1)
            return e.Skip(True)

        if self.model.expandable(self[i]) and e.GetX() < 15:
            # If we're clicking a Group expander triangle, toggle the group
            # expansion but do not select.
            self.toggle_expand(self[i])
        else:
            self.SetSelection(i)
            e.Skip(True)

            self.infobox.quickshow = True
            self.infobox_hittest(e.Position)

    def motion(self, e=None):
        'Invoked on mouse motion over the buddy list.'
        pos = None
        if e:
            e.Skip(True)
            pos = e.Position
        else:
            pos = self.Parent.ScreenToClient(wx.GetMousePosition())

        try:
            linkrect = self._linkrect
            helprect = self._helplinkrect
        except AttributeError:
            pass
        else:
            # If the cursor is over a custom drawn link show a hand
            if any(r.Contains(pos) for r in (linkrect, helprect)):
                self.SetCursor(StockCursor(CURSOR_HAND))
            else:
                self.SetCursor(StockCursor(CURSOR_ARROW))

        # Drag "distance" must be at least ten pixels
        if e and hasattr(self, 'drag_point') and e.LeftIsDown() and e.Dragging() \
            and _dist2(e.GetPosition(), self.drag_point) > 100:

            i = self.GetSelection()
            if i != -1 and i < len(self.model):
                data = self.make_drag_data(self.model[i])

                ds = BuddyListDropSource(self)
                ds.SetData(data)
                unused_result = ds.DoDragDrop(wx.Drag_AllowMove)
                self.hilite = None
                self.Refresh()
                self.dragging = False
        elif e and not e.LeftIsDown() and hasattr(self, 'drag_point'):
            del self.drag_point

        else:
            self.infobox_hittest(pos)

    show_infobox = prefprop('infobox.show')

    def infobox_hittest(self, pos):
        i = self.HitTest(pos)

        if i != -1:
            obj = self[i]
            if not isinstance(obj, GroupTypes):
                if self.show_infobox and isinstance(obj,
                                                    (Contact, MetaContact)):
                    p = self.Parent
                    pl = p.ClientToScreen(
                        wx.Point(0, self.Position.y + self.GetItemY(i)))
                    pr = pl + wx.Point(p.Size.width, 0)
                    return self.infobox.Display(pl, pr, obj)

        # hide infobox when over search entries, or empty space
        self._hide_infobox()

    def _hide_infobox(self):
        if self.infobox.Shown:
            self.infobox.DelayedHide()
        else:
            self.infobox.Hide()

    def make_drag_data(self, blist_item):
        data = wx.DataObjectComposite()

        import contacts.contactsdnd as contactsdnd
        contactsdnd.add_to_dataobject(data, blist_item)

        self.dragging_obj = blist_item
        return data

    def on_drop_buddylistitem(self, clist_obj):
        if not getattr(self, 'hilite', None):
            return

        # hilite is a tuple of (area, index)
        area, _i, drop_to = self.hilite

        if area == 'below_group':
            area = 'below'

        if area == 'disallow': return
        #        if self.model[i] is clist_obj: return # early exit for dropping to same

        from gui.searchgui import SearchEntry

        if isinstance(clist_obj, Contact):
            return self.on_drop_contact(clist_obj, area, drop_to)
        elif isinstance(clist_obj, MetaContact):
            return self.on_drop_metacontact(clist_obj, area, drop_to)
        elif isinstance(clist_obj, GroupTypes):
            return self.on_drop_dgroup(clist_obj, area, drop_to)
        elif isinstance(clist_obj, SearchEntry):
            return self.on_drop_search(clist_obj, area, drop_to)
        self.hilite = None

    def on_drop_dgroup(self, group, area, togroup):
        assert isinstance(
            togroup,
            GroupTypes), "dragging above or below something that isn't a group"
        assert area in ('above', 'below')
        profile.blist.rearrange_group(group, area, togroup)

    def on_drop_metacontact(self, clist_obj, area, drop_to):
        if isinstance(drop_to, GroupTypes):
            return self.on_drop_metacontact_dgroup(clist_obj, area, drop_to)
        elif isinstance(drop_to, MetaContact):
            return self.on_drop_metacontact_metacontact(
                clist_obj, area, drop_to)
        elif isinstance(drop_to, Contact):
            return self.on_drop_metacontact_contact(clist_obj, area, drop_to)

    def on_drop_metacontact_dgroup(self, clist_obj, area, drop_to):
        assert area in ('box', 'below')
        assert isinstance(clist_obj, MetaContact)
        blist = profile.blist
        if area == 'below':
            position = blist.DROP_BEGINNING
        else:
            position = blist.DROP_END
        blist.rearrange(clist_obj, area, drop_to, position)
        if not in_same_group(clist_obj, drop_to):
            clist_obj.move_to_group(drop_to.name)

    def do_relative_metacontact(self, clist_obj, area, drop_to):
        drop_group = self.model.parent_of(drop_to)
        profile.blist.rearrange(clist_obj, area, drop_group, drop_to)
        if not in_same_group(clist_obj, drop_group):
            clist_obj.move_to_group(drop_group.name)

    def on_drop_search(self, entry, area, drop_to):
        'rearrange search web items'
        from common.search import searches
        from common import setpref
        entry = entry.searchengine.dict()
        drop_to = drop_to.searchengine.dict()
        engines = [s.dict() for s in searches[:]]

        i = engines.index(entry)
        j = engines.index(drop_to) + (1 if area == 'below' else 0)

        if j > i: j -= 1

        if i != len(engines):
            engines.pop(i)
        engines.insert(j, entry)

        setpref('search.external', engines)

    def on_drop_metacontact_metacontact(self, clist_obj, area, drop_to):
        assert area in ('above', 'box', 'below')
        if area == 'box':
            contacts = list(drop_to) + list(clist_obj)
            diag = MetaContactDialog(self,
                                     contacts,
                                     metacontact=drop_to,
                                     title=_('Merge Contacts'),
                                     order=None)
            try:
                diag.Prompt(
                    ondone=lambda *a, **k: clist_obj.explode(ask=False))
            finally:
                diag.Destroy()
        else:
            self.do_relative_metacontact(clist_obj, area, drop_to)

    def on_drop_metacontact_contact(self, clist_obj, area, drop_to):
        assert area in ('above', 'box', 'below')
        if area == 'box':
            contacts = [drop_to] + list(clist_obj)
            diag = MetaContactDialog(self,
                                     contacts,
                                     metacontact=clist_obj,
                                     title=_('Merge Contacts'),
                                     order=None)
            drop_group = self.model.parent_of(drop_to)

            def morelater(*a, **k):
                profile.blist.rearrange(clist_obj, 'above', drop_group,
                                        drop_to)
                if not in_same_group(clist_obj, drop_group):
                    clist_obj.move_to_group(drop_group.name)

            try:
                diag.Prompt(ondone=morelater)
            finally:
                diag.Destroy()
        else:
            self.do_relative_metacontact(clist_obj, area, drop_to)

    def delete_blist_item(self, item):

        if isinstance(item, Contact):
            from gui.protocols import remove_contact
            remove_contact(item, item.remove)
        elif isinstance(item, MetaContact):
            item.explode()
        elif isinstance(item, GroupTypes):
            from gui.protocols import remove_group
            remove_group(item, item.delete)

    def on_drop_contact(self, clist_obj, area, drop_to):
        if isinstance(drop_to, GroupTypes):
            return self.on_drop_contact_dgroup(clist_obj, area, drop_to)
        elif isinstance(drop_to, MetaContact):
            return self.on_drop_contact_metacontact(clist_obj, area, drop_to)
        elif isinstance(drop_to, Contact):
            return self.on_drop_contact_contact(clist_obj, area, drop_to)

    def on_drop_contact_dgroup(self, clist_obj, area, drop_to):
        assert area in ('box', 'below')
        assert isinstance(clist_obj, Contact)
        blist = profile.blist
        if area == 'below':
            position = blist.DROP_BEGINNING
        else:
            position = blist.DROP_END
        success = lambda *a: blist.rearrange(clist_obj, area, drop_to, position
                                             )
        if clist_obj not in drop_to:

            @callsback
            def do_move(result=None, callback=None):
                clist_obj.move_to_group(drop_to.name, callback=callback)

            do_move(success=success)
        else:
            success()

    def do_relative_contact(self, clist_obj, area, drop_to):
        drop_group = self.model.parent_of(drop_to)
        blist = profile.blist
        success = lambda *a: blist.rearrange(clist_obj, area, drop_group,
                                             drop_to)
        if clist_obj not in drop_group:

            @callsback
            def do_move(result=None, callback=None):
                clist_obj.move_to_group(drop_group.name, callback=callback)

            do_move(success=success)
        else:
            success()

    def on_drop_contact_metacontact(self, clist_obj, area, drop_to):
        assert area in ('above', 'box', 'below')
        if area == 'box':
            diag = MetaContactDialog.add_contact(self, drop_to, clist_obj, -1)
            diag.Prompt(ondone=lambda *a: None)
            diag.Destroy()
        else:
            self.do_relative_contact(clist_obj, area, drop_to)

    def on_drop_contact_contact(self, clist_obj, area, drop_to):
        assert area in ('above', 'box', 'below')
        if area == 'box':
            order = ('__meta__', 'above', self.model.parent_of(drop_to),
                     drop_to)
            diag = MetaContactDialog(self, [drop_to, clist_obj], order=order)
            diag.Prompt(ondone=lambda *a: None)
            diag.Destroy()
        else:
            self.do_relative_contact(clist_obj, area, drop_to)

    def get_feedback(self, clientPt):
        # Percent will be the percentage of vertical space the cursor has
        # passed over the item it's on.
        i, percent = self.hit_test_ex(clientPt)
        dragging = self.dragging_obj
        drop_to = self.model[i]
        if i == -1:
            # We must be dragging off into the "void" below the
            # buddylist: put it below the last item.
            i = len(self.model) - 1
            percent = 1
            parent_percent = ('foo', 1)
        else:
            parent_percent = self.hit_test_parent(clientPt)

        from .buddylistrules import target, feedback
        new_to, position = target(self.model, dragging, drop_to, i, percent,
                                  parent_percent)
        feedback_result = feedback(self.model, dragging, new_to, position)
        return new_to, feedback_result

    def GiveFeedback(self, effect, dragsource):
        'Logic for drawing drag and drop indication marks.'

        mousepos = wx.GetMousePosition()
        clientPt = self.ScreenToClient(mousepos)
        new_to, feedback_result = self.get_feedback(clientPt)

        #        ITEM_BOX    = 'box'
        #        GROUP_BOX   = 'group_box'
        #        ABOVE       = 'above'
        #        BELOW       = 'below'
        #        BELOW_GROUP = 'below_group'
        #        DISALLOW    = 'disallow'

        if feedback_result == 'group_box':
            feedback_result = 'box'
#        if feedback_result == 'below_group':
#            feedback_result = 'below'

#        if feedback_result not in ('above', 'below', 'box'):
#            feedback_result = None

        old_hilite = self.hilite
        if feedback_result is not None:
            self.hilite = (feedback_result, self.model.index_of(new_to),
                           new_to)
        else:
            self.hilite = None

        # Is there a better way to do this? Keep track of previous mouse
        # positions, perhaps?


#        if self.hilite is not None:
#            area, i, drop_to = self.hilite
#            if area == 'disallow':
#                dragsource.SetCursor(effect, wx.StockCursor(wx.CURSOR_NO_ENTRY))
#            else:
#                dragsource.SetCursor(effect, wx.StockCursor(wx.CURSOR_COPY_ARROW))

# only refresh lines that need it
        if self.hilite != old_hilite:
            #            print self.hilite, old_hilite
            #            print [old_hilite[1] if old_hilite else -1, self.hilite[1] if self.hilite else -1]
            hilites = filter(lambda a: a != -1, [
                old_hilite[1] if old_hilite else -1,
                self.hilite[1] if self.hilite else -1
            ])
            i, j = min(hilites), max(hilites)
            self.RefreshLines(max(0, i - 1), min(self.GetItemCount() - 1,
                                                 j + 1))
            if old_hilite and old_hilite[0] == 'below_group':
                if self.model.is_expanded(old_hilite[1]):
                    self.RefreshLine(old_hilite[1] + len(old_hilite[2]))
            if self.hilite and self.hilite[0] == 'below_group':
                if self.model.is_expanded(self.hilite[1]):
                    self.RefreshLine(self.hilite[1] + len(self.hilite[2]))

        self.dragResult = wx.DragNone if not self.hilite or self.hilite[
            0] == 'disallow' else wx.DragMove

        return False

    def search(self, search_string):
        self.fallback_selection = 1
        profile.blist.search(search_string, self._on_search_cb)

    def _on_search_cb(self, results):
        # results is num contacts in (prevSearch, thisSearch)
        # if we went from finding no contacts to finding some contacts, select the first one.
        prev, this = results
        if prev == -1 and this > 0:
            wx.CallAfter(self.SetSelection, 1)

    def clear_search(self):
        profile.blist.search('')