def updateText(self):
        text = unicode(shared.config.get(self.address, 'label'), 'utf-8)') + ' (' + self.address + ')'
        
        font = QtGui.QFont()
        if self.unreadCount > 0:
            # only show message count if the child doesn't show
            if not self.isExpanded():
                text += " (" + str(self.unreadCount) + ")"
            font.setBold(True)
        else:
            font.setBold(False)
        self.setFont(0, font)
            
        #set text color
        if shared.safeConfigGetBoolean(self.address, 'enabled'):
            if shared.safeConfigGetBoolean(self.address, 'mailinglist'):
                brush = QtGui.QBrush(QtGui.QColor(137, 04, 177))
            else:
                brush = QtGui.QBrush(QtGui.QApplication.palette().text().color())
            #self.setExpanded(True)        
        else:
            brush = QtGui.QBrush(QtGui.QColor(128, 128, 128))
            #self.setExpanded(False)
        brush.setStyle(QtCore.Qt.NoBrush)
        self.setForeground(0, brush)

        self.setIcon(0, avatarize(self.address))
        self.setText(0, text)
        self.setToolTip(0, text)

 def setType(self):
     if shared.safeConfigGetBoolean(self.address, 'chan'):
         self.type = "chan"
     elif shared.safeConfigGetBoolean(self.address, 'mailinglist'):
         self.type = "mailinglist"
     else:
         self.type = "normal"

 def setType(self):
     if self.address is None:
         self.type = self.ALL
     elif shared.safeConfigGetBoolean(self.address, 'chan'):
         self.type = self.CHAN
     elif shared.safeConfigGetBoolean(self.address, 'mailinglist'):
         self.type = self.MAILINGLIST
     else:
         self.type = self.NORMAL

 def setType(self):
     self.setFlags(self.flags() | QtCore.Qt.ItemIsEditable)
     if self.address is None:
         self.type = self.ALL
         self.setFlags(self.flags() & ~QtCore.Qt.ItemIsEditable)
     elif shared.safeConfigGetBoolean(self.address, 'chan'):
         self.type = self.CHAN
     elif shared.safeConfigGetBoolean(self.address, 'mailinglist'):
         self.type = self.MAILINGLIST
     else:
         self.type = self.NORMAL

 def run(self):
     from debug import logger
     
     logger.debug("Starting UPnP thread")
     logger.debug("Local IP: %s", self.localIP)
     lastSent = 0
     while shared.shutdown == 0 and shared.safeConfigGetBoolean('bitmessagesettings', 'upnp'):
         if time.time() - lastSent > self.sendSleep and len(self.routers) == 0:
             try:
                 self.sendSearchRouter()
             except:
                 pass
             lastSent = time.time()
         try:
             while shared.shutdown == 0 and shared.safeConfigGetBoolean('bitmessagesettings', 'upnp'):
                 resp,(ip,port) = self.sock.recvfrom(1000)
                 if resp is None:
                     continue
                 newRouter = Router(resp, ip)
                 for router in self.routers:
                     if router.location == newRouter.location:
                         break
                 else:
                     logger.debug("Found UPnP router at %s", ip)
                     self.routers.append(newRouter)
                     self.createPortMapping(newRouter)
                     shared.UISignalQueue.put(('updateStatusBar', tr._translate("MainWindow",'UPnP port mapping established on port %1').arg(str(self.extPort))))
                     break
         except socket.timeout as e:
             pass
         except:
             logger.error("Failure running UPnP router search.", exc_info=True)
         for router in self.routers:
             if router.extPort is None:
                 self.createPortMapping(router)
     try:
         self.sock.shutdown(socket.SHUT_RDWR)
     except:
         pass
     try:
         self.sock.close()
     except:
         pass
     deleted = False
     for router in self.routers:
         if router.extPort is not None:
             deleted = True
             self.deletePortMapping(router)
     shared.extPort = None
     if deleted:
         shared.UISignalQueue.put(('updateStatusBar', tr._translate("MainWindow",'UPnP port mapping removed')))
     logger.debug("UPnP thread done")

 def setType(self):
     self.setFlags(self.flags() | QtCore.Qt.ItemIsEditable)
     if self.address is None:
         self.type = self.ALL
         self.setFlags(self.flags() & ~QtCore.Qt.ItemIsEditable)
     elif shared.safeConfigGetBoolean(self.address, 'chan'):
         self.type = self.CHAN
     elif shared.safeConfigGetBoolean(self.address, 'mailinglist'):
         self.type = self.MAILINGLIST
     elif sqlQuery(
         '''select label from subscriptions where address=?''', self.address):
         self.type = AccountMixin.SUBSCRIPTION
     else:
         self.type = self.NORMAL

 def __init__(self, address=None):
     self.address = address
     self.type = AccountMixin.NORMAL
     if shared.config.has_section(address):
         if shared.safeConfigGetBoolean(self.address, "chan"):
             self.type = AccountMixin.CHAN
         elif shared.safeConfigGetBoolean(self.address, "mailinglist"):
             self.type = AccountMixin.MAILINGLIST
     elif self.address == str_broadcast_subscribers:
         self.type = AccountMixin.BROADCAST
     else:
         queryreturn = sqlQuery("""select label from subscriptions where address=?""", self.address)
         if queryreturn:
             self.type = AccountMixin.SUBSCRIPTION

 def __init__(self, address, type = None):
     self.isEnabled = True
     self.address = address
     if type is None:
         if shared.safeConfigGetBoolean(self.address, 'mailinglist'):
             self.type = "mailinglist"
         elif shared.safeConfigGetBoolean(self.address, 'chan'):
             self.type = "chan"
         elif sqlQuery(
             '''select label from subscriptions where address=?''', self.address):
             self.type = 'subscription'
         else:
             self.type = "normal"
     else:
         self.type = type

    def run(self):
        # If there is a trusted peer then we don't want to accept
        # incoming connections so we'll just abandon the thread
        if shared.trustedPeer:
            return

        while shared.safeConfigGetBoolean("bitmessagesettings", "dontconnect"):
            time.sleep(1)
        helper_bootstrap.dns()
        # We typically don't want to accept incoming connections if the user is using a
        # SOCKS proxy, unless they have configured otherwise. If they eventually select
        # proxy 'none' or configure SOCKS listening then this will start listening for
        # connections.
        while shared.config.get("bitmessagesettings", "socksproxytype")[
            0:5
        ] == "SOCKS" and not shared.config.getboolean("bitmessagesettings", "sockslisten"):
            time.sleep(5)

        with shared.printLock:
            print "Listening for incoming connections."

        # First try listening on an IPv6 socket. This should also be
        # able to accept connections on IPv4. If that's not available
        # we'll fall back to IPv4-only.
        try:
            sock = self._createListenSocket(socket.AF_INET6)
        except socket.error, e:
            if isinstance(e.args, tuple) and e.args[0] in (errno.EAFNOSUPPORT, errno.EPFNOSUPPORT, errno.ENOPROTOOPT):
                sock = self._createListenSocket(socket.AF_INET)
            else:
                raise

def run(target, initialHash):
    target = int(target)
    if safeConfigGetBoolean('bitmessagesettings', 'opencl') and openclpow.has_opencl():
#        trialvalue1, nonce1 = _doGPUPoW(target, initialHash)
#        trialvalue, nonce = _doFastPoW(target, initialHash)
#        print "GPU: %s, %s" % (trialvalue1, nonce1)
#        print "Fast: %s, %s" % (trialvalue, nonce)
#        return [trialvalue, nonce]
        try:
            return _doGPUPoW(target, initialHash)
        except:
            pass # fallback
    if bmpow:
        try:
            return _doCPoW(target, initialHash)
        except:
            pass # fallback
    if frozen == "macosx_app" or not frozen:
        # on my (Peter Surda) Windows 10, Windows Defender
        # does not like this and fights with PyBitmessage
        # over CPU, resulting in very slow PoW
        # added on 2015-11-29: multiprocesing.freeze_support() doesn't help
        try:
            return _doFastPoW(target, initialHash)
        except:
            pass #fallback
    return _doSafePoW(target, initialHash)

def signal_handler(signal, frame):
    if shared.safeConfigGetBoolean('bitmessagesettings', 'daemon'):
        shared.doCleanShutdown()
        sys.exit(0)
    else:
        print('Unfortunately you cannot use Ctrl+C ' +
              'when running the UI because the UI captures the signal.')

def getBitfield(address):
    # bitfield of features supported by me (see the wiki).
    bitfield = 0
    # send ack
    if not shared.safeConfigGetBoolean(address, "dontsendack"):
        bitfield |= shared.BITFIELD_DOESACK
    return struct.pack(">I", bitfield)

    def run(self):
        # If there is a trusted peer then we don't want to accept
        # incoming connections so we'll just abandon the thread
        if shared.trustedPeer:
            return

        while shared.safeConfigGetBoolean('bitmessagesettings', 'dontconnect') and shared.shutdown == 0:
            self.stop.wait(1)
        helper_bootstrap.dns()
        # We typically don't want to accept incoming connections if the user is using a
        # SOCKS proxy, unless they have configured otherwise. If they eventually select
        # proxy 'none' or configure SOCKS listening then this will start listening for
        # connections.
        while shared.config.get('bitmessagesettings', 'socksproxytype')[0:5] == 'SOCKS' and not shared.config.getboolean('bitmessagesettings', 'sockslisten') and shared.shutdown == 0:
            self.stop.wait(5)

        logger.info('Listening for incoming connections.')

        # First try listening on an IPv6 socket. This should also be
        # able to accept connections on IPv4. If that's not available
        # we'll fall back to IPv4-only.
        try:
            sock = self._createListenSocket(socket.AF_INET6)
        except socket.error, e:
            if (isinstance(e.args, tuple) and
                e.args[0] in (errno.EAFNOSUPPORT,
                              errno.EPFNOSUPPORT,
                              errno.ENOPROTOOPT)):
                sock = self._createListenSocket(socket.AF_INET)
            else:
                raise

    def run(self):
        while shared.safeConfigGetBoolean('bitmessagesettings', 'dontconnect'):
            time.sleep(1)
        helper_bootstrap.dns()
        # We typically don't want to accept incoming connections if the user is using a
        # SOCKS proxy, unless they have configured otherwise. If they eventually select
        # proxy 'none' or configure SOCKS listening then this will start listening for
        # connections.
        while shared.config.get('bitmessagesettings', 'socksproxytype')[0:5] == 'SOCKS' and not shared.config.getboolean('bitmessagesettings', 'sockslisten'):
            time.sleep(5)

        logger.info('Listening for incoming connections.')

        HOST = ''  # Symbolic name meaning all available interfaces
        PORT = shared.config.getint('bitmessagesettings', 'port')
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        # This option apparently avoids the TIME_WAIT state so that we can
        # rebind faster
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind((HOST, PORT))
        sock.listen(2)

        while True:
            # We typically don't want to accept incoming connections if the user is using a
            # SOCKS proxy, unless they have configured otherwise. If they eventually select
            # proxy 'none' or configure SOCKS listening then this will start listening for
            # connections.
            while shared.config.get('bitmessagesettings', 'socksproxytype')[0:5] == 'SOCKS' and not shared.config.getboolean('bitmessagesettings', 'sockslisten'):
                time.sleep(10)
            while len(shared.connectedHostsList) > 220:
                logger.info('We are connected to too many people. Not accepting further incoming connections for ten seconds.')

                time.sleep(10)
            a, (HOST, PORT) = sock.accept()

            # The following code will, unfortunately, block an incoming
            # connection if someone else on the same LAN is already connected
            # because the two computers will share the same external IP. This
            # is here to prevent connection flooding.
            while HOST in shared.connectedHostsList:
                logger.info('We are already connected to %s . Ignoring connection.'%HOST)

                a.close()
                a, (HOST, PORT) = sock.accept()
            someObjectsOfWhichThisRemoteNodeIsAlreadyAware = {} # This is not necessairly a complete list; we clear it from time to time to save memory.
            a.settimeout(20)

            sd = sendDataThread()
            sd.setup(
                a, HOST, PORT, -1, someObjectsOfWhichThisRemoteNodeIsAlreadyAware)
            sd.start()

            rd = receiveDataThread()
            rd.daemon = True  # close the main program even if there are threads left
            rd.setup(
                a, HOST, PORT, -1, someObjectsOfWhichThisRemoteNodeIsAlreadyAware, self.selfInitiatedConnections)
            rd.start()

            logger.info('%s connected to %s during INCOMING request.'%(self,HOST))

 def get_api_address():
     if not shared.safeConfigGetBoolean('bitmessagesettings', 'apienabled'):
         return None
     address = shared.config.get('bitmessagesettings', 'apiinterface')
     port = shared.config.getint('bitmessagesettings', 'apiport')
     return {
         'address': address,
         'port': port
     }

def getMyAddresses():
    """
    Generator which returns all your addresses.
    """
    configSections = shared.config.sections()
    for addressInKeysFile in configSections:
        if addressInKeysFile != 'bitmessagesettings' and not shared.safeConfigGetBoolean(addressInKeysFile, 'chan'):
            isEnabled = shared.config.getboolean(
                addressInKeysFile, 'enabled')  # I realize that this is poor programming practice but I don't care. It's easier for others to read.
            if isEnabled:
                yield addressInKeysFile

def run(target, initialHash):
    target = int(target)
    if shared.safeConfigGetBoolean('bitmessagesettings', 'opencl') and openclpow.has_opencl():
#        trialvalue1, nonce1 = _doGPUPoW(target, initialHash)
#        trialvalue, nonce = _doFastPoW(target, initialHash)
#        print "GPU: %s, %s" % (trialvalue1, nonce1)
#        print "Fast: %s, %s" % (trialvalue, nonce)
#        return [trialvalue, nonce]
        return _doGPUPoW(target, initialHash)
    elif frozen == "macosx_app" or not frozen:
        return _doFastPoW(target, initialHash)
    else:
        return _doSafePoW(target, initialHash)

def createSupportMessage(myapp):
    checkAddressBook(myapp)
    address = createAddressIfNeeded(myapp)
    if shared.shutdown:
        return

    myapp.ui.lineEditSubject.setText(str(QtGui.QApplication.translate("Support", SUPPORT_SUBJECT)))
    addrIndex = myapp.ui.comboBoxSendFrom.findData(address, QtCore.Qt.UserRole, QtCore.Qt.MatchFixedString | QtCore.Qt.MatchCaseSensitive)
    if addrIndex == -1: # something is very wrong
        return
    myapp.ui.comboBoxSendFrom.setCurrentIndex(addrIndex)
    myapp.ui.lineEditTo.setText(SUPPORT_ADDRESS)
    
    version = shared.softwareVersion
    os = sys.platform
    if os == "win32":
        windowsversion = sys.getwindowsversion()
        os = "Windows " + str(windowsversion[0]) + "." + str(windowsversion[1])
    else:
        try:
            from os import uname
            unixversion = uname()
            os = unixversion[0] + " " + unixversion[2]
        except:
            pass
    architecture = "32" if ctypes.sizeof(ctypes.c_voidp) == 4 else "64"
    frozen = "N/A"
    if shared.frozen:
        frozen = shared.frozen
    portablemode = "True" if shared.appdata == shared.lookupExeFolder() else "False"
    cpow = "True" if bmpow else "False"
    #cpow = QtGui.QApplication.translate("Support", cpow)
    openclpow = "True" if shared.safeConfigGetBoolean('bitmessagesettings', 'opencl') and has_opencl() else "False"
    #openclpow = QtGui.QApplication.translate("Support", openclpow)
    locale = getTranslationLanguage()
    try:
        socks = shared.config.get('bitmessagesettings', 'socksproxytype')
    except:
        socks = "N/A"
    try:
        upnp = shared.config.get('bitmessagesettings', 'upnp')
    except:
        upnp = "N/A"
    connectedhosts = len(shared.connectedHostsList)

    myapp.ui.textEditMessage.setText(str(QtGui.QApplication.translate("Support", SUPPORT_MESSAGE)).format(version, os, architecture, frozen, portablemode, cpow, openclpow, locale, socks, upnp, connectedhosts))

    # single msg tab
    myapp.ui.tabWidgetSend.setCurrentIndex(0)
    # send tab
    myapp.ui.tabWidget.setCurrentIndex(1)

def translateText(context, text):
    if not shared.safeConfigGetBoolean('bitmessagesettings', 'daemon'):
        try:
            from PyQt4 import QtCore, QtGui
        except Exception as err:
            print 'PyBitmessage requires PyQt unless you want to run it as a daemon and interact with it using the API. You can download PyQt from http://www.riverbankcomputing.com/software/pyqt/download   or by searching Google for \'PyQt Download\'. If you want to run in daemon mode, see https://bitmessage.org/wiki/Daemon'
            print 'Error message:', err
            os._exit(0)
        return QtGui.QApplication.translate(context, text)
    else:
        if '%' in text:
            return translateClass(context, text.replace('%','',1))
        else:
            return text

    def processgetpubkey(self, data):
        readPosition = 20  # bypass the nonce, time, and object type
        requestedAddressVersionNumber, addressVersionLength = decodeVarint(
            data[readPosition:readPosition + 10])
        readPosition += addressVersionLength
        streamNumber, streamNumberLength = decodeVarint(
            data[readPosition:readPosition + 10])
        readPosition += streamNumberLength

        myAddress = ''
        if requestedAddressVersionNumber <= 3 :
            requestedHash = data[readPosition:readPosition + 20]
            if len(requestedHash) != 20:
                return
            if requestedHash in shared.myAddressesByHash:  # if this address hash is one of mine
                myAddress = shared.myAddressesByHash[requestedHash]
        elif requestedAddressVersionNumber >= 4:
            requestedTag = data[readPosition:readPosition + 32]
            if len(requestedTag) != 32:
                return
            if requestedTag in shared.myAddressesByTag:
                myAddress = shared.myAddressesByTag[requestedTag]

        if myAddress == '':
            return

        if decodeAddress(myAddress)[1] != requestedAddressVersionNumber:
            return
        if decodeAddress(myAddress)[2] != streamNumber:
            return
        if shared.safeConfigGetBoolean(myAddress, 'chan'):
            return
        try:
            lastPubkeySendTime = int(shared.config.get(
                myAddress, 'lastpubkeysendtime'))
        except:
            lastPubkeySendTime = 0
        if lastPubkeySendTime > time.time() - 2419200:  # If the last time we sent our pubkey was more recent than 28 days ago...
            return
        if requestedAddressVersionNumber == 2:
            shared.workerQueue.put((
                'doPOWForMyV2Pubkey', requestedHash))
        elif requestedAddressVersionNumber == 3:
            shared.workerQueue.put((
                'sendOutOrStoreMyV3Pubkey', requestedHash))
        elif requestedAddressVersionNumber == 4:
            shared.workerQueue.put((
                'sendOutOrStoreMyV4Pubkey', myAddress))