'''
 
Connection list, showing IM accounts in the buddylist.
 
'''
 
import wx
from wx import AutoBufferedPaintDC, RectS, Point, Rect, Size, MemoryDC, CallLater
 
from gui import skin
from gui.skin.skinobjects import SkinColor,Margins,MarginSizer
from gui.textutil import default_font,CopyFont, Wrap,GetTextWidth
from gui.uberwidgets.uberwidget import UberWidget
from gui.uberwidgets.UberButton import UberButton
from gui.uberwidgets.umenu import UMenu
 
from cgui import SimplePanel
 
from common.Protocol import ProtocolStatus,OfflineReason
from common import profile, pref, actions
from gui.toolbox.scrolling import WheelScrollMixin
 
accounts = None
 
SCROLLCONST = 20
 
ShowNothingStates = set([ProtocolStatus.CONNECTING,
                         ProtocolStatus.AUTHENTICATING,
                         ProtocolStatus.INITIALIZING,
                         ProtocolStatus.LOADING_CONTACT_LIST])
 
class ConnectionsPanel(SimplePanel, UberWidget):
    """
        Panel that holds the list of accounts, used for frame and holding button
    """
    def __init__(self, parent):
        SimplePanel.__init__(self, parent, wx.FULL_REPAINT_ON_RESIZE)
 
        content = self.content = wx.BoxSizer(wx.VERTICAL)
 
        self.SetSkinKey('AccountPanels', True)
 
        cl = self.cl = ConnectionList(self)
        content.Add(cl, 1, wx.EXPAND)
 
        statebutton = self.statebutton = UberButton(self, icon = self.iconshow, skin = self.buttonskin)
        self.button_has_been_pressed = False
        statebutton.Bind(wx.EVT_BUTTON, self.__OnButtonClick)
 
        if self.expandup:
            content.Add(statebutton, 0, wx.EXPAND)
        else:
            content.Insert(0, statebutton, 0, wx.EXPAND)
 
        self.Sizer = MarginSizer(self.framesize, content)
 
        Bind = self.Bind
        Bind(wx.EVT_SIZE,  self.OnSize)
        Bind(wx.EVT_PAINT, self.OnPaint)
 
        profile.prefs.add_observer(self.WhenOrderChanges,'buddylist.order') #@UndefinedVariable
 
 
 
 
    def WhenOrderChanges(self,*a):
 
        order = pref('buddylist.order', [])
 
        try:
            cli = order.index('clist')
            bli = order.index('blist')
        except ValueError: #not in list
            self.expandup = False
        else:
            self.expandup = bli<cli
 
 
        self.iconshow = self.iconup if self.expandup else self.icondown
        self.iconhide = self.icondown if self.expandup else self.iconup
 
 
        if hasattr(self,'statebutton'):
            statebutton = self.statebutton
            content = self.content
 
            self.content.Detach(self.statebutton)
 
            if self.expandup:
                content.Add(statebutton, 0, wx.EXPAND)
            else:
                content.Insert(0, statebutton, 0, wx.EXPAND)
            self.statebutton.SetSkinKey(self.buttonskin)
            self.statebutton.SetIcon(self.iconhide if self.cl.ShowAll else self.iconshow)
 
 
    def UpdateSkin(self):
        """
            The usual.
        """
        key = self.skinkey
        s= lambda k,d=None: skin.get('%s.%s'%(key,k),d)
 
        self.framebg        = s('Frame',      lambda: SkinColor(wx.BLACK))
        self.framesize      = s('FrameSize',  lambda: Margins([0,0,0,0]))
        self.iconup         = s('icons.show', None)
        self.icondown       = s('icons.hide', lambda: wx.BitmapFromImage(wx.ImageFromBitmap(self.iconup).Mirror(False)))
        self.buttonskin     = s('buttonskin', None)
 
        self.WhenOrderChanges()
 
        if self.Sizer:
            self.Sizer.SetMargins(self.framesize)
 
    def __OnButtonClick(self, e):
        self.button_has_been_pressed = True
        return self.ToggleState(e)
 
    def ToggleState(self, event = None):
        """
            Toggles the List between Show All mode and hide Online/Offline mode
        """
        cl = self.cl
        cl.ShowAll = not cl.ShowAll
 
        if cl.ShowAll:
            cl.SetFocus()
 
        self.statebutton.SetIcon(self.iconhide if cl.ShowAll else self.iconshow)
 
        wx.CallAfter(self.Layout)
 
    def OnSize(self,event):
        """
            Relayout on resize
        """
        event.Skip()
        self.Layout()
 
    def OnPaint(self,event):
        """
            Standard paints.
        """
        dc   = AutoBufferedPaintDC(self)
        rect = RectS(self.Size)
 
        self.framebg.Draw(dc,rect)
 
panel_flags = wx.EXPAND|wx.BOTTOM|wx.LEFT|wx.RIGHT
 
class ConnectionList(WheelScrollMixin, wx.ScrolledWindow, UberWidget):
    """
        This is a scrollable list of all accounts associated to the profile.
        Its size is the height of all shown panels up to a certain height defined
        in the prefs.  Has two modes. In ShowAll mode all accounts are shown
        regardless of state. When ShowAll is false only those accounts that have
        an error, or are currently in between offline and online states are shown.
        Once a state is online or offline it will disappear after a period of time.
        When the list of accounts changes, the list destroys all existing panels,
        and recreates them in the correct order.
    """
    def __init__(self,parent):
        super(ConnectionList, self).__init__(parent)
 
        #set here so that when a profile change occurs the reference updates correctly
        global accounts
        accounts = profile.account_manager.accounts
 
        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 
        self.Sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetScrollRate(0,1)
        self.SetSkinKey('accountpanels',True)
        self.ShowAll = False
 
        self.oldaccounts = []
        self.panels      = {}
 
        accounts.add_observer(self.WhenListChanges)
        profile.account_manager.add_observer(self.InitShow,'accounts_loaded')
 
        self.menu = UMenu(self)
 
        Bind = self.Bind
        Bind(wx.EVT_PAINT, self.OnPaint)
        Bind(wx.EVT_ERASE_BACKGROUND, lambda e: None)
        Bind(wx.EVT_SIZE,self.OnSize)
        self.BindWheel(self)
        Bind(wx.EVT_SCROLLWIN_LINEDOWN, lambda e: self.Scroll(0,self.ViewStart[1]+SCROLLCONST))
        Bind(wx.EVT_SCROLLWIN_LINEUP, lambda e: self.Scroll(0,self.ViewStart[1]-SCROLLCONST))
        Bind(wx.EVT_SCROLLWIN, lambda e: (e.Skip(), wx.CallAfter(self.Refresh)))
        Bind(wx.EVT_KEY_DOWN, self.OnKey)
 
    def OnKey(self,event):
 
        key = event.KeyCode
 
        if key == wx.WXK_PAGEDOWN:
            self.ScrollPages(1)
        elif key == wx.WXK_PAGEUP:
            self.ScrollPages(-1)
        else:
            event.Skip()
 
    def UpdateSkin(self):
        key = self.skinkey
        s = lambda k, d = None: skin.get('%s.%s' % (key,k), d)
 
        self.bg = s('backgrounds.behind', SkinColor(wx.WHITE))
        self.spacing = s('spacing', 0)
 
        wx.CallAfter(self.WhenListChanges)
 
    def OnPaint(self, event):
        self.bg.Draw(AutoBufferedPaintDC(self), RectS(self.ClientSize))
 
    def _on_mousewheel(self, e):
        """
            Handles mouse wheel scroll events to make the list scroll with mouse
            wheel use.
        """
        super(ConnectionList, self)._on_mousewheel(e)
        if not self.bg.ytile:
            self.Refresh()
 
    def get_wheel_lines(self, rotation, e):
        val = rotation / float(e.GetWheelDelta()) * e.LinesPerAction
        return val / 2.0 # 2-line panels
 
    def rotation_for_lines(self, lines, e):
        return float(e.GetWheelDelta()) / e.LinesPerAction * lines * 2.0
 
    def ScrollLines(self, lines):
        dist = 0
        a = b = None
        try:
            accts = list(accounts)
            if len(accts) > 1:
                a = self.panels[accts[1]].Position.y
                b = self.panels[accts[0]].Position.y
            else:
                dist = 0
        except Exception:
            dist = 0
        else:
            if a is not None and b is not None:
                dist = a - b
        if dist:
            dist = lines * dist - getattr(self, 'borrowed_dist', 0)
            self.borrowed_dist = int(round(dist)) - dist
            self.Scroll(0, self.ViewStart.y + int(round(dist)))
        else:
            super(ConnectionList, self).ScrollLines(lines)
 
    def InitShow(self,*a):
        """
            Because accounts are loaded late, the decision to show most happen
            later.  Decides the initial show based off if the account
        """
 
        #ShowAll is True if no accounts autoLogin
        def show():
            if not self.Parent.button_has_been_pressed: # don't toggle state if user has already clicked.
                self.ShowAll = not any(getattr(account, 'autologin', False) for account in profile.account_manager.accounts)
                self.Parent.statebutton.icon = self.Parent.iconhide if self.ShowAll else self.Parent.iconshow#Label = 'Hide' if self.ShowAll else 'Show'
 
        self.showtimer = CallLater(500, show)
 
    def SetShowAll(self, show):
        """
        Set the ShowAll mode True or False
        True    - Show all accounts
        False   - Show only accounts in error or between states
        """
        self.showall = show
        self.UpdateChildrenShown()
 
    def GetShowAll(self):
        "Returns ShowAll mode True or False"
 
        return self.showall
 
    ShowAll = property(GetShowAll, SetShowAll)
 
    def UpdateChildrenShown(self):
        """
        Loop through the children showing or hiding the ones affected by the
        a ShowAll switch.
        """
        for child in self.Children:
            if hasattr(child, 'DetermineShow'):
                child.DetermineShow()
 
        wx.CallAfter(self.SelfSize)
 
    def OnSize(self, event = None):
        """
        When the list has a change in size sets the virtual size and calls
        SelfSize to firgure out the appropriate MinSize
        """
        if event is not None:
            event.Skip()
 
        # Make sure virtual Width is the same as the Client Width
        self.SetVirtualSizeHints(self.ClientSize.width, -1, self.ClientSize.width, -1)
 
        if self.Size.width == self.lastwidth:
            return
 
        wx.CallAfter(self.SelfSize)
 
    def WhenListChanges(self, *a):
        self.Freeze()
        try:
            scrolly = self.GetScrollPos(wx.VERTICAL)
            accts = list(accounts)
 
            # Early exit hack here if the accounts list is not empty and equal
            # to our cached one in self.oldaccounts--the logic for preserving
            # the scroll is always a few pixels off, so don't do anything if we
            # don't have to.
            if accts and self.oldaccounts == accts:
                return
 
            self.Sizer.Clear(deleteWindows = False)
            oldaccts, panels = self.oldaccounts, self.panels
            old, new = set(oldaccts), set(accts)
 
            for acct in old - new:
                panel = panels.pop(acct)
                panel.OnDestroy()
                panel.Destroy()
 
            for acct in new - old:
                panels[acct] = ConnectionPanel(self, acct)
 
            # Add a spacer to make sure the first visible item obeys the spacing between
            # itself and the edge of the list
            self.Sizer.AddSpacer(self.spacing)
 
            # create a new panel for each account and place it in the sizer
 
    #        try:
            for acct in accts:
                self.Sizer.Add(panels[acct], 0, panel_flags, self.spacing)
 
            self.oldaccounts = accts
 
            wx.CallAfter(self.SelfSize)
            wx.CallAfter(self.Scroll, 0, scrolly)
        finally:
            wx.CallAfter(self.Thaw)
 
    def SelfSize(self):
        """
            Figures out the maximum height of the list by the smaller of shown elements
            or the pref connectionlist.max_height
        """
 
        #h is the minimum of height of all items + spacing or the height specified in prefs
        h = min(sum(child.MinSize.height+self.spacing for child in self.Children if child.Shown) + self.spacing, pref('connectionlist.max_height', 200))
        #Hide if no items shown
        self.Show(h > self.spacing)
 
        self.MinSize = wx.Size(-1, h)
        self.GrandParent.Layout()
 
        if self.Shown:
            wx.CallAfter(self.Layout)
            wx.CallAfter(self.Refresh)
            wx.CallAfter(self.EnsureVirtualHeight)
 
        self.lastwidth = self.Size.width
 
    def EnsureVirtualHeight(self):
        """
            This is called to make sure that the VirtualHeight is correct
        """
        vheight = self.VirtualSize.height
        cheight = self.Sizer.MinSize.height
 
        if vheight != cheight:
            self.VirtualSize = (-1, cheight)
 
 
class ConnectionPanel(SimplePanel, UberWidget):
    """
        This panel corresponds to an individual IM account and displays data about it.
        It displays the account's username, it's offline reason or state if no
        reason is available, a link that will connect if offline or disconnect
        if online, a dismiss button if the list is not set to ShowAll and the
        account is either online or offline, the protocol icon, and the state icon
        if the list is in ShowAll.
    """
    def __dtor__(self):
        from gui.toolbox.refreshtimer import refreshtimer
        refreshtimer().UnRegister(self)
 
    def __init__(self, parent, account):
 
        self.initover = False
 
        SimplePanel.__init__(self, parent)
 
        self.Show(False)
 
        self.account=account
 
        #Refernce for the timer for delayed hide
        self.willhide = None
 
        self.SetSkinKey('AccountPanels',True)
 
        self.title = account.username
 
        self.account.add_observer(self.WhenStateChange,'offline_reason')
        self.account.add_observer_callnow(self.WhenStateChange,'state')
 
        #Becasue the width affects the content and the content effects the height
        #   this is used to store the last size so the widths can be compared
        #   perventing an infinit loop of size adjustments
        self.lastsizedto=self.Size
 
        #These are used for faking a button
        self.buttonstate = 0 #visual state: Idle; 1: hover; 2: down
        self.buttonisdown = False #because if the button is down and shown down can differ
        self.buttonshown= False #Is the button visible?
 
        self.linkhovered = False #True if mouse is in the link rect
        self.linkdown = False #True if the mouse button was pushed while in link rect
 
        Bind = self.Bind
 
        Bind(wx.EVT_PAINT,        self.OnPaint)
        Bind(wx.EVT_SIZE,         self.OnSize)
        Bind(wx.EVT_ENTER_WINDOW, self.OnMouseIn)
        Bind(wx.EVT_LEAVE_WINDOW, self.OnMouseOut)
        Bind(wx.EVT_MOTION,       self.OnMouseMotion)
        Bind(wx.EVT_LEFT_DOWN,    self.OnLeftDown)
        Bind(wx.EVT_LEFT_UP,      self.OnLeftUp)
        Bind(wx.EVT_RIGHT_UP,     self.OnMenu)
        Bind(wx.EVT_KEY_DOWN,     self.OnKey)
 
        self.initover = True
 
    def OnKey(self, event):
        self.Parent.ProcessEvent(event)
 
    def OnMenu(self, e = None):
        if e: e.Skip()
        menu    = self.Parent.menu
        account = self.account
 
        menu.RemoveAllItems()
        menu.AddItem(_('&Edit'), callback = lambda: profile.account_manager.edit(account))
        menu.AddSep()
 
        if account.connection:
            actions.menu(self, account.connection, menu)
            actions.menu(self, account, menu)
        else:
            menu.AddItem(_('&Connect'), callback = lambda: account.connect())
 
        menu.PopupMenu()
 
    def WhenStateChange(self, acct, attr, old, new):
        """
        When the account state changes this calls everything that sets up the
        the elements of the panel and determines whether it shows or hides
        """
        # An if self check becasue it's posible the callback could trigger between
        # the time the object is destroyed and the observer is removed
        account = self.account
 
        #When in the WILL_RECONNECT state, registered to refresh every 1 second
        from gui.toolbox.refreshtimer import refreshtimer
        if account.offline_reason == OfflineReason.WILL_RECONNECT:
            self.reason = lambda: profile.account_manager.state_desc(self.account)
            refreshtimer().Register(self)
        else:
            self.reason = profile.account_manager.state_desc(account) if account.state==ProtocolStatus.OFFLINE and account.offline_reason else _(account.state)
            refreshtimer().UnRegister(self)
 
        self.stateicon = account.statusicon.ResizedSmaller(16)
 
        if not wx.IsDestroyed(self):
            self.MakeLink()
            self.CalcLayout()
            self.Refresh()
            #Tells DetermineShow to delay the hide if state changed to ONLINE or OFFLINE
            delayed = (account.state == ProtocolStatus.ONLINE) or (account.state == ProtocolStatus.OFFLINE and account.offline_reason == OfflineReason.NONE)
            self.DetermineShow(delayed)
            self.Parent.SelfSize()
            self.GrandParent.Parent.Layout()
 
    def MakeLink(self):
        """
            Gets the link information for the current state of the account
        """
        self.link,self.linkcallback = self.account.get_link()
 
    def UpdateSkin(self):
        """
            The usual update skin
        """
        key = self.skinkey
        s = lambda k,d=None: skin.get('%s.%s'%(key,k),d)
 
        self.bg             = s('backgrounds.account',lambda: SkinColor(wx.WHITE))
        self.majorfont      = s('Fonts.Account', default_font)
        self.minorfont      = s('Fonts.StateAndLink',default_font)
        self.linkfont       =  CopyFont(self.minorfont, underline=True)
        self.majorfc        = s('FontColors.Account', wx.BLACK)
        self.statefc        = s('FontColors.State',lambda: wx.Colour(125,125,125))
        self.linkfc         = s('FontColors.Link', wx.BLUE)
        self.closeicon      =  [None]*3
        self.closeicon[0]   = s('Icons.Close',skin.get('AppDefaults.removeicon')).ResizedSmaller(16)
        self.closeicon[1]   = s('Icons.CloseHover',self.closeicon[0]).ResizedSmaller(16)
        self.closeicon[2]   = s('Icons.CloseDown',self.closeicon[1]).ResizedSmaller(16)
        self.liconsize      = s('ServiceIconSize',16)
        self.padding        = s('Padding',lambda: wx.Point(3,3))
 
 
        self.stateicon = self.account.statusicon.ResizedSmaller(16)
 
        self.licon = self.account.serviceicon.Resized(self.liconsize)
 
        if self.initover:
            self.CalcLayout()
 
    def CalcLayout(self):
        """
        Calculates the layout and height of the pannel based off of it's
        width and the size of the elements
        """
        dc = MemoryDC()
 
        #x and y are the cursor for were the next item will be placed
        #padx and pady are just local refs to padding.x and padding.y
        x,y = padx, pady = self.padding
 
        sz = self.Size
 
        linkfont  = self.linkfont
        minorfont = self.minorfont
        majorfont = self.majorfont
 
        licon   = self.licon
        link    = self.link
 
        #Positiong the service icon and the status/close icon to the left or
        #   right respectivly
        self.liconpos = Point(x, y)
        self.riconpos = Point(sz.width - 16 - padx, y)
 
        #incriment x position to right of icon
        x += licon.Width + padx
 
        #Which is taller, the label or the icon
        h = max(majorfont.Height, 16)
 
        #Place title rect with the erlier calculated values and width whats left
        #   of the overall width for the width left for the label
        self.titlerect = Rect(x, y, sz.width-4*padx-licon.Width-16,h)
 
        #incriment y to below the filled space
        y += h+pady
 
        #Find the link width because it's needed to know how much room the
        #   reason rect needs
        linkwidth = GetTextWidth(link,linkfont)
 
        #Determine the horizantal space left for the reason, then wrap it
        reasonwidth = sz.width - x - (linkwidth + 2*padx)
        reason = self.reason() if callable(self.reason) else self.reason
        wrappedreason = self.wrappedreason = Wrap(reason, reasonwidth, minorfont, dc)
 
        #Get the height needed for the label from the wraped string
        reasonheight = dc.GetMultiLineTextExtent(wrappedreason,minorfont)[1]
 
        #combine into a rectangle
        self.reasonrect = Rect(x,y,reasonwidth,reasonheight)
 
        #Figure the rest of the link size information
        self.linksize = Size(linkwidth,linkfont.LineHeight)
 
        #figure out the height the panel has to be in order to fit the content
        h = max(y+reasonheight+pady,self.liconsize+2*padx)
 
        newSize = Size(self.MinSize.width,h)
        if self.MinSize != newSize:
            self.MinSize = newSize
 
        self.Refresh()
 
    def DetermineShow(self, later=False):
        """
            Decides weither the panel should show or hide.
            If 'later' is True, hiding is delayed by the pref connectionlist.online_linger
        """
        account = self.account
 
        #Initialise or stop a delayed hide
        if later and not self.Parent.ShowAll and self.Shown:
            if not self.willhide:
                self.willhide = wx.CallLater(pref('connectionlist.online_linger',1000),self.WillShowFalse)
        else:
            if self.willhide:
                self.willhide.Stop()
                self.willhide = None
 
            #figures if it should show if parent is set to ShowAll or Offline with a reason and not achknowledged or the state is not OFFLINE or ONLINE
            shouldshow = self.Parent.ShowAll or ((account.state==ProtocolStatus.OFFLINE and account.offline_reason and not account.error_acked) or account.state not in (ProtocolStatus.OFFLINE,ProtocolStatus.ONLINE))
            self.Show(bool(shouldshow))
        self.DoLinkPos()
 
    def WillShowFalse(self):
        """
        Callback for the delayed hide of DetermineShow
        Hides the panel and takes the stepss to correct the layout for the
        change
        """
        self.Show(False)
        self.Parent.SelfSize()
        self.GrandParent.Parent.Layout()
 
    def OnSize(self,event):
        """
        When the panel is width is change, runs CalcLayout to position elements
        and figure new height
        """
        event.Skip()
        # Make sure the width actualy changed before calculating new positions and height
        if self.lastsizedto.width != self.Size.width:
            self.lastsizedto = self.Size
            self.CalcLayout()
        self.DoLinkPos()
 
    def DoLinkPos(self):
        "Positions the link in the lower right hand corner of the panel."
        sz = self.Size
        linksz = self.linksize
        padx,pady = self.padding
 
        # Link goes in lower right hand corner
        self.linkrect = wx.Rect(sz.width - padx - linksz.width, sz.height - pady - linksz.height,*linksz)
 
 
    def OnPaint(self,event):
        dc   = AutoBufferedPaintDC(self)
        rect = RectS(self.Size)
        self.bg.Draw(dc, rect)
 
        # Draw service icon
        icon = self.licon if self.account.is_connected else self.licon.Greyed
 
        dc.DrawBitmapPoint(icon, self.liconpos, True)
 
        #The right icon can either be the close icon, the state icon, or nothing
        #Shows the state icon if the list is in ShowAll or nothing if state is CONNECTING, AUTHENTICATING,INITIALIZING, or LOADING_CONTACT_LIST
        #   Otherwise it shows the close button
        ricon = self.stateicon if self.Parent.ShowAll else (self.closeicon[self.buttonstate] if self.account.state not in ShowNothingStates else None)
        if ricon:
            rconpos = self.riconpos + Point(8 - ricon.Width // 2, 8 - ricon.Height // 2)
            dc.DrawBitmapPoint(ricon, rconpos, True)
        self.buttonshown = bool(ricon)
 
        # Draw the account name
        dc.Font = self.majorfont
        dc.TextForeground = self.majorfc
        dc.DrawTruncatedText(self.title, self.titlerect)
 
        # Draws the offline reason or state
        dc.Font = self.minorfont
        dc.TextForeground = self.statefc
        if callable(self.reason):
            self.wrappedreason = Wrap(self.reason(), self.reasonrect.Width, self.minorfont, dc )
        dc.DrawLabel(self.wrappedreason,self.reasonrect)
 
        # Draw the link
        dc.Font = self.linkfont
        dc.TextForeground = self.linkfc
        dc.DrawLabel(self.link,self.linkrect)
 
    def OnDestroy(self):
        """
        When the panel is destroyed, this removes the panel as an observer
        of the account
        """
        self.account.remove_observer(self.WhenStateChange,'offline_reason')
        self.account.remove_observer(self.WhenStateChange,'state')
 
    def OnLeftDown(self,event):
        """
        Detects left mouse button down events for emulation of links and
        buttons
        """
 
        event.Skip()
 
        # if the button is being hovered
        if self.buttonstate == 1:
            # it is now down
            self.buttonstate = 2
            self.buttonisdown = True
            self.Refresh()
 
        elif self.linkhovered:
            self.linkdown = True
 
    def OnLeftUp(self,event):
        """
            Detects left mouse button up events for emulation of links and
            buttons
        """
 
        event.Skip()
 
        #if the buttons state is down, set it to idle and close the panel
        #   ackknowledging the the error
        if self.buttonstate == 2:
            self.buttonstate = 0
            self.account.error_acked = True
            self.DetermineShow()
            self.Parent.SelfSize()
 
        self.buttonisdown = False
 
        #If link is down
        if self.linkdown:
            #And if the pointer is over the link
            if self.linkhovered:
                #call the callback for the link
                self.linkcallback()
            self.linkdown = False
 
        self.OnMouseMotion(event)
 
        self.Refresh()
 
    def OnMouseMotion(self,event):
        """
            Ensures mouse in and mouse out capture events occure, also handels
            hover for the button and link
        """
 
        #If the left mouse button is not down, make sure the panel gets/losses
        # capture accordingly
        if not event.LeftIsDown():
            mouseisin = wx.FindWindowAtPointer() is self
 
            if mouseisin and not self.HasCapture():
                self.OnMouseIn(event)
 
            elif not mouseisin and self.HasCapture():
                self.OnMouseOut(event)
 
        #Handle button statethings on mouse over
        if not self.Parent.ShowAll and self.HasCapture() and self.buttonshown:
            bstate = self.buttonstate
            bisdown = self.buttonisdown
            mouseinb = wx.RectPS(self.riconpos,(16,16)).Contains(event.Position)
            if bstate == 0 and mouseinb:
                self.buttonstate = 2 if bisdown else 1
                self.Refresh()
            elif bstate in (1,2) and not mouseinb:
                self.buttonstate = 0
                self.Refresh()
 
        #handle link mouseover
        mouseinl = self.linkhovered = self.linkrect.Contains(event.Position)
        self.SetCursor(wx.StockCursor(wx.CURSOR_HAND if mouseinl else wx.CURSOR_DEFAULT))
 
    def OnMouseIn(self,event):
        """
            Captures the mouse when the cursor enters the panel
        """
        if not self.HasCapture() and not event.LeftIsDown():
            self.CaptureMouse()
 
    def OnMouseOut(self,event):
        """
            Releases the mouse when the cursor leaves the panle
        """
        if not event.LeftIsDown():
            while self.HasCapture():
                self.ReleaseMouse()