#! /usr/bin/env python
#-*- coding: iso-8859-1 -*-

# Mucous - a curses client for museek 
# Based on Museekchat
#
# Copyright (C) 2003-2004 Hyriand <hyriand@thegraveyard.org>
#
# Contributions by daelstorm (C) 2005
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import curses, sys, time, pwd, os, commands,  getopt,  threading, codecs
import curses.wrapper
import curses.textpad
import select, string, re, ConfigParser
from time import sleep
import messages, driver #from museek 

from UserDict import UserDict

class SortedDict(UserDict):
	def __init__(self):
		self.__keys__ = []
		self.__sorted__ = True
		UserDict.__init__(self)
	def __setitem__(self, key, value):
		if not self.__dict__.has_key(key):
			self.__keys__.append(key) 
			self.__sorted__ = False   
		UserDict.__setitem__(self, key, value)
	def __delitem__(self, key):
		self.__keys__.remove(key)
		UserDict.__delitem__(self, key)
	def keys(self):
		if not self.__sorted__:
			self.__keys__.sort()
			self.__sorted__ = True
		return self.__keys__
	def items(self):
		if not self.__sorted__:
			self.__keys__.sort()     
			self.__sorted__ = True
		for key in self.__keys__:
			yield key, self[key]		
alpha_list  = SortedDict()

states = {}
states[0] = "Finished"
states[1] = "Transferring"
states[2] = "Negotiating"
states[3] = "Waiting"
states[4] = "Establishing"
states[5] = "Initiating"
states[6] = "Connecting"
states[7] = "Queued"
states[8] = "Address"
states[9] = "Status"
states[10] = "Offline"
states[11] = "Closed"
states[12] = "Can't Connect"
states[13] = "Aborted"
states[14] = "Not Shared"

config_dir = str(os.path.expanduser("~/.mucous/"))
log_dir = str(os.path.expanduser("~/.mucous/logs/"))
config_file = config_dir+"config"

version = "0.5.2"

def usage():
	print ("""Mucous is a client for Museek, the P2P Soulseek Daemon
Authors: Daelstorm & Hyriand
Version: %s
	Default options: none
	-c,	--config <file>	Use a different config file
	-lc,	--log <dir>	Use a different logging directory
	-v,	--version	Display version and quit

	-h,	--help		Display this help and exit
	""" %version)
	sys.exit(2)
	
try:
	opts, args = getopt.getopt(sys.argv[1:], "hc:vl:", ["help", "config=", "version", "log="])
except getopt.GetoptError:
	# print help information and exit:
	usage()
	sys.exit(2)
for opts, args in opts:
	if opts in ("-h", "--help"):
		usage()
		sys.exit()
	if opts in ("-c", "--config"):
		print args
		config_file=str(os.path.expanduser(args))
	if opts in ("-l", "--log"):
		print args
		log_dir=str(os.path.expanduser(args))		
	if opts in ("-v", "--version"):
		print "Mucous version: %s" % version
		sys.exit(2)
		
parser = ConfigParser.ConfigParser()
# default config
mucous_config = {"connection":{"interface":'localhost:2240', "passw":None}, \
	"mucous":{"autobuddy": "no", "log_dir": "~/.mucous/logs/", "now-playing": "default", "now-playing-prefix": None}, "tickers":{'default_ticker': "http://thegraveyard.org/daelstorm/mucous.html", \
	'tickers_enabled': 'yes', "rooms":{} }, "rooms": {"default_room":"museek"}}
		


def create_config():

	parser.read([config_file])

	mucous_config_file = file(config_file, 'w')
	
	for i in mucous_config.keys():
		if not parser.has_section(i):
			parser.add_section(i)
		for j in mucous_config[i].keys():
			if j not in ["nonexisting", "hated", "options"]:
				parser.set(i,j, mucous_config[i][j])
			else:
				parser.remove_option(i,j)
	parser.write(mucous_config_file)
	mucous_config_file.close()	


def read_config():
	
	parser.read([config_file])
	for i in parser.sections():
		for j in parser.options(i):
			val = parser.get(i,j, raw = 1)

			if j in ['login','passw','interface', 'tickers_enabled', 'default_room', "autobuddy", "now-playing", "log_dir", "now-playing-prefix"] :
				mucous_config[i][j] = val
				#print j
			else:
				try:
					mucous_config[i][j] = eval(val, {})
				except:
					mucous_config[i][j] = None
# 		if i not in mucous_config.keys():
# 			print "Bogus config section:",i
# 		elif j not in mucous_config[i].keys() and j != "filter":
# 			print "Bogus config option",j,"section",i
# 		for j, z in parser.items(i):
# 			print i,  j, z
#	for j, z in mucous_config.items():
#		print j, z#[0], z[1]
# 	print "Config Loaded"

def update_config():
	mucous_config_file = file(config_file, 'w')
	for i in mucous_config.keys():
		if not parser.has_section(i):
			parser.add_section(i)
		for j in mucous_config[i].keys():
			if j not in ["sharedfiles","sharedfilesstreams","wordindex","fileindex","sharedmtimes"]:
				parser.set(i,j, mucous_config[i][j])
			else:
				parser.remove_option(i,j)
	parser.write(mucous_config_file)
	mucous_config_file.close()
	
def check_path():
	if os.path.exists(config_dir):
		if os.path.exists(config_file) and os.stat(config_file)[6] > 0:
			read_config()
		else:
			create_config()
			
	else:
		os.mkdir(config_dir, 0700)
		create_config()
check_path()


class editor:
	def __init__(self, win, escaped, tabbing, listline, textwin,  line = ""):
		self.win = win
		self.escaped = escaped
		self.tabbing = tabbing
		self.h, self.w = win.getmaxyx()
		self.scroll = 0
		self.textwin = textwin
		self.line = line
		self.x = len(self.line)
		self.fixpos()
		self.escape = False
		self.y = None
		self.word = None
		self.listline = listline
		self.firsttab = 0

	def process(self, c):
		pos = self.x + self.scroll
		
		# debugging: display keypress
		#print c

		if c != chr(9) and c !="KEY_MOUSE":  # Clear self.word if tab wasn't pressed
			self.word = None
			self.firsttab = 0
			self.listline = []
			
		if c == "KEY_MOUSE":
			if not self.escape:
				self.escaped(c, self.line)
		elif c == "KEY_LEFT" or c == chr(2):
			if self.escape:
				self.escaped(c, self.line)
			else:
				self.x -= 1
		elif c == chr(93) or c == chr(91)  or c == chr(34) or c == chr(35):
			if self.escape:
				self.escaped(c, self.line)
			else:
				self.line = self.line[:pos] + c + self.line[pos:]
				self.x += 1
		elif c == "KEY_RIGHT" or c == chr(6):
		
			if self.escape:
				self.escaped(c, self.line)
			else:
				self.x += 1
		elif c in ("KEY_F(1)", "KEY_F(2)", "KEY_F(3)", "KEY_F(4)", "KEY_F(5)", "KEY_F(6)", "KEY_F(7)", "KEY_F(8)", "KEY_F(9)", "KEY_F(10)"):
			if not self.escape:
				self.escaped(c, self.line)
			
 		elif c in ("KEY_UP", "KEY_DOWN", "KEY_PPAGE", "KEY_NPAGE", "KEY_HOME", "KEY_END"): 
			# Scrolling
			if not self.escape:
				self.escaped(c, self.line)
 		elif c == "KEY_IC": # Insert
			self.escaped(c, self.line)
		elif c == "KEY_DC" or c == chr(4):
			self.line = self.line[:pos] + self.line[pos+1:]
		elif c == chr(5):
			self.x = len(self.line)
		elif c == chr(1): # Ctrl - a
			self.x = self.scroll = 0
		elif c == chr(10) or c == "KEY_ENTER":
			self.escape = False
			return True
		elif c == chr(9): # Tab
			if self.word == None:
				w = self.line.split(' ')
				self.word = w[-1]
			#print "word is"+self.word
			if self.firsttab == None:
				self.firsttab = 0
			self.listline, self.firsttab= self.tabbing(self.line, self.word, self.firsttab, self.listline)
			#self.textwin.addstr(str(self.listline))
 			if self.listline != []:
 				self.line = ''
 				for r in self.listline:
 					if r is not self.listline[-1]:
 						self.line +=r +' '
					elif r is self.listline[-1]:
 						self.line +=r
			
			self.x = len(self.line)
			#return False
		elif c == chr(11):
			self.line = self.line[:pos]
			self.x = len(self.line)
			self.scroll = 0
		elif c == chr(23): # Ctrl-W
			z = self.line.split(' ')

			if len(z) >1:
				if z[-1] != ' ' and z[-1] != '':
					self.line = ''
					for s in z:
						if s is not z[-1]:
							self.line = self.line + s +" "
						elif s is z[-1]:
							self.line = self.line
							break
				else:
					self.line = ''
					for s in z:
						if s not in (z[-1], z[-2]):
							self.line = self.line + s +" "
						elif s is z[-2]:
							self.line = self.line
							break
			else:
				self.line = ''
			self.x = len(self.line)

		elif c == chr(127) or c == "KEY_BACKSPACE" or c == chr(8):
			if pos > 0:
				self.line = self.line[:pos-1] + self.line[pos:]
				self.x -= 1
		elif c == chr(27):
			self.escape = True
			return False
		elif len(c) == 1 and ord(c[0]) >= 32 and ord(c[0]) <127:
			# normal letters 
			self.line = self.line[:pos] + c + self.line[pos:]
			self.x += 1
		elif len(c) == 1 and ord(c[0]) >= 127 and ord(c[0]) <327:
			# everything else
			self.line = self.line[:pos] + c + self.line[pos:]
			self.x += 1
			self.fixpos()
			return False
			
		if c !="KEY_RESIZE":
			self.fixpos()
		self.escape = False
		return False

	def fixpos(self):
		self.x1 = self.x
		if self.x1 <= 0:
			self.x1 = 0	
		while self.scroll + self.x > len(self.line):
			self.x -= 1
			
		while self.x >= self.w:
			self.scroll += 1
			
			self.x -= 1
		if self.x < 0:
			self.scroll += self.x
			
			self.x = 0

		if self.scroll < 0:
			self.scroll = 0

		self.win.erase()

		self.win.addstr(self.line[self.scroll:self.scroll+self.w-1])
		self.win.refresh()

	def reset(self):
		self.x = self.scroll = 0
		self.line = ""
		self.win.erase()
		self.win.refresh()

class mucous(driver.Driver):

	def __init__(self):
		driver.Driver.__init__(self)
		self.rooms = {}
		self.joined = []
		self.current = None # Global edit title 
		self.username = None #  Your username
		self.manual_user = None # Manual Download Username
		self.pm_user = None # Last Private Messaged user
		self.pm_users = [] # Last Private Messaged user
		self.current_room = None # Current Chatroom
		
		# Temporary Logs
		self.log = [""] * 4
		self.onlinestatuslog =""
		self.usernamelog = [""] 
		self.uploadlog = ""
		self.downloadlog =""
		self.searchwinlog = ""
		self.buddylog = [""] 
		self.banlog = [""]
		self.ignorelog = [""]
		self.uptransferlog = [""]
		self.downtransferlog = [""]

		self.alertwinlog = ""
		self.privatelog = {}
		self.pminfolog = ["Global Private Messaging commands:\nType in the username you wish to PM below, and then type your messages, or use the commands below.","\n/pm <user>\n/pmclose <user>\n/msg <message>\n"]
		
		self.searchlog = ["Global search commands:\n/searchfor <query>\n/searchbuddy <query>\n/download <number>\nOr, type in the query, below."]
		
		self.browselog = ["Global browsing commands:\n/buser <user>\n/bdown <number>\n/bsearch <query>\nOr, type in the user you wish to browse, below."]
				
		self.infolog = ["","","","Global User Information commands:\n/userinfo <user>","\n/stat <user>","\n/ip <user>","\nOr type the user name that you wish get recieve userinfo from, below.", "\n--"]
		
		# Logging to file disabled by default
		if "logging" in mucous_config["mucous"].keys():
			self.logging = mucous_config["mucous"]["logging"]
		else:
			self.logging = False
		
		self.timer = None
		
		self.display_which_text = "chat" # default mode
		self.display_which_pm = None
		
		self.ip_requested = None
		self.info_requested = None
		self.stat_requested = None
		self.browse_requested = None
		
		self.status = None
		self.startup = 1
		self.size = None
		self.master_roomlist = {}
		self.roomlogs = {}
		self.statuslogs = {}
		
		self.tab_complete_list=[]
		self.listline = []
		self.scrollup = 0
		self.scrollup_static = 0
		self.requested_room_list = False
		
		self.all_roomlist = {}
		self.roomboxlist ={}
		# searches
		self.search_visible = 1
		self.s_tickets = []
		self.s_query = {}
		self.search_results = {}
		self.search_number = 0
		self.search_type = "globally"

		# transfers
		self.browse_results = {}
		self.browse_number = 0
		self.upload_number = 0
		self.upload_results = {}
		self.download_number = 0
		self.download_results = {}
		self.transfers = {}
		self.transfers["downloads"] = {}
		self.transfers["uploads"] = {}
		self.transfer_display_mode = 'active'
		self.transferscroll="upload"
		self.down_transfer_numbers = {}
		self.up_transfer_numbers = {}
		# config
		self.config = {}
		self.invalidpass = 0
		self.stats = []
		# tickers
		self.ticker_room = None
		self.master_ticklist = {}
		#colors
		

		self.unhide = "false" # show password?
		# Help lists
		self.commandlist =  "/me", "/join", "/part", "/leave", "/talk", "/list",  \
 "/help", "/info",  "/autojoin", "/noauto", "/roomlist", "/roomlistrefresh", \
"/inrooms", "/pm", "/pmclose", "/msg", "/np", "/npset", "/npcheck",\
"/npprefix", "/tick", "/settick", "/listtick", "/ticker", "/interface", "/password",\
"/save", "/connect", "/disconnect", "/autobuddy", "/privbuddy", "/onlybuddy",\
"/slots","/buddy", "/unbuddy",  "/ban", "/banlist", "/unban", "/nuke", "/unnuke",\
"/ignore", "/unignore",  "/unhide",  "/userinfo", "/ip", "/stat", "/away", "/abortup",\
"/abortdown",  "/removeup", "/removedown", "/retry", "/clearup", "/cleardown",\
"/search", "/searchfor", "/searchbuddy", "/download", "/downdir", "/browse",\
"/browseuser", "/browsesearch", "/browsedown",  "/downuser",\
"/downpath", "/downpathdir",  "/chat", "/ignorelist", "/banlist", "/transfer", "/private",\
"/buddylist", "/setup", "/quit",  "/share-mode", "/logging", "/reloadshares", "/rescanshares"
		# not real commands "/un", "/down", "/abort", "/remove",
		
		self.help_chat = "\n----[Chat Commands]---- \
\n/join <room> \t/part <room>\t/leave <room>\
\n/talk <room>\
\n/list <room>\t\t(lists of users)\
\n/autojoin <room>\t(autojoin room next session)\
\n/noauto <room>\t\t(don't autojoin next session)\
\n/roomlist <num users> \t(list of rooms >= number)\
\n/roomlistrefresh\t(redownload roomlist from server)\
\n/inrooms\t\t(list of joined rooms)\
\n/pm <user> \t\t(private message)\
\n/msg <message>\t\t(send message to last user)\
\n/np\t\t\t(XMMS/BMP Now playing script)\
\n/npcheck\t\t(display Now playing script command)\
\n/npset <command>\t(Set Now playing script to command)\
\n/npprefix <text>\t(set to np: or /me is now playing:)\
"
		
		self.help_ticker = "\n----[Ticker Commands]---- \
\n/tick <room> \t\t(Choose room to set ticker)\
\n/settick <message>\t(set ticker for last room)\
\n/listtick <room>\t(Lists tickers in room)\
\n/ticker \t\t(Toggle tickers)"

		self.help_connect = "\nConnection Configuration\
\n/interface </tmp/museekd.[username]> or <host:port>\
\n/password <interface password>\
\n/connect\t(Attempts to connect to Museekd)\
\n/disconnect\t(disconnects from Museekd)\
\n/save\t\t(Writes settings to config)"

		self.help_setup = "\nSetup\
\n/autobuddy\t(Auto-buddy users you download from)\
\n/privbuddy\t(Toggle Privileging buddies)\
\n/onlybuddy\t(Toggle Only sharing to buddies)\
\n/slots\t(Set upload slots)\
\n/unhide\t(Toggle show password)\
/logging\t(Toggle Logging)\
"

		self.help_user = "\n----[User Commands]---- \
\n/buddy\t<user>\t/unbuddy<user>\
\n/ban\t<user>\t/unban <user>\
\n/nuke\t<user>\t/unnuke <user>\
\n/ignore\t<user>\t/unignore<user>\
\n/userinfo <user>\
\n/stat\t<user>\t/ip <user>\
\n/away (Toggle your Online/Away Status)"

		self.help_transfer = "\n----[Transfer Commands]---- \
\n/abortu <num>\t/abortup <num>\t\t(Abort Upload)\
\n/abortd <num>\t/abortdown <num>\t(Abort Download)\
\n/removeu <num>\t/removeup <num>\t\t(Remove Upload)\
\n/removed <num>\t/removedown <num>\t(Remove Download)\
\n/retry <num> \t\t\t\t(Retry Download)\
\n/clearup \t\t\t\t(Clear failed/finished Uploads)\
\n/cleardown \t\t\t\t(Clear finished Download)\
"

		self.help_mode = "\n----[Mode Commands]---- \
\n/chat\t\t[Chat Mode]\
\n/transfer\t[Transfer Mode]\
\n/info\t\t[Info Mode]\
\n/browse\t\t[Browse Mode]\
\n/private\t[Private Message Mode]\
\n/search\t\t[Search Mode]\
\n/buddylist\t[Buddy Mode]\
\n/banlist\t[Ban Mode]\
\n/ignorelist\t[Ignore Mode]\
\n/setup\t[Setup Mode]\
"
		self.help_help = "\n----[Help Commands]---- \
\n/help\t\t(This Message)\
\n/help connect\t(Connection Commands)\
\n/help setup\t(Connection Commands)\
\n/help mode\t(Mode Commands)\
\n/help chat\t(Chatroom Commands)\
\n/help ticker\t(Ticker Commands)\
\n/help user\t(User Commands)\
\n/help transfer\t(Transfer Commands)\
\n/help search\t(Search Commands)\
\n/help download\t(Download Commands)\
\n/help keys\t(Special Keys)\
\n/quit"
		
		self.help_search = "\n----[Search/Browse Commands]----\
\n/search\t[Switch to Search Mode]\
\n/searchfor <query>\
\n/searchbuddy <query>\
\n/download <search number>\
\n/downdir <search number>\
\n/browse\t[Switch to Browse Mode]\
\n/browseuser /buser <user>\
\n/browsedown /bdown <search number>\
\n/browsesearch /bsearch <query>"
		
		self.help_download = "\n----[Manual Download Commands]----\
\n/downuser <user> (sets download user)\
\n/downpath <path> (download file from user)\
\n/downpathdir <path> (download dir from user)\
"
		self.help_keys ="\n------[Keys]------ \
\nESC or Alt + [, ], <-, ->\t(Change Room / Transfer display mode)\
\nInsert\t\t\t\t(Same as above)\
\nTab\t\t(Completes nicks)\
\nHome/End\t(switches Upload & Download scrolling)\
\nUp, PageUp\t(Scroll Up a line, a page)\
\nDown, PageDown\t(Scroll Down a line, a page)\
\nF1->Chat\t\tF6->Browse\
\nF2->Private Messages\tF7->Buddy List\
\nF3->Transfers\t\tF8->Ban List\
\nF4->Search\t\tF9->Ignore List\
\nF5->Info\t\tF10->Setup"

	def build(self, stdscr, line = ""):
		self.stdscr = stdscr
		self.stdscr.clear()
		self.stdscr.refresh()
		self.h, self.w = self.stdscr.getmaxyx()

		if  self.h >=15 and self.w >=77:
			
			self.inputwin = curses.newwin(3,self.w,self.h-4,0)
			self.inputwin.attron(blue)
			self.inputwin.border()
			self.inputwin.refresh()
			self.editwin = curses.newwin(1, self.w-2, self.h-3, 1)
			
			if self.display_which_text == "chat":
				self.chat_mode()

			elif self.display_which_text == "private":
				self.private_mode()

			elif self.display_which_text == "browse":
				self.browse_mode()

			elif self.display_which_text == "transfer":
				self.transfer_mode()

			elif self.display_which_text == "info":
				self.info_mode()
				
			elif self.display_which_text == "search":
				self.search_mode()
				
			elif self.display_which_text == "buddies":
				self.buddy_mode()
				
			elif self.display_which_text == "banned":
				self.ban_mode()
				
			elif self.display_which_text == "ignored":
				self.ignore_mode()
				
			elif self.display_which_text == "setup":
				self.setup_mode()
				
			self.onlinestatus =  curses.newwin(1, 8, 0, 0)
			self.onlinestatus.scrollok(1)
			self.onlinestatus.idlok(1)
			self.onlinestatus.addstr(self.onlinestatuslog)
			self.onlinestatus.refresh()
			
			self.uploadwin = curses.newwin(1, 10, 0, 25)
			self.uploadwin.scrollok(1)
			self.uploadwin.idlok(1)
			self.uploadwin.addstr(self.uploadlog, curses.A_UNDERLINE)
			self.uploadwin.refresh()
			
			self.downloadwin = curses.newwin(1, 10, 0, 35)
			self.downloadwin.scrollok(1)
			self.downloadwin.idlok(1)
			self.downloadwin.addstr(self.downloadlog, curses.A_UNDERLINE)
			self.downloadwin.refresh()
			

			self.searchwin = curses.newwin(1, 15, 0, self.w-30)
			self.searchwin.scrollok(1)
			self.searchwin.idlok(1)
			self.searchwin.addstr(self.searchwinlog, curses.A_UNDERLINE)
			self.searchwin.refresh()


			self.alertwin = curses.newwin(1, 15, 0, self.w-15)
			self.alertwin.scrollok(1)
			self.alertwin.idlok(1)
			self.alertwin.addstr(self.alertwinlog, red | curses.A_UNDERLINE)
			self.alertwin.refresh()

			self.usernamewin = curses.newwin(1, 16, 0, 9)
			self.usernamewin.scrollok(1)
			self.usernamewin.idlok(1)
			if self.username != None:
				self.usernamewin.addstr(self.username[:15])
			self.usernamewin.refresh()

			self.edit = editor(self.editwin, self.escaped, self.tabbing, self.listline, self.textwin, line)
			self.stdscr.nodelay(1)	

		else:

			sys.exit("\nMucous requires at least 77 columns and 15 rows")
			
	def cb_disconnected(self):
		#self.info_log("--- Disconnected from museekd ---")
		self.onlinestatuslog="\nClosed"
		self.onlinestatus.addstr(self.onlinestatuslog, red)
		self.onlinestatus.refresh()
		
		for room in self.joined:
			msg = ("--- Disconnected from museekd ---")
			self.say("Status", room, '!!!!', msg)
		
	def nickcheck(self):
		if self.username == None:
			self.info_mode()
			self.info_log("Connection is taking a while to start, maybe you are trying to connect to an FTP daemon?")
			self.info_log("Killing connection..")
			driver.Driver.close(self)
			
	def disconnect(self):
		driver.Driver.close(self)
		
	def connect(self):
		
		keys = []
		
		while 1:
			
			self.host = mucous_config["connection"]["interface"]
			self.password = mucous_config["connection"]["passw"]
			
			try:
				if self.invalidpass == 0:
					if self.password != None:
						self.timer = threading.Timer(5.0, self.nickcheck)
						self.timer.start()
						driver.Driver.connect(self, self.host, self.password, messages.EM_CHAT |  messages.EM_USERINFO| messages.EM_PRIVATE| messages.EM_TRANSFERS  | messages.EM_USERSHARES | messages.EM_CONFIG)
						
						break
					else:
						raise Exception,  "IdASS"
				else:
					raise Exception,  "INVPASS"
					

			except Exception, e:
				self.info_mode()
				#self.info_log(str(e))
				if self.timer != None:
					self.timer.cancel()
				if e == "INVPASS":
					self.info_log("Incorrect Password, try another.")
				elif e == [111, "Connection refused"]:
					self.info_log(e[1] +", make sure the daemon is running, or change the interface.")
				self.info_log("Connection failed, try changing your interface or password")
				self.info_log(self.help_connect)
				q = "42"
				while q == "42":
					sleep(0.01)
					try:
						c = self.stdscr.getkey(self.h-3, self.edit.x+1)
						keys.append(c)
					except:
						pass
					if not keys:
						d = 1000
					else:
						d = 0
					while keys:
						c, keys = keys[0], keys[1:]
						
						if self.edit.process(c):
							line = self.edit.line
							if line == "/quit" or line == "/exit":
								return
							if line[:11] == "/interface " and line[11:] != "":
								self.info_mode()
								mucous_config["connection"]["interface"] = line[11:]
								self.info_log("Museekd interface set to: " + line[11:])
							elif line[:10] == "/password " and line[10:] != "":
								self.info_mode()
								mucous_config["connection"]["passw"] = line[10:]
								self.info_log("New password set")
							elif line[:8] == "/connect":
								self.chat_mode()
								self.invalidpass = 0
								q = "43"
							elif line[:8] == "/version":
								self.info_mode()
								self.info_log("\nMucous version: %s" % version)
							elif line[:5] == "/help":
								self.info_mode()
								self.info_log(self.help_connect)
							elif line[:5] == "/save":
								update_config()
								self.info_mode()
								self.info_log("Config Saved")
							elif line[:5] == "/list":
								self.info_log(mucous_config["connection"]["interface"])
								self.info_log(mucous_config["connection"]["passw"])
							self.edit.reset()
	def process(self):
#		c = None
		keys = []
		
		while 1:
			try:
				c = self.stdscr.getkey(self.h-3, self.edit.x+1)
				keys.append(c)
			except:
				pass

			if not keys:
				d = 1000
			else:
				d = 0
			if self.socket != None:
				r, w, x = select.select([self.socket, sys.stdin], [], [self.socket], d)
			else:
				sleep(0.01)
			if self.socket in r:
				driver.Driver.process(self)

			if sys.stdin in r:
				try:
					c = self.stdscr.getkey(self.h-2, self.edit.x)
					keys.append(c)
					
				except Exception, e:
					pass
			while keys:
				c, keys = keys[0], keys[1:]

				if self.edit.process(c):
					line = self.edit.line
					if line[:1] == "/" and line[:4] != "/me " and line[:2] != '//':


						if line == "/quit" or line == "/exit":
							return
						elif line[:11] == "/disconnect":
							self.disconnect()
						elif line[:5] == "/help":
							
							self.info_mode()
							if line[5:] == " chat":
								self.info_log(self.help_chat)
							elif line[5:] == " mode":
								self.info_log(self.help_mode)
							elif line[5:] == " user":
								self.info_log(self.help_user)
							elif line[5:] == " search":
								self.info_log(self.help_search)
							elif line[5:] == " browse":
								self.info_log(self.help_search)
							elif line[5:] == " transfer":
								self.info_log(self.help_transfer)
							elif line[5:] == " ticker":
								self.info_log(self.help_ticker)
							elif line[5:] == " download":
								self.info_log(self.help_download)
							elif line[5:] == "":
								self.info_log(self.help_help)
							elif line[5:] == " keys":
								self.info_log(self.help_keys)
							elif line[5:] == " connect":
								self.info_log(self.help_connect)
							elif line[5:] == " setup":
								self.info_log(self.help_setup)
							self.edit.reset()
							'''
							Chatrooms
							'''
						elif line[:6] == "/talk ": 
							self.set_room(line[6:])
							
						elif line[:6] == "/join ":
							self.send(messages.JoinRoom(line[6:]))
							
						elif line == "/part" and self.current_room or line == "/leave" and self.current_room:
							self.send(messages.LeaveRoom(self.current_room))
							
						elif line[:6] == "/part ":
							if line[:6] in self.joined:
								self.send(messages.LeaveRoom(line[6:]))
						elif line[:7] == "/leave ":
							if line[:7] in self.joined:
								self.send(messages.LeaveRoom(line[6:]))
							
						elif line[:10] == "/autojoin ":
							if line[10:] in rooms.joined:
								self.send(messages.ConfigSet("autojoin", line[10:], ""))
								self.info_log("Added %s to AutoJoin list" % line[5:])
							
						elif line[:8] == "/noauto ":
							if line[8:] in rooms.joined:
								self.send(messages.ConfigRemove("autojoin", line[8:]))
								self.info_log("Removed %s from AutoJoin list" % line[7:])

						elif line[:4] == "/pm " and line[4:] != '':
							self.pm_user = line[4:]
							self.start_pm(self.pm_user)
							if self.display_which_text == 'private':
								self.private_mode()
							
						elif line[:9] == "/pmclose " and line[9:] != '':
							user = line[9:]
							if user in self.pm_users:
								self.pm_users.remove(user)
								for users in self.pm_users:
									self.pm_user = users
									if self.display_which_text == 'private':
										self.private_mode()
									break
								self.pm_user = None
								if self.display_which_text == 'private':
									self.private_mode()
						elif line[:5] == "/msg " and line[5:] != '':
							if self.pm_user != None:
								message = line[5:]
								self.send(messages.PrivateMessage(self.pm_user, message))
 								self.send_private_message(self.pm_user, message)
							else:
								self.info_mode()
								self.info_log("Set a user to message with /pm!")
						elif line[:5] == "/away":
							if self.status == 0:
								self.send(messages.SetStatus(1))
							elif self.status == 1:
								self.send(messages.SetStatus(0))
								
						elif line[:3] == "/np" and line[3:] == '':
							if "now-playing" in mucous_config["mucous"].keys():
								if mucous_config["mucous"]["now-playing"] == "default":
									p = "/tmp/xmms-info"
									if os.path.exists(p):
										fsock = open(p)
										for i in range(3):  s = fsock.readline()[8:-1]
										for i in range(10):  m = fsock.readline()[7:-1]
										message ="Now %s: %s " % (s, m)
										fsock.close()
										if self.display_which_text == "chat":
											self.send(messages.SayRoom(self.current_room, message))
									else: self.info_log("WARNING: XMMS or BMP isn't running or the InfoPipe plugin isn't enabled")
								else:
									p = mucous_config["mucous"]["now-playing"]
									nowplaying = commands.getoutput(p)
									nowplaying = nowplaying.split('\n')
									nowplaying = nowplaying[0]
									if self.display_which_text == "chat":
										if mucous_config["mucous"]["now-playing-prefix"] != None:
											self.send(messages.SayRoom(self.current_room, "%s %s" % (mucous_config["mucous"]["now-playing-prefix"], nowplaying) ) )
										else:
											self.send(messages.SayRoom(self.current_room, nowplaying))
									
						elif line[:7] == "/npset " and line[7:] != '':
							mucous_config["mucous"]["now-playing"] =line[7:]
							
						elif line[:8] == "/npcheck" and line[8:] == '':
							if "now-playing" in mucous_config["mucous"].keys():
								self.info_log("Now playing command is: "+ str(mucous_config["mucous"]["now-playing"]))
							
						elif line[:10] == "/npprefix " and line[10:] != '':
							mucous_config["mucous"]["now-playing-prefix"] = line[10:]
							
						elif line[:13] == "/rescanshares":
							self.daemon="local"
							if self.daemon=="local":
								p = "/usr/bin/muscan"
								
								if os.path.exists(p):
									os.system(p+" &")
							elif self.daemon=="remote":
								os.system('xterm -fg white -bg black -e musetup')
						elif line[:13] == "/reloadshares":
							self.daemon="local"
							if self.daemon=="local":
								p = "/usr/bin/museekd"
								if os.path.exists(p):
									os.system("killall -HUP museekd")
						elif line[:8] == "/logging":
							if self.logging == True:
								self.logging = False
							elif self.logging == False:
								self.logging = True
							mucous_config["mucous"]["logging"] = self.logging
							'''
							User Information
							'''
						elif line[:10] == "/userinfo " and line[10:] != '':
							self.info_requested = line[10:]
							self.send(messages.UserInfo(self.info_requested))
								
						elif line[:3] == "/tc":
							self.completion_list()
							
						elif line[:4] == "/ip " and line[4:] != '':
							self.ip_requested = str(line[4:])
							self.send(messages.PeerAddress(self.ip_requested))
							
						elif line[:6] == "/stat " and line[6:] != '':
							self.stat_requested = str(line[6:])
							self.send(messages.PeerStats(self.stat_requested))
							'''
							MODE SELECTIONS
							'''
						
						elif line[:5] == "/chat" and line[5:] == '':
							self.chat_mode()

						elif line[:8] == "/private"  and line[8:] == '':
							self.private_mode()

						elif line[:7] == "/search"  and line[7:] == '':
							self.search_mode()

						elif line[:9] == "/transfer"  and line[9:] == '':
							self.transfer_mode()

						elif line[:5] == "/info"   and line[5:] == '':
							self.info_mode()
							
						elif line[:10] == "/buddylist"   and line[10:] == '':
							self.buddy_mode()
							
						elif line[:8] == "/banlist"   and line[8:] == '':
							self.ban_mode()
							
						elif line[:11] == "/ignorelist"   and line[11:] == '':
							self.ignore_mode()
						elif line[:6] == "/setup"   and line[6:] == '':
							self.setup_mode()
							
							'''
							CONFIG
							'''
						elif line[:5] == "/save" and line[5:] == '':
							update_config()
							self.info_mode()
							self.info_log("Config Saved")
						elif line[:11] == "/interface " and line[11:] != "":
							mucous_config["connection"]["interface"] = line[11:]
							self.info_log("Museekd interface set to: " + line[11:])

						elif line[:10] == "/password " and line[10:] != "":
							mucous_config["connection"]["passw"] = line[10:]
							self.info_log("New password set")

						elif line[:8] == "/version":
							self.info_mode()
							self.info_log("\nMucous version: %s" % version)
						elif line[:8] == "/connect":
							self.connect()
						
							'''
							Tickers
							'''
						elif line[:5] == "/tick":
							if line[5:] == '':
								self.ticker_room =  self.current_room
								self.info_log("You picked room: " +self.ticker_room+" to set a ticker.")
								self.info_mode()
							elif line[5:6] == " " and line[6:] != '':
								self.ticker_room = line[6:]
								self.info_log("You picked room: " +self.ticker_room+" to set a ticker.")
								self.info_mode()
								
						elif line[:7] == "/ticker" and line[7:] == '':
							if mucous_config["tickers"]["tickers_enabled"] == 'no':
								mucous_config["tickers"]["tickers_enabled"] = 'yes'
								self.info_log("Tickers Enabled")
							elif mucous_config["tickers"]["tickers_enabled"] == 'yes':
								mucous_config["tickers"]["tickers_enabled"] = 'no'
								self.info_log("Tickers Disabled")

						elif line[:9] == "/tickroom" and line[9:] == '':
							self.ticker_room = self.current_room
							self.set_room("% Set ticker for: "+ self.current_room+(" %"))

						elif line[:9] == "/settick " and line[9:] != '':
							if self.ticker_room != None:
								message = line[9:]
								self.send(messages.RoomTickerSet(self.ticker_room, message))
								mucous_config["tickers"]["rooms"][self.ticker_room]=message
								self.info_log("You set your ticker in " +self.ticker_room+" to "+message)
							else:
								self.info_log("Choose a room with /tick, first.") 
							'''
							List tickers in current room or selected rooms
							'''
						
						elif line[:9] == "/listtick":
							if line [9:] == '':
								woom = self.current_room
							else:
								woom = line[10:]
								
							alpha_list  = SortedDict()
							for rooms in self.master_ticklist:
								alpha_list[rooms] = self.master_ticklist[rooms]
							if mucous_config["tickers"]["tickers_enabled"] == 'yes':
								for rooms, ticks in alpha_list.items():
									if rooms == woom:
										self.info_log("Tickers in room: "+str(rooms))
										ttickers =[]
										ttickers = ticks.keys()
										ttickers.sort()
										for names in ttickers:
											self.info_log(" ["+str(names)+'] '+str(ticks[names]))
										self.textwin.refresh()

							'''
							User Management
							'''
						elif line[:5] == "/ban " and line[5:] != '':
							username = line[5:]
							if username not in self.config["banned"].keys():
								self.send(messages.ConfigSet("banned", username, "banned by mucous"))
							
						elif line[:7] == "/unban " and line[7:] != '':
							username = line[7:]
							if username in self.config["banned"].keys():
								self.send(messages.ConfigRemove("banned", username))
							else:
								self.info_log("User not in ban list: %s" % username)
								
						elif line[:8] == "/ignore " and line[8:] != '':
							username = line[8:]
							if username not in self.config["ignored"].keys():
								self.send(messages.ConfigSet("ignored", username, ""))
								self.info_log("Ignored: %s" % username)
							
						elif line[:10] == "/unignore " and line[10:] != '':
							username = str(line[10:])
							if username in self.config["ignored"].keys():
								self.send(messages.ConfigRemove("ignored", username))
							else:
								self.info_log("User not in ignore list: %s" % username)
									
						elif line[:7] == "/buddy " and line[7:] != '':
							username = str(line[7:])
							if username not in self.config["buddies"].keys():
								self.send(messages.ConfigSet("buddies", username, "buddied by mucous"))

						elif line[:9] == "/unbuddy " and line[9:] != '':
							username = str(line[9:])
							if username in self.config["buddies"].keys():
								self.send(messages.ConfigRemove("buddies", username))
							else:
								self.info_log("User not in buddy list: %s" % username)
									
						elif line[:11] == "/share-mode":
							if self.config["transfers"]["only_buddies"] == "true":
								self.send(messages.ConfigSet("transfers", "only_buddies", "false"))
								
							elif self.config["transfers"]["only_buddies"] == "false":
								self.send(messages.ConfigSet("transfers", "only_buddies", "true"))

							
						elif line[:11] == "/autobuddy":
							if mucous_config["mucous"]["autobuddy"]  == "yes":
								mucous_config["mucous"]["autobuddy"] = "no"
								self.info_log("AutoBuddy Disabled")
							elif mucous_config["mucous"]["autobuddy"]  == "no":
								mucous_config["mucous"]["autobuddy"] = "yes"
								self.info_log("AutoBuddy Enabled")
								
						elif line[:6] == "/nuke " and line[6:] != '':
							username = str(line[6:])
							if username not in self.config["banned"].keys():
								self.send(messages.ConfigSet("banned", username, "banned by mucous"))
							if username not in self.config["ignored"].keys():
								self.send(messages.ConfigSet("ignored", username, ""))
							self.info_log("Nuked: %s" % username)
							
						elif line[:8] == "/unnuke " and line[8:] != '':
							username = str(line[8:])
							if username in self.config["ignored"].keys():
								self.send(messages.ConfigRemove("ignored", username))

							if username in self.config["banned"].keys():
								self.send(messages.ConfigRemove("banned", username))
							self.info_log("Irradiated: %s" % username)
								
							'''
							List Users in room
							'''
						elif line[:5] == "/list":
							self.startup = 0
							if line [5:6] == ' ':
								woom = line[6:]
							else:
								woom = self.current_room
							if woom != None:
								self.show_nick_list(woom)
							
							'''
							List Rooms whose number of users is greater than the number you input
							'''
						elif line[:9] == "/roomlist":
							if line[9:] == '':
								self.display_room_list()
							elif line[9:10] == ' ':
								try:
									self.size = int(line[10:])
									self.display_room_list()
								except:
									self.info_log("Input an integer with /roomlist")
							elif line[9:] == 'refresh':
								self.requested_room_list = True
								self.send(messages.RoomList())
							
						elif line[:8] == "/inrooms" and line[8:] == '':
							w = ''
							for room in self.joined:
								w += room + ', '
								
							self.info_log("You are in: %s" %w[:-2])
							
							'''
							Manual Download
							'''	
						elif line[:10] == "/downuser " and  line[10:] != '':
							self.transfer_mode()
							self.manual_user = line[10:]
							self.set_edit_title("% % User: "+line[10:] + " (input download path) % %")
								
						elif line[:10] == "/downpath " and line[10:] != '':
							path = line[10:]
							if self.manual_user != None and self.manual_user != '':
								user = self.manual_user
								self.send(messages.DownloadFile(user, path))
								self.info_log("Trying to Download: " + path+" from "+ user)
						elif line[:13] == "/downpathdir " and line[13:] != '':
							directory = line[13:]
							if self.manual_user != None and self.manual_user != '':
								user = self.manual_user
								self.send(messages.GetFolderContents(user, directory))
								self.info_log("Try to Download directory: %s from %s" % (directory, user))

							'''
							Search Globally for files & Download them
							'''
						elif line[:11] == "/searchfor " and line[11:] != '':
							query = line[11:]
							if query not in ('mp3', ' '):
								self.send(messages.Search(query))
								self.search_log("Started search for: "+ query)
							else:
								self.search_log("Query \""+ query+"\" was ignored")
						elif line[:13] == "/searchbuddy " and line[13:] != '':
							query = line[13:]
							self.send(messages.BuddySearch(query))
							self.search_log("Started Buddy search for: "+ query)
								
						elif line[:10] == "/download " or line[:9] == "/downdir ":
							sinput = None
							dinput = None
							linput = None
							if line[:10] == "/download " and line[10:] != '':
								linput = sinput = line[10:]
							elif line[:9] == "/downdir "  and line[9:] != '':
								linput = dinput = line[9:]
							if linput != None:
								try:
									searchnum = int(linput)
									if self.search_results != {}:
										if self.search_results[searchnum] != None:
											user = self.search_results[searchnum][1]
											path = self.search_results[searchnum][5]
											if sinput != None:
												self.send(messages.DownloadFile(user, path))
												self.info_log("Try to Download file: %s from %s" % (path, user))
											elif dinput != None:
												r = path.split('\\')
												directory = ''
												for s in r:
													if s != r[-1]:
														directory += s+'\\'
												self.send(messages.GetFolderContents(user, directory))
												self.info_log("Try to Download directory: %s from %s" % (directory, user))
											
											if mucous_config["mucous"]["autobuddy"]  == "yes":
												if user not in self.config["buddies"].keys():
													self.send(messages.ConfigSet("buddies", user, "buddied by mucous"))
													self.info_log("Auto-Buddied: %s" % user)
										else:
											self.info_log("No such file")
									else:
										self.info_log("You need to search, first ;)")
								except:
									self.info_log("Enter an Integer")
									
							'''
							Browse Shares & Download from them
							'''
						elif line[:12] == "/browseuser " or line[:7] == "/buser ":
							user = None
							if line[:12] == "/browseuser " and line[12:] != '':
								user = line[12:]
							elif line[:7] == "/buser " and line[7:] != '':
								user = line[7:]
							if user != None:
								self.browse_requested = user
								self.send(messages.UserShares(user))
								self.browse_log("\nStarted browsing: %s" % user)
						elif line[:14] == "/browsesearch " or line[:9] == "/bsearch ":
							l_input = None
							if line[:14] == "/browsesearch " and line[14:] != '':
								l_input = line[14:]
							elif line[:9] == "/bsearch " and line[9:] != '':
								l_input = line[9:]
							if l_input != None:
								search = re.compile('.*' +str(l_input) + '.*', re.DOTALL | re.I)
								self.browse_log("search compiled")
								for item, path in self.browse_results.items():
									if re.match( search, path[1]):
										self.browse_log("Found: [" + str(item) +'] ' +path[1])
									
						elif line[:12] == "/browsedown " or line[:7] == "/bdown ":
							l_input = None
							if line[:12] == "/browsedown " and line[12:] != '':
								l_input = line[12:]
							elif line[:7] == "/bdown " and line[7:] != '':
								l_input = line[7:]
							if l_input != None:
								try:
									browsenum = int(l_input)
									if self.browse_results != {}:
										if self.browse_results[browsenum] != None:
											username = self.browse_results[browsenum][0]
											path = self.browse_results[browsenum][1]
											self.send(messages.DownloadFile(user, path))
											self.info_log("Try to Download: %s from %s" % (path, username))
										
											if mucous_config["mucous"]["autobuddy"]  == "yes":
												if username not in self.config["buddies"].keys():
													self.send(messages.ConfigSet("buddies", username, "buddied by mucous"))
													self.info_log("Auto-Buddied: %s" % username)
											
										else:
											self.info_log("No such file")
									else:
										self.info_log("You need to browse, first ;)")
								except:
									self.info_log("Enter an Integer")

						elif line[:11] == "/hidesearch":
							self.search_visible = 0
							self.info_log("Searches hidden")
							
						elif line[:11] == "/showsearch":
							self.search_visible = 1
							self.info_log("Searches made visible")
							'''
							Manage Transfers
							'''
						elif line[:8] == "/abortd " or line[:11] == "/abortdown ":
							transfer = None
							if line[:8] == "/abortd " and line[8:] != '':
								try:
									transfer = int(line[8:])
								except:
									self.info_log("Enter an Integer")
							elif line[:11] == "/abortdown " and line[11:] != '':
								try:
									transfer = int(line[11:])
								except:
									self.info_log("Enter an Integer")
								
							if transfer != None:
								if transfer in self.down_transfer_numbers.keys():
									for username, path in self.down_transfer_numbers[transfer].items():
										#self.info_log(username +' '+ path)
										self.info_log("Aborting download: [%s] %s" % (username, path))
										self.send(messages.TransferAbort(0, username, path))
								else:
									self.info_log("No such transfer #" + str(transfer))
						elif line[:8] == "/abortu " or line[:9] == "/abortup ":
							transfer = None
							if line[:8] == "/abortu " and line[8:] != '':
								try:
									transfer = int(line[8:])
								except:
									self.info_log("Enter an Integer")
							elif line[:9] == "/abortup " and line[9:] != '':
								try:
									transfer = int(line[9:])
								except:
									self.info_log("Enter an Integer")
							if transfer != None:
								if transfer in self.up_transfer_numbers.keys():
									for username, path in self.up_transfer_numbers[transfer].items():
										self.info_log("Aborting upload: [%s] %s" % (username, path))
										self.send(messages.TransferAbort(1, username, path))
								else:
									self.info_log("No such transfer #" + str(transfer))
						elif line[:9] == "/removeu " or line[:10] == "/removeup ":
							transfer = None
							if line[:9] == "/removeu " and line[9:] != '':
								try:
									transfer = int(line[9:])
								except:
									self.info_log("Enter an Integer")
							elif line[:10] == "/removeup " and line[10:] != '':
								try:
									transfer = int(line[10:])
								except:
									self.info_log("Enter an Integer")
							if transfer != None:
								if transfer in self.up_transfer_numbers.keys():
									for username, path in self.up_transfer_numbers[transfer].items():
										self.info_log("Removing upload: [%s] %s" % (username, path))
										self.send(messages.TransferRemove(1, username, path))
								else:
									self.info_log("No such transfer #" + str(transfer))
								

						elif line[:9] == "/removed " or line[:12] == "/removedown ":
							transfer = None
							if line[:9] == "/removed " and line[9:] != '':
								try:
									transfer = int(line[9:])
								except:
									self.info_log("Enter an Integer")
							elif line[:12] == "/removedown " and line[12:] != '':
								try:
									transfer = int(line[12:])
								except:
									self.info_log("Enter an Integer")
							if transfer != None:
								if transfer in self.down_transfer_numbers.keys():
									for username, path in self.down_transfer_numbers[transfer].items():
										self.info_log("Removing download: [%s] %s" % (username, path))
										self.send(messages.TransferRemove(0, username, path))
								else:
									self.info_log("No such transfer #" + str(transfer))

									
						elif line[:7] == "/retry " and line[7:] != '':
							transfer = None
							try:
								transfer = int(line[7:])
							except:
								self.info_log("Enter an Integer")
							if transfer != None:
								if transfer in self.down_transfer_numbers.keys():
									for username, path in self.down_transfer_numbers[transfer].items():
										self.info_log("Retrying download: [%s] %s" % (username, path))
										self.send(messages.DownloadFile(username, path))
								else:
									self.info_log("No such transfer #" + str(transfer))
							
						elif line[:7] == "/slots " and line[7:] != "":
							slots = None
							try:
								slots = int(line[7:])
							except:
								self.info_log("Enter an Integer")
							if slots != None:
								self.send(messages.ConfigSet("transfers", "upload_slots", str(slots)))

						elif line[:10] == "/privbuddy":
							if self.config["transfers"]["privilege_buddies"] == "true":
								self.send(messages.ConfigSet("transfers", "privilege_buddies", "false"))
								
							elif self.config["transfers"]["privilege_buddies"] == "false":
								self.send(messages.ConfigSet("transfers", "privilege_buddies", "true"))
								
								
						elif line[:10] == "/onlybuddy":
							if self.config["transfers"]["only_buddies"] == "true":
								self.send(messages.ConfigSet("transfers", "only_buddies", "false"))
							elif self.config["transfers"]["only_buddies"] == "false":
								self.send(messages.ConfigSet("transfers", "only_buddies", "true"))

						elif line[:7] == "/unhide":
							if self.unhide == "true":
								self.unhide = "false"
							elif self.unhide == "false":
								self.unhide = "true"
							if self.display_which_text == "setup":
								self.setup_mode()
						elif line[:10] == "/buddyall":
							self.info_log("Buddying ALL users currently transferring to or from you.")
							currentusersintransferlist = {}
							for userpath, values in self.transfers["uploads"].items():
								currentusersintransferlist[values[1]] = 0
							for userpath, values in self.transfers["downloads"].items():
								currentusersintransferlist[values[1]] = 0
							for username in currentusersintransferlist.keys():
								if username not in self.config["buddies"].keys():
									self.send(messages.ConfigSet("buddies", username, "Buddied by mucous"))
								
						elif line[:8] == "/clearup":
							for userpath, values in self.transfers["uploads"].items():
								if values[3] in (0, 10, 11, 12, 13, 14):
									self.send(messages.TransferRemove(1, values[1], values[2]))
									
						elif line[:10] == "/cleardown":
							for userpath, values in self.transfers["downloads"].items():
								if values[3] == 0:
									self.send(messages.TransferRemove(0, values[1], values[2]))

						else:
							continue
						self.edit.reset()
					elif self.current and line:
						'''
						Special Input Box for Downloading Manually
						'''
						# escape //
						if line[:2] == '//':
							line = line[1:]
						# Manual Download input box
						if self.current[:10] == '% % User: ' and line != '':
							if self.manual_user != None and self.manual_user != '':
								path = line
								self.send(messages.DownloadFile(self.manual_user, path))
								self.info_log("Trying to Download: " + path+" from "+ self.manual_user)
						# Ticker set input box
						elif self.current[:12] == '% Set ticker' and line != '':
							self.send(messages.RoomTickerSet(self.ticker_room, line))
							

						else:
							if line != '':
								if self.display_which_text == "chat":
									#Normal Chat Room Message
									if self.current_room:
										self.send(messages.SayRoom(self.current_room, line))
									
								
								elif self.display_which_text == "private":
									#Normal Private Messaging
									if self.pm_user != None:
										# Private Message
										self.send(messages.PrivateMessage(self.pm_user, line))
										self.send_private_message(self.pm_user, line)
									else:
										# Set user to message
										self.pm_user = line
										self.start_pm(self.pm_user)
										self.set_edit_title("Send message to: " + self.pm_user)
										
								elif self.display_which_text == "search":
									
									if len(line) > 2 and line != 'mp3':
										# Normal Search
										if self.search_type == "globally":
											self.send(messages.Search(line))
										# Buddies Search
										elif self.search_type == "buddies":
											self.send(messages.BuddySearch(line))
								elif self.display_which_text == "browse":
									# Browse User's shares
									self.send(messages.UserShares(line))
								elif self.display_which_text == "info":
									# Get User's UserInfo and PeerStats
									self.info_log("Getting information about user: " +line)
									self.info_requested = self.stat_requested = line
									self.send(messages.UserInfo(line))
									self.send(messages.PeerStats(line))
								elif self.display_which_text == "buddies":
									if line not in self.config["buddies"].keys():
										self.send(messages.ConfigSet("buddies", line, "buddied by mucous"))
										
								elif self.display_which_text == "banned":
									if line not in self.config["banned"].keys():
										self.send(messages.ConfigSet("banned", line, "banned by mucous"))
									
								elif self.display_which_text == "ignored":
									if line not in self.config["ignored"].keys():
										self.send(messages.ConfigSet("ignored", line, "ignored by mucous"))
						self.edit.reset()
						
	# -- v Museek Messages v
	
	def cb_login_error(self, reason):
		if reason == "INVPASS":
			self.invalidpass = 1
			self.info_log("couldn't log in: Invalid Password")
			self.connect()
		else:
			self.invalidpass = 0
			self.info_log("couldn't log in: " + reason)

	def cb_login_ok(self):
		self.invalidpass = 0
		self.info_log("Logging in...")
		
	
	def cb_server_state(self, state, username):

		self.username = username
		
		self.usernamewin.addstr(self.username[:15])
		self.usernamewin.refresh()
		
		self.upload_status("0")
		self.download_status("0")
		self.search_status("\nResults: 0")
		
		if state:
			self.info_log("connected to soulseek, username: " + username)
			self.onlinestatuslog="\nOnline"
			if mucous_config["tickers"]["tickers_enabled"] == 'yes':
				self.info_log("Tickers enabled")
			else:
				self.info_log("Tickers disabled")
			if self.joined:
				for room in self.joined:
					msg = ("--- Connected ---")
					self.say("Status", room, '!!!!', msg)
			
		else:
			self.info_log("not connected to soulseek")

			self.onlinestatuslog="\nOffline"
			self.onlinestatus.addstr(self.onlinestatuslog)
			self.onlinestatus.refresh()

			if self.joined:
				for room in self.joined:
					msg = ("--- Disconnected from the Museek Daemon ---")
					self.say("Status", room, '!!!!', msg)
	
	def cb_room_state(self, roomlist, joined, tickers):
		for room, number in roomlist.items():
			self.all_roomlist[room] = number
			
		for room in joined:

			if room not in self.roomlogs:
				self.roomlogs[room] = []
				self.statuslogs[room] = []
			self.rooms[room] = joined[room]
			roomlist = []

			alpha_list  = SortedDict()
			
			for users in joined[room]:
				roomlist.append(users)
			self.master_roomlist[room] = roomlist

			# tickers == (rooms, [(user1: message1), (user2: message2),] )
			# a string and then a dictionary

			for rooms, ticks in tickers.items():
				if rooms == room:
					self.master_ticklist[room] = ticks

			for rooms, ticks in alpha_list.items():
				if rooms == room:
					self.master_ticklist[room] = alpha_list[room]
					
			#SMALL ROOM USER PRINTOUT
			if len(joined[room]) <= 30:
				self.show_nick_list(room)

				if mucous_config["tickers"]["tickers_enabled"] == 'yes':
					for rooms, ticks in self.master_ticklist.items():
						if rooms == room:
							self.info_log("Tickers in room: "+str(rooms))
							ttickers =[]
							ttickers = ticks.keys()
							ttickers.sort()
							for names in ttickers:
								self.info_log(" ["+str(names)+'] '+str(ticks[names]))
							self.info_log("")
							self.textwin.refresh()
				
		self.joined = self.rooms.keys()
		if self.joined:
			if mucous_config["rooms"]["default_room"] != None:
				if mucous_config["rooms"]["default_room"] in self.joined:
					self.current_room = mucous_config["rooms"]["default_room"]
					self.set_room(mucous_config["rooms"]["default_room"])
				else:
					self.send(messages.JoinRoom(mucous_config["rooms"]["default_room"]))
					self.set_room(self.joined[0])

			else:
				self.current_room = self.joined[0]
				self.set_room(self.joined[0])

		for rooms, tickers in mucous_config["tickers"]["rooms"].items():
			if rooms in self.joined:
				if self.username not in self.master_ticklist[rooms].keys():
					self.send(messages.RoomTickerSet(rooms, tickers))
				elif self.master_ticklist[rooms][self.username] != tickers:
					self.send(messages.RoomTickerSet(rooms, tickers))
			
	def cb_room_list(self, roomlist):
		for name in  roomlist:
			alpha_list[name] = roomlist[name]
		
		collapsed_roomlist = {}
		self.all_roomlist = {}
		
		if self.size == None:
			if len(roomlist) > 100:
				self.size = 50
			else:
				self.size = 1
				
		for x, y in alpha_list.items():
			if y >= self.size:
				collapsed_roomlist[x] = y
			self.all_roomlist[x] = y
		
			
		if self.requested_room_list == True:
			roomstring = []
			for x, y in collapsed_roomlist.items():
				roomstring.append(x + ' ['+str(y)+'],')
			self.info_log("Rooms: " +(string.join(map(str, roomstring))[:-1]))
			self.info_log("Rooms with at least %s user(s): %s" % (self.size, len(collapsed_roomlist.keys() ) ))
			self.info_log("Total Number of rooms: %s" % len(roomlist))
			self.requested_room_list = False
			
	def display_room_list(self):
		
		if self.size == None:
			if len(self.all_roomlist) > 100:
				self.size = 50
			else:
				self.size = 1
				
		collapsed_roomlist = {}
		for x, y in self.all_roomlist.items():
			if y >= self.size:
				collapsed_roomlist[x] = y
			
		roomstring = []
		for x, y in collapsed_roomlist.items():
			roomstring.append(x + ' ['+str(y)+'],')
		self.info_log("Rooms: " +(string.join(map(str, roomstring))[:-1]))
		self.info_log("Rooms with at least %s user(s): %s" % (self.size, len(collapsed_roomlist.keys() ) ))
		self.info_log("Total Number of rooms: %s" % len(self.all_roomlist.keys()))
		self.requested_room_refresh = False
			
	def cb_room_said(self, room, user, text):

		if text[:4] == "/me ":
			self.say("Me", room, user, text[4:])
		else:
			if self.username in text:
				self.say("Mentioned", room, user, text)
				if self.display_which_text != "chat":
					self.alert_status("Nick Mention")

			else:
				self.say("Normal", room, user, text)
				if self.display_which_text != "chat":
					self.alert_status("New Chat")
				elif self.display_which_text == "chat" and self.current_room != room:
					self.alert_status(room[:14])
		if self.logging == True:
			message = "%s %s" % (user, text)
			self.log_to_file("rooms", time.strftime("%d %b %Y %H:%M:%S"), room, message )


	
	def cb_room_joined(self, room, users):

		if room not in self.roomlogs:
			self.roomlogs[room] = []
			self.statuslogs[room] = []

		self.rooms[room] = users
		self.joined.append(room)
		#if len(self.joined[room]) <= 30:
		self.show_nick_list(room)
		#self.say("Status", room, '!!!! ', msg)

		# send list of users for rooms smaller than 30 users
		
		self.show_nick_list(room)
		
		if self.display_which_text == "chat":
			self.set_room(room)
		
		# Send Default ticker to all new rooms
		if mucous_config["tickers"]["default_ticker"] != None:
			self.send(messages.RoomTickerSet(room, mucous_config["tickers"]["default_ticker"]))
		
	
	def cb_room_left(self, room):
		
		del self.rooms[room]
		if room == self.current_room:
			ix = self.joined.index(room)
			if ix > 0:
				ix -= 1
			self.set_room(self.joined[ix])
			self.say("Status", self.joined[ix], '!!!!', "Left room %s" % room)
		self.joined.remove(room)
		if not self.joined:
			self.set_room(None)
			
	
	def cb_room_user_joined(self, room, user, data):
		did = "join"
		what = data
		self.log_window(user, room, did, what)
		self.rooms[room][user] = data
		if self.display_which_text == "chat":
			if self.current_room == room:
				self.roomstatusbox()
				for lines in self.roomlogs[self.current_room]:
					if lines[2] == user:
						self.set_room(self.current_room)
						break

		
	
	def cb_room_user_left(self, room, user):
		did = "left"
		what = None
		self.log_window(user, room, did, what)
		del self.rooms[room][user]
		if self.display_which_text == "chat":
			if self.current_room == room:
				self.roomstatusbox()
				for lines in self.roomlogs[self.current_room]:
					if lines[2] == user:
						self.set_room(self.current_room)
						break

	
	def cb_peer_status(self, user, status):
		if status == 1:
			what = "away"
		elif status == 2:
			what = "online"
		elif status == 0:
			what = "offline"
		room = None
		did = "change"
		self.log_window(user, room, did, what)
		
	def cb_user_info(self, user, info, picture, uploads, queue, slotsfree):
		if user == self.info_requested:
			self.info_requested = None
			e = info.split('\n')
			for i in e:
				self.info_log(i)
			self.info_log("\nQueue: %s \tUploads: %s \tFree Slots: %s"  % ( queue, uploads, slotsfree) )
			if picture != '':
				r = file(str(user)+".image", 'w')
				print >> r, str(picture)
				r.close()
				self.info_log( "Saved UserImage as: "+ str(user)+".image")
		if self.display_which_text != "info":
			self.alert_status("New Userinfo")
			
	def cb_peer_address(self, user, ip, port):
		if user == self.ip_requested:
			self.ip_requested = None
			self.info_log("%s's IP: %s Port: %s"  % (user, str(ip), str(port)) )
			if self.display_which_text != "info":
				self.alert_status("New IP")
			
	def cb_peer_stats(self, user, avgspeed, numdownloads, numfiles, numdirs):
		if user == self.stat_requested:
			x = "Peer Stats for: %s \nSpeed: %s \tDownloads: %s \nFiles: %s \tDirectories: %s" % (user,  avgspeed, numdownloads, numfiles, numdirs)
			self.info_log(x)
			self.info_log("")
			self.stat_requested = None
			if self.display_which_text != "info":
				self.alert_status("New Stats")
		if user == self.username:
			self.stats = user,  avgspeed, numdownloads, numfiles, numdirs
			if self.display_which_text == "setup":
				self.setup_mode()
	
				
	def send_private_message(self, user, message):
		if self.logging == True:
			self.log_to_file("private", time.strftime("%d %b %Y %H:%M:%S"), user, "You said: " +message )
		pmtype = "outgoing"
		if user not in self.pm_users:
			self.pm_users.append(self.pm_user)
		self.private_log(pmtype, user, message)
		if self.alertwinlog == "\nNew PM":
			self.alert_status("\n ")
	
	def cb_private_message(self, timestamp, user, message):
		if self.logging == True:
			self.log_to_file("private", time.strftime("%d %b %Y %H:%M:%S"), user, user+" said: "+ message )
		
		if self.pm_user == None:
			self.pm_user = user
			
		if user not in self.pm_users:
			self.pm_users.append(user)
			
		pmtype = "incoming"
		self.start_pm(user)

		self.private_log(pmtype, user, message)
		
		if self.display_which_text != "private":
			self.alert_status("New PM")
		else:
			self.set_edit_title("Send message to: " + self.pm_user)
		
	def cb_server_status_set(self, status):
		self.status = status
		if status:
			stat = "Away"
		else:
			stat = "Online"
		self.onlinestatuslog="\n"+stat
		self.onlinestatus.addstr(self.onlinestatuslog)
		self.onlinestatus.refresh()
		
			
	def cb_room_ticker_set(self, room, user, message):
		what = message
		did = "ticker"
		self.log_window(user, room, did, what)
		for rooms, tickle in self.master_ticklist.items()[:]:
			if room == rooms:
				tickle[user] = message
				
	def cb_search_ticket(self, query, ticket):
		self.s_query[ticket] = query
		
	def cb_search_results(self, ticket, user, free, speed, queue, results):
		# search results

		if self.search_visible == 1:
			self.search_log("---------\nSearch: " +str(self.s_query[ticket]) + " Results from: User: "+ user )

		for result in results:
			result_list = []
			# Create Result List for future use 
			# clear it next interation

			result_list = ticket, user, free, speed, queue, result[0], result[1], result[2], result[3]
			
			# Count Search Result
			self.search_number += 1
			# Send Num of Results to Search Window
			self.search_status(self.search_number)
			# Activate Number for Result
			self.search_results[self.search_number] = result_list
			
			# Display Search Result
			if self.search_visible == 1:
				path = result[0]
				size = str(result[1]/1024)+'KB'
				ftype = result[2]
	
				if ftype in ('mp3', 'ogg'):
					if result[3] != []:
						bitrate = result[3][0]
						length = result[3][1]
						minutes = int(length)/60
						seconds = str(length - (60 * minutes))
						
						if len(seconds) < 2:
							seconds = '0' + seconds
					else:
						bitrate = 'None'
						minutes = '00'
						seconds = '00'
						length = 0
				else:
					bitrate = 'None'
					minutes = '00'
					seconds = '00'
					length = 0
				
				self.search_log("Num: [" +str(self.search_number)+"] Path: "+ path+ "\nSize: "+str(size)+ " Type: "+ ftype + " Bitrate: "+ str(bitrate) + " Length: " + str(minutes)+":"+seconds)
				
	def cb_user_shares(self, user, shares):
		if self.browse_requested == user:
			self.browse_requested = None
			self.browse_log("Browsing: " + user)
			self.browse_results = {}
			self.browse_number = 0
			for dirs, files in shares.items():
				result_list = []
				
				if files != {}:
					self.browse_log("------\nDIR: " + dirs)
				for file, stats in files.items():
					self.browse_number = self.browse_number +1
	
					size= str(stats[0]/1024)+"KB"
					ftype =stats[1]
					if ftype == '':
						ftype = "None"
						length = "00:00"
						bitrate = 'None'
					else:
						bitrate =str(stats[2][0])
						if bitrate == '':
							bitrate = 'None'	
						length =str(stats[2][1])
						if length != '' and length != None:
							minutes = int(length)/60
							seconds = str( int(length) - (60 * minutes))
							if len(seconds) < 2:
								seconds = '0' + seconds
							length = str(minutes)+":"+str(seconds)
						else:
							length = "00:00"
	
					
					filename = dirs + "\\" + file
					result_list = user, filename
					# Activate Number for Result
					self.browse_results[self.browse_number] = result_list
					
					self.browse_log('['+str(self.browse_number)+'] ' + " Size: " + str(size) + " Type: " + ftype + " Length: " + length + " Bitrate: " + bitrate + "\nFile: " +  file)
			self.browse_log("Finished browsing: " + user)
		
	def cb_transfer_state(self, downloads, uploads):
		for users in uploads:
			upload = int(users[0])
			user_path = (users[1], users[2])
			user = users[1]
			path = users[2]
			status = int(users[3])
			error = users[4] 
			filepos = int(users[5])
			filesize = int(users[6])
			rate = int(users[7])
			self.transfers["uploads"][user_path] =   [upload, user, path, status, error, filepos, filesize, rate]

		for users in downloads:
			upload = int(users[0])
			user_path = (users[1], users[2])
			user = users[1]
			path = users[2]
			status = int(users[3])
			error = users[4] 
			filepos = int(users[5])
			filesize = int(users[6])
			rate = int(users[7])
			self.transfers["downloads"][user_path] =   [upload, user, path, status, error, filepos, filesize, rate]
			
		self.upload_manager()
		self.download_manager()
			
	def cb_transfer_update(self, downloads, uploads):
		upload_update = 0
		for users in uploads:
			upload = int(users[0])
			user_path = (users[1], users[2])

			user = users[1]
			path = users[2]
			status = int(users[3])
			error = users[4] 
			filepos = int(users[5])
			filesize = int(users[6])
			rate = int(users[7])
			self.transfers["uploads"][user_path] =  [upload, user, path, status, error, filepos, filesize, rate]
			upload_update = 1
			
		download_update = 0
		for users in downloads:
			upload = int(users[0])
			user_path = (users[1], users[2])
			user = users[1]
			path = users[2]
			status = int(users[3])
			error = users[4] 
			filepos = int(users[5])
			filesize = int(users[6])
			rate = int(users[7])
			self.transfers["downloads"][user_path] =   [upload, user, path, status, error, filepos, filesize, rate]
			download_update = 1
			
		if upload_update == 1:
			self.upload_manager()
		if download_update == 1:
			self.download_manager()
	def cb_transfer_remove(self, transfer):
		
		user_path = transfer[1], transfer[2]
		if transfer[0]:
			del self.transfers["uploads"][user_path]
			self.upload_manager()
					
		else:
			del self.transfers["downloads"][user_path]
			self.download_manager()

	#Add new/replace old keys to self.config
	def cb_config_set(self, domain, key, value):

		if key in self.config[domain].keys():
			self.info_log("Modified <"+key+"> in <" +domain+"> to <"+value + ">")
			self.config[domain][key] = value
		else:
			if value == '':
				self.info_log("Added <"+key+"> to <" +domain+">")
			else:
				self.info_log("Added <"+key+"> to <" +domain+"> and set to <"+value+">")
			self.config[domain][key] = value
		self.display_config_update(domain)
		
	#Delete keys from self.config
	def cb_config_remove(self, domain, key):

		if key in self.config[domain].keys():
			self.info_log("Removed <"+key+"> from <" +domain+">")
			del self.config[domain][key]
		self.display_config_update(domain)
	
	#Copy config to self.config at connection
	def cb_config_state(self, config):
		self.config = config.copy()
		
	# -- ^ Museek Messages ^
	def display_config_update(self, domain):
		if domain in ("buddies", "banned", "ignored"):
			if self.display_which_text == "buddies":
				self.buddy_mode()
			elif self.display_which_text == "banned":
				self.ban_mode()
			elif self.display_which_text == "ignored":
				self.ignore_mode()
		elif domain == "transfers" and self.display_which_text == "setup":
			self.setup_mode()

	def upload_manager(self):
		
		if self.display_which_text == "transfer":

			if self.transfer_display_mode == 'active':
				status_list = (1, 2, 3, 4, 5, 6, 8, 9,)
			elif self.transfer_display_mode == 'all':
				status_list = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)
			elif self.transfer_display_mode == 'finished':
				status_list = (0, 99999)
			elif self.transfer_display_mode == 'queued':
				status_list = (7, 99999)
			elif self.transfer_display_mode == 'failed':
				status_list = (  10, 11, 12, 13)
			uploadlist = []
			a = 0
			self.up_transfer_numbers = {}
			for users, vals in self.transfers["uploads"].items():

				upload = vals[0]
				user = vals[1]
				path = vals[2]
				status = vals[3]
				error = vals[4]
				filepos = vals[5]
				filesize = vals[6]
				rate = vals[7]
				a += 1
				username = {}
				username[user] = path
				self.up_transfer_numbers[a] = username
				if status in status_list:
					if filesize != 0:
						percent = str(100 * filepos / filesize)
						if len(percent) < 2:
							percent = '  ' + percent
						if len(percent) < 3:
							percent = ' ' + percent
						if filesize >= 1048576 and filesize <= 1073741824:
							filefrmt = str(filesize/1024/1024) +" MB"
						elif filesize < 1048576 and filesize >= 1024:
							filefrmt = str(filesize/1024) +" KB"
						elif filesize < 1024 and filesize > 0:
							filefrmt = str(filesize) +" B"
						if len(filefrmt) < 5:
							filefrmt = ' '+filefrmt
						if len(filefrmt) < 6:
							filefrmt = ' '+filefrmt
					else: 
						percent = '  0'
						filefrmt = '0 Bits'

					if len(user) <2 :
						spacer = "\t\t"
					else:
						spacer = "\t"
					if len(states[status]) <8:
						spacer2 = "\t\t"
					else:
						spacer2 = "\t"
					#self.upwin.addstr
					
					ae = str(a)
					while len(ae) < 4:
						ae = ' '+ae
					while len(user[:10]) < 10:
						user += " "
					mo = {}
					ea = "\n[%s|%s%%|%s] [%s]%s%s%s%s" % (str(ae), percent , filefrmt , user[:10], spacer, states[status], spacer2, path[-self.w+51:])
					mo = ea, status
					uploadlist.append(mo)
			self.window_height =self.h/2-4
			if self.transferscroll == "upload":
				if self.scrollup > 0:
					self.scrollup = 0
				if self.scrollup > len(uploadlist):
					self.scrollup = len(uploadlist)
					
				end = len(uploadlist) + self.scrollup
				
				if end < self.window_height -1:
					end == self.window_height -1
				if end < 0:
					end = 0
					
				start = end - self.window_height +1
				
				if start < 0:
					start = 0
					end = self.window_height -1
					self.scrollup = -(len(uploadlist) - end)
				
			else:
				end = len(uploadlist)
				start = end - self.window_height +1
				if start < 0: start = 0
				
			self.upwin.clear()
			self.upwin.addstr("[Numb|Perc| Size ] [Username]\t[Status]\t[Path]", green)
			if uploadlist != []:
				for transfers in uploadlist[start:end]:
					if transfers[1] == 1:
						attr = green
					elif transfers[1] == 0:
						attr = magenta
					elif transfers[1] in (10, 11, 12, 13, 14):
						attr = red
					else:
						attr = curses.color_pair(0)
					self.upwin.addstr(transfers[0], attr)
			else:
				self.upwin.addstr("\nNo transfers in this category, hit INSERT to switch to another.")
			self.upwin.refresh()
		self.upload_status(str(len(self.transfers["uploads"].keys())))

	def download_manager(self):
		if self.display_which_text == "transfer":

			if self.transfer_display_mode == 'active':
				status_list = (1, 2, 3, 4, 5, 6, 8, 9,)
			elif self.transfer_display_mode == 'all':
				status_list = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,  14)
			elif self.transfer_display_mode == 'finished':
				status_list = (0, 99999)
			elif self.transfer_display_mode == 'queued':
				status_list = (7, 99999)
			elif self.transfer_display_mode == 'failed':
				status_list = (  10, 11, 12, 13)
			downloadlist = []
			a = 0
			self.down_transfer_numbers = {}
			
			for users, vals in self.transfers["downloads"].items():
				download = vals[0]
				user = vals[1]
				path = vals[2]
				status = vals[3]
				error = vals[4]
				filepos = vals[5]
				filesize = vals[6]
				rate = vals[7]
				a += 1
				username = {}
				username[user] = path
				self.down_transfer_numbers[a] = username

				if status in status_list:

					if filesize != 0:
						percent = str(100 * filepos / filesize)
						if len(percent) < 2:
							percent = '  ' + percent
						if len(percent) < 3:
							percent = ' ' + percent
						if filesize >= 1048576 and filesize <= 1073741824:
							filefrmt = str(filesize/1024/1024) +" MB"
						elif filesize < 1048576 and filesize >= 1024:
							filefrmt = str(filesize/1024) +" KB"
						elif filesize < 1024 and filesize > 0:
							filefrmt = str(filesize) +" B"
						if len(filefrmt) < 5:
							filefrmt = ' '+filefrmt
						if len(filefrmt) < 6:
							filefrmt = ' '+filefrmt
					else: 
						percent = '  0'
						filefrmt = '0 Bits'

					if len(user) <2 :
						spacer = "\t\t"
					else:
						spacer = "\t"
					if len(states[status]) <8:
						spacer2 = "\t\t"
					else:
						spacer2 = "\t"
					#self.downwin.addstr

					ae = str(a)
					while len(ae) < 4:
						ae = ' '+ae
					mo = {}
					while len(user[:10]) < 10:
						user += " "
					ea = "\n[%s|%s%%|%s] [%s]%s%s%s%s" % (str(ae), percent , filefrmt , user[:10], spacer, states[status], spacer2, path[-self.w+51:])
					mo = ea, status
					downloadlist.append(mo)
			self.window_height =self.downtext
			if self.transferscroll == "download":
				if self.scrollup > 0:
					self.scrollup = 0
				if self.scrollup > len(downloadlist):
					self.scrollup = len(downloadlist)
					
				end = len(downloadlist) + self.scrollup
				
				if end < self.window_height -1:
					end == self.window_height -1
				if end < 0:
					end = 0
					
				start = end - self.window_height +1
				
				if start < 0:
					start = 0
					end = self.window_height -1
					self.scrollup = -(len(downloadlist) - end)
				
			else:
				
				end = len(downloadlist)
				start = end - self.window_height +1
				if start < 0: start = 0
				
			self.downwin.clear()
			self.downwin.addstr("[Numb|Perc| Size ] [Username]\t[Status]\t[Path]", green)
			if downloadlist != []:
				for transfers in downloadlist[start:end]:
					if transfers[1] == 1:
						attr = green
					elif transfers[1] == 0:
						attr = magenta
					elif transfers[1] in (10, 11, 12, 13, 14):
						attr = red
					else:
						attr = curses.color_pair(0)
					self.downwin.addstr(transfers[0], attr)
			else:
				self.downwin.addstr("\nNo transfers in this category, hit INSERT to switch to another.")
			self.downwin.refresh()
		self.download_status(str(len(self.transfers["downloads"].keys())))		
		
		# Change Room Title in edit window
	def show_nick_list(self, room):
		self.colorednicks = {}
		
		if self.rooms[room] != None:
			
			self.colorednicks[room] = []
			for username in self.rooms[room].keys():
				
				if username == self.username:
					self.colorednicks[room].append([username, "Me"])
				elif username not in self.rooms[room].keys():
					self.colorednicks[room].append([username, "Left"])
				elif username in self.config["banned"].keys():
					self.colorednicks[room].append([username, "Banned"])
				elif username in self.config["buddies"].keys():
					self.colorednicks[room].append([username, "Buddies"])
				else:
					self.colorednicks[room].append([username, "Normal"])
				if username is not self.rooms[room].keys()[-1]:
					self.colorednicks[room].append([", ", "NotLast"])
			mtype = "List"
			user = "!!!!"
			msg = self.colorednicks[room]
			self.say("List", room, '!!!!', msg)
			

	# Change Room Title
	def set_room(self, r):
		self.current_room = r
		self.current = r
		
		self.display_status_log()
		if self.display_which_text == "chat":
			self.inputwin.clear()
			self.roomstatusbox()
			# Change title in edit window
			self.set_edit_title(self.current_room)
			# Display Next-room hotspot's text
			self.inputwin.addstr(0, self.w-9, "< ")
			self.inputwin.addstr(0, self.w-7, "Next ", cyan | curses.A_BOLD)
			self.inputwin.addstr(0, self.w-2, ">")
			# Clean screen
			self.inputwin.refresh()
			self.editwin.refresh()
			self.textwin.clear()
			
			# Display chat log
			if self.roomlogs[self.current_room] != None:
				for lines in self.roomlogs[self.current_room]:
					self.display_room_text(self.current_room, lines)
			
			# Clear Alert log
			if "\n%s" % self.current_room == self.alertwinlog:
				self.alert_status("\n")
			
			# Count lines in the log
			self.scrollup_static = len(self.roomlogs[self.current_room])
			# Reset line number to zero
			self.scrollup = 0 
			self.chatwin.attron(green)
			self.chatwin.border()
			self.chatwin.addstr(0, 3, "< Chat Rooms >",  green | curses.A_BOLD)
			self.chatwin.addstr(1, self.w-1, "^",  green | curses.A_BOLD)
			self.chatwin.addstr(self.h-13, self.w-1, "v",  green | curses.A_BOLD)
			self.chatwin.addstr(self.h-12, self.w-18, "< "+str(abs(self.scrollup))+"/"+str(self.scrollup_static)+" >", green | curses.A_BOLD)
			
			self.chatwin.refresh()
		self.textwin.refresh()
		
		
	def set_edit_title(self, r):
		self.current = r
		self.inputwin.border()
		if self.current:
			self.inputwin.addstr(0, 2, "< ")
			self.inputwin.addstr(0, 4, self.current, cyan | curses.A_BOLD)
			self.inputwin.addstr(0, 4+len(self.current), " >")
		if self.display_which_text != "chat":
			self.inputwin.refresh()
			self.editwin.refresh()		
		
	# Rebuild Buddylist from self.config
 	def buddylist(self):
		if "buddies" in self.config.keys():
			self.buddylog = []
			alpha_list = SortedDict()
			for keyname, keyvalue in self.config["buddies"].items():
				alpha_list[keyname] = keyvalue
			self.chatwin.addstr(self.h-6, self.w-18, "> "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
			self.chatwin.refresh()
			for keyname, keyvalue in alpha_list.items():
				banned = None
				ignored = None
				tabbedname = keyname
				while len(tabbedname) < 25:
					tabbedname += " "
				tabs = "\t"
				for bdomain, bkey in self.config.items()[:]:
					if bdomain == "banned":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								banned = 1
					elif bdomain == "ignored":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								ignored = 1
				if banned != None:
					self.buddy_log("Banned",  keyname, keyvalue)
				elif ignored != None:
					self.buddy_log("Ignored",  keyname, keyvalue)
				else:
					self.buddy_log("Normal",  keyname, keyvalue)

	# Rebuild Banlist from self.config
 	def banlist(self):
		if "banned" in self.config.keys():
			self.banlog = []
			alpha_list = SortedDict()
			for keyname, keyvalue in self.config["banned"].items():
				alpha_list[keyname] = keyvalue
			self.chatwin.addstr(self.h-6, self.w-18, "< "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
			self.chatwin.refresh()
			for keyname, keyvalue in alpha_list.items():
				buddies = None
				ignored = None
				tabbedname = keyname
				while len(tabbedname) < 25:
					tabbedname += " "
				tabs = "\t"
				for bdomain, bkey in self.config.items()[:]:
					if bdomain == "buddies":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								buddies = 1
					elif bdomain == "ignored":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								ignored = 1
				if buddies != None:
					self.ban_log("Buddies", keyname, keyvalue)
				elif ignored != None:
					self.ban_log("Ignored",  keyname, keyvalue)
				else:
					self.ban_log("Normal",  keyname, keyvalue)
					
	def completion_list(self):
		usercompletionlist = {}
		
		for users in self.config["buddies"].keys():
			usercompletionlist[users] = 0
			
		for users in self.config["banned"].keys():
			usercompletionlist[users] = 0
			
		for users in self.config["ignored"].keys():
			usercompletionlist[users] = 0
			
		for room in self.rooms.keys():
			for users in  self.rooms[room].keys():
				usercompletionlist[users] = 0
				
		for userpath, values in self.transfers["uploads"].items():
			usercompletionlist[values[1]] = 0
			
		for userpath, values in self.transfers["downloads"].items():
			usercompletionlist[values[1]] = 0
			
		for values in self.commandlist:
			usercompletionlist[values] = 0
			
		self.tab_complete_list = usercompletionlist.keys()
		self.tab_complete_list.sort()
		
	# Rebuild Ignorelist from self.config
	def ignorelist(self):
		if "ignored" in self.config.keys():
			self.ignorelog = []
			alpha_list = SortedDict()
			for keyname, keyvalue in self.config["ignored"].items():
				alpha_list[keyname] = keyvalue
			self.chatwin.addstr(self.h-6, self.w-18, "< "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
			self.chatwin.refresh()
			for keyname, keyvalue in alpha_list.items():
				banned = None
				buddies = None
				tabbedname = keyname
				while len(tabbedname) < 25:
					tabbedname += " "
				tabs = "\t"
				for bdomain, bkey in self.config.items()[:]:
					if bdomain == "buddies":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								buddies = 1
					elif bdomain == "banned":
						for bkeyname, bkeyvalue in bkey.items():
							if keyname == bkeyname:
								banned = 1	
				if buddies != None:
					self.ignore_log("Buddies",  keyname, keyvalue)
				elif banned != None:
					self.ignore_log("Banned",  keyname, keyvalue)
				else:
					self.ignore_log("Normal",  keyname, keyvalue)
	def scrolltext(self):
		key = self.key
		color_added = None
		if self.display_which_text not in ("transfer", "setup"):
			self.textwin.clear()
			self.textwin.refresh()
		
			if self.display_which_text == "chat":
				self.window_height = -(self.h-13)
				self.textwin.scrollok(0)
			else:
				self.window_height = -(self.h-7)
				self.textwin.scrollok(1)
				
			if self.display_which_text == "chat":
				selected_log = self.roomlogs[self.current_room]
			elif self.display_which_text == "search":
				selected_log = self.searchlog
			elif self.display_which_text == "info":
				selected_log =  self.infolog
			elif self.display_which_text == "private":
				if self.pm_user != None:
					selected_log =  self.privatelog[self.pm_user]
				else:
					selected_log = self.pminfolog
			elif self.display_which_text == "browse":
				selected_log = self.browselog
			elif self.display_which_text == "buddies":
				selected_log = self.buddylog
			elif self.display_which_text == "banned":
				selected_log = self.banlog
			elif self.display_which_text == "ignored":
				selected_log = self.ignorelog
				
			if key == "KEY_UP":	
				# SCROLLING UP
				# Redisplay chat log with one less line every time the Up key is pressed
				self.scrollup = self.scrollup -1
				
			elif key == "KEY_DOWN":
				#SCROLLING DOWN
				self.textwin.scrollok(1)
				self.scrollup = self.scrollup +1
			elif key == "KEY_PPAGE":
				self.scrollup = self.scrollup -10
			elif key == "KEY_NPAGE":
				self.textwin.scrollok(1)
				self.scrollup = self.scrollup +10
			log_scroll = []
			if selected_log != None:
				for line in selected_log:
					log_scroll.append(line)
	
				if self.scrollup > 0:
					self.scrollup = 0
				elif self.scrollup < -len(log_scroll):
					self.scrollup = -len(log_scroll)  - self.window_height 
				elif self.scrollup < -len(log_scroll)-self.window_height:
					self.scrollup = -len(log_scroll)-self.window_height
				elif abs(self.scrollup) >= len(log_scroll):
					self.scrollup = -len(log_scroll)  - self.window_height 
					
				end = len(log_scroll) +self.scrollup
				start = end +self.window_height
				if start <= 0:
					start = 0
				if self.display_which_text == "chat":
					#start -= 1
					self.chatwin.attron(green)
					self.chatwin.border()
					self.chatwin.addstr(1, self.w-1, "^",  green | curses.A_BOLD)
					self.chatwin.addstr(self.h-13, self.w-1, "v",  green | curses.A_BOLD)
					self.chatwin.addstr(self.h-12, self.w-18, "< "+str(abs(self.scrollup))+"/"+str(len(log_scroll))+" >", green| curses.A_BOLD)
					self.chatwin.addstr(0, 3, "< Chat Rooms >",  green | curses.A_BOLD)
					self.chatwin.attroff(green)
					self.chatwin.refresh()
					for lines in log_scroll[start:end]:
						self.display_room_text(self.current_room,lines)
					self.textwin.refresh()
		
				elif self.display_which_text in ("buddies", "banned", "ignored"):
					for lines in log_scroll[start:end]:
						self.display_list_text(lines)
					self.textwin.refresh()
				else:
					for lines in log_scroll[start:end]:
						self.textwin.addstr(lines)
					self.textwin.refresh()
				
		if self.display_which_text == "transfer":
			
			if self.transferscroll == "upload":
				scrolldiff = self.uptext
			elif self.transferscroll == "download":
				scrolldiff = self.downtext
			if key == "KEY_UP":	
				# SCROLLING UP
				# Redisplay chat log with one less line every time
				# the Up key is pressed
				self.scrollup = self.scrollup -1
				
			elif key == "KEY_DOWN":
				#SCROLLING DOWN
				self.scrollup = self.scrollup +1
			elif key == "KEY_PPAGE":
				# upload or download window height - one line for heading
				self.scrollup = self.scrollup -scrolldiff +1
			elif key == "KEY_NPAGE":
				self.scrollup = self.scrollup + scrolldiff -1
				
			if self.scrollup > 0:
				self.scrollup = 0
			if self.transferscroll == "upload":
				self.upload_manager()
			elif self.transferscroll == "download":
				self.download_manager()
		self.key = None	
	# ---v  KEYS v
	
	# Tab completion
	def tabbing(self, line, word, firsttab, listline):
		self.firsttab = firsttab
		self.listline = listline
		if self.display_which_text in ("chat", "buddies", "banned", "ignored", "info", "private", "browse", "transfer", "setup", "search"):
			
			if self.firsttab ==0:
 				self.completion_list()
				self.keepit=[]
				for words in self.tab_complete_list:
					if word[0:1] == '/':
						if words.startswith(word[0:2]):
							self.keepit.append(words)
					else:
						if words.startswith(word[0:1]):
							self.keepit.append(words)
				self.keepit.sort()

			self.firsttab +=1
			if self.listline == []:
				self.listline = line.split(" ")
			split_line = self.listline
			
			for words in self.keepit:
				if words.startswith(split_line[-1][0:1]) and split_line[-1] != ' ' and split_line[-1] != '':
					self.listline = []
					r = len(split_line)
					if r >1:
						
						for s in split_line:
							if s is not split_line[-1]:
								self.listline.append(s)
							elif s is split_line[-1]:
								if s != words:
									self.listline.append(words)
									break
								elif s == words:
									if self.firsttab ==0:
										if words.startswith(split_line[-1]):
											self.listline.append(self.keepit[0])
											break
									else:
										self.keepit.append(self.keepit[0])
										del self.keepit[0]
										self.listline.append(self.keepit[0])
										break
						break
					else:
						s =  split_line[0]
						if s != words:
							if words.startswith(s):
								self.listline.append(words)
								break
						elif s == words:
							if self.firsttab ==0:
								if words.startswith(split_line[-1]):
									self.listline.append(self.keepit[0])
									break
							else:
								
								self.keepit.append(self.keepit[0])
								del self.keepit[0]
								self.listline.append(self.keepit[0])
								break


			return self.listline, self.firsttab

	def escaped(self, key, line):
		if key == "KEY_RESIZE":
			stdscr.keypad(1)
			self.build(stdscr, line)
		if key in ("KEY_UP",  "KEY_DOWN", "KEY_PPAGE", "KEY_NPAGE"):
			#if self.display_which_text not in ("setup", "transfer"):
			self.key = key
			self.scrolltext()

		elif key == "KEY_F(1)":
			self.chat_mode()
		elif key == "KEY_F(2)":
			self.private_mode()
		elif key == "KEY_F(3)":
			self.transfer_mode()
		elif key == "KEY_F(4)":
			self.search_mode()
		elif key == "KEY_F(5)":
			self.info_mode()
		elif key == "KEY_F(6)":
			self.browse_mode()
		elif key == "KEY_F(7)":
			self.buddy_mode()
		elif key == "KEY_F(8)":
			self.ban_mode()
		elif key == "KEY_F(9)":
			self.ignore_mode()
		elif key == "KEY_F(10)":
			self.setup_mode()
			
		elif key in ("KEY_HOME", "KEY_END"):
			if self.display_which_text == "transfer":
				# Tab to switch between upload and download scrolling
				if self.transferscroll == "upload":
					self.transferscroll="download"
					self.scrollup =0
				elif self.transferscroll=="download":
					self.transferscroll="upload"
					self.scrollup =0
				self.transfer_mode()
				
		elif key == "KEY_MOUSE":
			(id,x,y,z,event)=curses.getmouse()
			#self.info_log(str(id)+" "+str(x)+" "+str(y)+" "+str(z)+" "+str(event))
			if y >= self.h-1:
				# clickable mode switching
				if x >= 0 and x < 7:
					self.chat_mode()
				elif x >= 7 and x < 16:
					self.private_mode()
				elif x >= 16 and x < 27:
					self.transfer_mode()
				elif x >= 27 and x < 34:
					self.search_mode()
				elif x >= 34 and x < 40:
					self.info_mode()
				elif x >= 40 and x < 48:
					self.browse_mode()
				elif x >= 48 and x < 55:
					self.buddy_mode()
				elif x >= 55 and x < 60:
					self.ban_mode()
				elif x >= 60 and x < 68:
					self.ignore_mode()
				elif x >= 68 and x < 75:
					self.setup_mode()
			
			if self.display_which_text == "chat":
				# Clickable room switch
				if y == self.h-3 or y == self.h-4:
					if x >=self.w-9 and x < self.w-1:
						if not self.current_room in self.joined:
							ix = 0
						else:
							ix = self.joined.index(self.current_room)
							ix += 1
							if ix < 0:
								ix = -1
							elif ix >= len(self.joined):
								ix = 0
						self.set_room(self.joined[ix])
				elif y in (self.h-6, self.h-7, self.h-8, self.h-9) and x >= self.w-5:
					self.key = "KEY_NPAGE"
					self.scrolltext()
				elif y in (7, 8, 9, 10) and x >= self.w-5:
					self.key = "KEY_PPAGE"
					self.scrolltext()
			if self.display_which_text == "private":
				# Clickable room switch

				if y in (2, 3, 4):
					#for s in self.pm_users[:]:
					if self.pm_user != None:
						if len(self.pm_users) > 1:
							#s = self.pm_user
							self.info_log(self.pm_users.index(self.pm_user))
							s = self.pm_users.index(self.pm_user)
							self.pm_user = self.pm_users[s-1]
							#self.pm_users.remove(self.pm_user)
							#self.pm_users.append(self.pm_user)
							#self.display_which_pm = self.pm_users[0]
							self.start_pm(self.pm_user)
							self.private_mode()
					#break

					
			elif self.display_which_text == "setup":
				if y == 8:
					if x >=1 and x <=15:
						#Buddies-only
						if self.config["transfers"]["only_buddies"] == "true":
							self.send(messages.ConfigSet("transfers", "only_buddies", "false"))
						elif self.config["transfers"]["only_buddies"] == "false":
							self.send(messages.ConfigSet("transfers", "only_buddies", "true"))
					elif x >=17 and x <=31:
						#buddy-privs
						if self.config["transfers"]["privilege_buddies"] == "true":
							self.send(messages.ConfigSet("transfers", "privilege_buddies", "false"))
								
						elif self.config["transfers"]["privilege_buddies"] == "false":
							self.send(messages.ConfigSet("transfers", "privilege_buddies", "true"))
						
				elif y == 11:
					if x >=1 and x <=15:
						# Toggle Autobuddy
						if mucous_config["mucous"]["autobuddy"]  == "yes":
							mucous_config["mucous"]["autobuddy"] = "no"

						elif mucous_config["mucous"]["autobuddy"]  == "no":
							mucous_config["mucous"]["autobuddy"] = "yes"

						self.setup_mode()
					elif x >=17 and x <=31:
						#slots
						self.setup_mode()
			elif self.display_which_text == "search":
				if y ==self.h-4:
					if x >= 10 and x <= 20:
						if self.search_type == "globally":
							self.search_type = "buddies"
						elif self.search_type == "buddies":
							self.search_type = "globally"
						self.search_mode()
			
			elif self.display_which_text == "transfer":
				# Clickable transfer type switcher
				if y ==self.h-5:
					if x >=self.w-18:
						if self.transfer_display_mode == 'active':
							self.transfer_display_mode = 'queued'	
							
						elif self.transfer_display_mode == 'queued':
							self.transfer_display_mode = 'finished'
							
						elif self.transfer_display_mode == 'finished':
							self.transfer_display_mode = 'all'
							
						elif self.transfer_display_mode == 'all':
							self.transfer_display_mode = 'failed'
							
						elif self.transfer_display_mode == 'failed':
							self.transfer_display_mode = 'active'
						self.transfer_mode()
						
		if key in( "KEY_LEFT", chr(91), chr(34), "KEY_RIGHT", chr(93), chr(35), "KEY_IC"):
			if not self.joined:
				return

			if self.display_which_text == "chat":
				# Hotkeys to switch rooms
				if not self.current_room in self.joined:
					if key == "KEY_LEFT" or key == chr(91) or key == chr(34):
						ix = -1
					elif key == "KEY_RIGHT" or key == chr(93) or key == chr(35) or key == "KEY_IC":
						ix = 0

				else:
					ix = self.joined.index(self.current_room)
					if key == "KEY_LEFT" or key == chr(91)  or key == chr(34):
						ix -= 1
					elif key == "KEY_RIGHT" or key == chr(93) or key == chr(35) or key == "KEY_IC":
						ix += 1
					
					if ix < 0:
						ix = -1
					elif ix >= len(self.joined):
						ix = 0
				if ix != None:
					self.set_room(self.joined[ix])
			elif self.display_which_text == "private":
				if self.pm_user != None:
					if len(self.pm_users) > 1:
						#s = self.pm_user
						self.info_log(self.pm_users.index(self.pm_user))
						s = self.pm_users.index(self.pm_user)
						self.pm_user = self.pm_users[s-1]
						#self.pm_users.remove(self.pm_user)
						#self.pm_users.append(self.pm_user)
						#self.display_which_pm = self.pm_users[0]
						self.start_pm(self.pm_user)
						self.private_mode()
			elif self.display_which_text == "transfer":
				# Hotkeys to switch listing transfer types
				if self.transfer_display_mode == 'active':
					self.transfer_display_mode = 'queued'	
					
				elif self.transfer_display_mode == 'queued':
					self.transfer_display_mode = 'finished'
					
				elif self.transfer_display_mode == 'finished':
					self.transfer_display_mode = 'all'
					
				elif self.transfer_display_mode == 'all':
					self.transfer_display_mode = 'failed'
					
				elif self.transfer_display_mode == 'failed':
					self.transfer_display_mode = 'active'
				self.transfer_mode()
	
			elif self.display_which_text == "search":	
				# Hotkeys to switch types of searches
				if self.search_type == "globally":
					self.search_type = "buddies"
				elif self.search_type == "buddies":
					self.search_type = "globally"
				self.search_mode()
			else:
				self.set_edit_title(self.current)

	# ---^  KEYS ^
	def display_status_log(self):
		if self.display_which_text == "chat":
			self.logwin = self.borderlogwin.subwin(4, self.w -17, 2, 16)
			self.logwin.clear()
			self.logwin.scrollok(1)
			self.logwin.idlok(1)
		
			if self.current_room != None:
				if len(self.statuslogs[self.current_room]) != 0:
					for i in range(len(self.statuslogs[self.current_room])):
						self.logwin.addstr(self.statuslogs[self.current_room][i])
				
			self.logwin.refresh()		
	# ---v  MODES v
	def roomstatusbox(self):
		self.roomstatusborderwin = curses.newwin(6, 15, 1, 0)
		self.roomstatusborderwin.border()
		
		if self.current_room != None:
			self.roomstatusborderwin.addstr(0, 1, "<           >")
			self.roomstatusborderwin.addstr(0, 2, "Users: "+str(len(self.rooms[self.current_room].keys())), curses.A_BOLD)
		self.roomstatusborderwin.refresh()
		
		self.roomstatuswin = self.roomstatusborderwin.subwin(4, 13, 2, 1)
		self.roomstatuswin.scrollok(1)
		self.roomstatuswin.idlok(1)
		
		if self.current_room != None:
			self.roomboxlist[self.current_room] = []
			if len( self.rooms[self.current_room].keys() ) <= 100:
				for users in self.rooms[self.current_room].keys():
					self.roomboxlist[self.current_room].append(users)
				if self.roomboxlist[self.current_room] !=[]:
					for users in self.roomboxlist[self.current_room]:
						self.roomstatuswin.addstr('\n'+users[:12])
		self.roomstatuswin.refresh()
		
	def chat_mode(self):
		self.display_which_text = "chat"
		self.hotkeys()
		self.roomstatusbox()
		self.chatwin = curses.newwin(self.h - 10 -1, self.w, 7, 0, )
		self.chatwin.border()
		self.chatwin.refresh()
		
		self.textwin = self.chatwin.subwin(self.h-12 -1,self.w-2,8,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		
		self.scrollup_static = 0
		self.scrollup = 0
		self.textwin.refresh()
		
		if self.alertwinlog in ( "\nNew Chat", "\nNick Mention"):
			self.alert_status("\n")	

		
		self.borderlogwin = curses.newwin(6, self.w-15, 1, 15)
		self.borderlogwin.border()
		self.borderlogwin.addstr(0, 3, "<")
		self.borderlogwin.addstr(0, 4, " Status Log ", blue | curses.A_BOLD)
		self.borderlogwin.addstr(0, 16, ">")
		self.borderlogwin.refresh()
		self.display_status_log()

		if self.current_room != None:
			self.set_room(self.current_room)
		


			
	def private_mode(self):
		self.display_which_text = "private"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h -8, self.w, 4, 0)
		self.chatwin.border()
		
		self.chatwin.addstr(0, 3, "< ")
		self.chatwin.addstr(0, 5, "Private Chat",  green | curses.A_BOLD)
		self.chatwin.addstr(0, 17, " >")
		self.chatwin.refresh()
		
		self.textwin = self.chatwin.subwin(self.h-10,self.w-2,5,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		
		self.scrollup_static = 0
		self.scrollup = self.scrollup_static
		
		if self.pm_user != None:
			for lines in self.privatelog[self.pm_user]:
				self.textwin.addstr(lines)
		else:
			for lines in self.pminfolog:
				self.textwin.addstr(lines)
		self.textwin.refresh()
		if self.pm_user != None:
			self.set_edit_title("Send message to: " + self.pm_user)
		else:
			self.set_edit_title("Set a user to Private Message")

		if self.alertwinlog == "\nNew PM":
			self.alert_status(" ")
			
		self.tabclearwin = curses.newwin(3, self.w, 1, 0)
		self.tabclearwin.hline(1, 1, curses.ACS_HLINE, self.w-2)
		
		self.tabclearwin.addstr(1,0, "<")
		self.tabclearwin.addstr(1,self.w-1, ">")
		self.tabclearwin.refresh()

		if self.pm_users != []:

			pos = 1
# 			totwidth = 0
# 			for string in self.pm_users:
# 				totwidth += len(string[:13])+3
			#self.textwin.refresh()
		
			for string in self.pm_users:
			#	self.textwin.addstr('\n'+str(string))
			#	sleep(2)
				if pos + len(string[:13])+3 < self.w -2:
					
					self.tabwin = curses.newwin(3, len(string[:13])+3, 1, pos)
					self.tabwin.border()
					self.tabwin.refresh()
					self.tab1win = self.tabwin.subwin(1,len(string[:13])+1,2,pos+1)
					if string == self.pm_user:
						self.tab1win.addstr(str(string[:13]), green | curses.A_BOLD)
					else:
						self.tab1win.addstr(str(string[:13]))
					self.tab1win.refresh()
					pos += len(string[:13])+3
			
			


	def transfer_mode(self):
		self.display_which_text = "transfer"
		self.hotkeys()
		# Draw upload border
		self.upwinheight = self.h/2-2
		self.transwin = curses.newwin(self.upwinheight, self.w, 1, 0)
		if self.transferscroll == "upload":
			self.transwin.attron(green)
			self.transwin.border()
			self.transwin.addstr(0, 3, "< Uploading Transfers >",  green | curses.A_BOLD)
			self.transwin.attroff(green)
		else:
			self.transwin.border()
			self.transwin.addstr(0, 3, "< Uploading Transfers >",   curses.A_BOLD)
		
		#+str(self.h) +'H '+ str(self.w)+'W ' + str(self.upwinheight ) #resize debugging
		self.transwin.refresh()
		
		# Draw upload window
		self.uptext = self.h/2-4
		self.upwin = self.transwin.subwin(self.h/2-4,self.w-2,2,1)
		self.upwin.scrollok(1)
		self.upwin.idlok(1)
		self.upwin.refresh()
		
		# Draw download border
		self.downwinheight = self.h -self.upwinheight -5 # Magic! :)
		self.trans2win = curses.newwin(self.downwinheight , self.w, self.h/2 -1, 0)
		if self.transferscroll == "download":
			self.trans2win.attron(green)
			self.trans2win.border()
			self.trans2win.addstr(0, 3, "< Downloading Transfers >",   curses.A_BOLD|green)
			self.trans2win.attroff(green)
		else:
			self.trans2win.border()
			self.trans2win.addstr(0, 3, "< Downloading Transfers >",   curses.A_BOLD)
		
		self.trans2win.addstr(self.downwinheight-1, self.w-18, "< "+self.transfer_display_mode.capitalize()+" >", curses.A_BOLD)
		self.trans2win.refresh()
		
		# Draw download window
		self.downtext = self.downwinheight -2
		self.downwin = self.trans2win.subwin(self.downtext,self.w-2,self.h/2,1)
		self.downwin.scrollok(1)
		self.downwin.idlok(1)
		self.scrollup_static = 0
		self.scrollup = self.scrollup_static
		self.downwin.refresh()

		self.set_edit_title("Modify Transfers")
		self.upload_manager()
		self.download_manager()
		
	def browse_mode(self):
		self.display_which_text = "browse"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Browse users >",  green | curses.A_BOLD)
		self.chatwin.refresh()
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 5000
		self.scrollup = self.scrollup_static
		for lines in self.browselog:
			self.textwin.addstr(lines)
		self.textwin.refresh()
		self.set_edit_title("Browse users' files")

	def search_mode(self):
		self.display_which_text = "search"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Search >",  green | curses.A_BOLD)
		self.chatwin.refresh()
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 5000
		self.scrollup = self.scrollup_static
		for lines in self.searchlog:
			self.textwin.addstr("\n"+lines)
		self.textwin.refresh()
		if self.search_type != None:
			self.set_edit_title("Search "+self.search_type.capitalize()+" for:")


	def info_mode(self):
		self.display_which_text = "info"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Info Mode >",  green | curses.A_BOLD)
		self.chatwin.refresh()
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 0
		self.scrollup = self.scrollup_static
		for lines in self.infolog:
			self.textwin.addstr(lines)
		self.textwin.refresh()
		self.set_edit_title("Get info about user:")
		if self.alertwinlog in ("\nNew Userinfo", "\nNew IP", "\nNew Stats"):
			self.alert_status("\n")

	def buddy_mode(self):
		
		self.display_which_text = "buddies"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Buddy Mode >",  green | curses.A_BOLD)
		self.chatwin.refresh()
		self.buddylist()
		
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 1000
		self.scrollup = self.scrollup_static
		
		for lines in self.buddylog:
			self.display_list_text(lines)
		self.textwin.refresh()
		self.set_edit_title("Add Buddy")
		
	def ban_mode(self):
		self.display_which_text = "banned"
		
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Ban Mode >",  green | curses.A_BOLD)
		self.banlist()
		self.chatwin.refresh()
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 1000
		self.scrollup = self.scrollup_static
		for lines in self.banlog:
			self.display_list_text(lines)
		self.textwin.refresh()
		self.set_edit_title("Add User to Ban List:")
		
	def ignore_mode(self):
		self.display_which_text = "ignored"
		
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.attron(green)
		self.chatwin.border()
		self.chatwin.attroff(green)
		self.chatwin.addstr(0, 3, "< Ignore Mode >",  green | curses.A_BOLD)
		self.ignorelist()
		self.chatwin.refresh()
		
		self.textwin = self.chatwin.subwin(self.h-6 -1,self.w-2,2,1)
		self.textwin.scrollok(1)
		self.textwin.idlok(1)
		self.scrollup_static = 1000
		self.scrollup = self.scrollup_static
		for lines in self.ignorelog:
			self.display_list_text(lines)
		self.textwin.refresh()
		self.set_edit_title("Add User to Ignore List")
		
		
	def setup_mode(self):
		
		self.display_which_text = "setup"
		self.hotkeys()
		self.chatwin = curses.newwin(self.h - 4 -1, self.w, 1, 0)
		self.chatwin.clear()
		self.chatwin.refresh()
		# Interface
		self.buttonwin = curses.newwin(3,32,1,0)
		self.buttonwin.border()
		self.buttonwin.addstr(0, 1, "< Interface >",  curses.A_BOLD)
		self.buttonwin.refresh()
		self.inbuttonwin = self.buttonwin.subwin(1,30,2,1)
		self.inbuttonwin.scrollok(1)
		if self.host != None:
			self.inbuttonwin.addstr(self.host, cyan )
		self.inbuttonwin.refresh()
		# Your stats
		self.bwin = curses.newwin(6,32,1,33)
		self.bwin.border()
		self.bwin.addstr(0, 1, "< Stats >",  curses.A_BOLD)
		self.bwin.refresh()
		self.inbwin = self.bwin.subwin(1,30,2,34)
		self.inbwin2 = self.bwin.subwin(1,30,3,34)
		self.inbwin3 = self.bwin.subwin(1,30,4,34)
		self.inbwin4 = self.bwin.subwin(1,30,5,34)
		self.inbwin.scrollok(1)
		self.inbwin2.scrollok(1)
		self.inbwin3.scrollok(1)
		self.inbwin4.scrollok(1)
		if self.stats != []:
			self.inbwin.addstr("Files: "+str(self.stats[3]), cyan )
			self.inbwin2.addstr("Dirs: "+str(self.stats[4]), cyan )
			self.inbwin3.addstr("Downloads: "+str(self.stats[2]), cyan )
			self.inbwin4.addstr("Average speed: "+str(self.stats[1]), cyan )
			#self.stats = user,  avgspeed, numdownloads, numfiles, numdirs
		else:
			if self.username != None:
				self.send(messages.PeerStats(self.username))
		self.inbwin.refresh()
		self.inbwin2.refresh()
		self.inbwin3.refresh()
		self.inbwin4.refresh()
		
 		self.buttonwin2 = curses.newwin(3,32,4,0)
 		self.buttonwin2.border()
		self.buttonwin2.addstr(0, 1, "< Interface Password >",  curses.A_BOLD)
 		self.buttonwin2.refresh()
		self.inbuttonwin2 = self.buttonwin2.subwin(1,30,5,1)
		self.inbuttonwin2.scrollok(1)
		if self.password != None:
			if self.unhide=="true":
				self.inbuttonwin2.addstr(self.password)
			else:
				self.inbuttonwin2.addstr("*********")
		else:
			self.inbuttonwin2.addstr("NOT set")
		self.inbuttonwin2.refresh()
		
 		self.buttonwin3 = curses.newwin(3,16,7,0)
 		self.buttonwin3.border()
		self.buttonwin3.addstr(0, 1, "<Buddies-Only>",  green | curses.A_BOLD)
 		self.buttonwin3.refresh()
		self.inbuttonwin3 = self.buttonwin3.subwin(1,15,8,1)
		self.inbuttonwin3.scrollok(1)
		if self.config != {}:
			self.inbuttonwin3.addstr(self.config["transfers"]["only_buddies"])
		self.inbuttonwin3.refresh()
		
		self.buttonwin4 = curses.newwin(3,16,7,16)
 		self.buttonwin4.border()
		self.buttonwin4.addstr(0, 1, "<Buddy Privs>",  green | curses.A_BOLD)
 		self.buttonwin4.refresh()
		
		self.inbuttonwin4 = self.buttonwin4.subwin(1,15,8,17)
		self.inbuttonwin4.scrollok(1)
		if self.config != {}:
			self.inbuttonwin4.addstr(self.config["transfers"]["privilege_buddies"])
		self.inbuttonwin4.refresh()

		
 		self.buttonwin5 = curses.newwin(3,16,10,0)
 		self.buttonwin5.border()
		self.buttonwin5.addstr(0, 1, "<Auto-Buddy>",  green | curses.A_BOLD)
 		self.buttonwin5.refresh()
		self.inbuttonwin5 = self.buttonwin5.subwin(1,15,11,1)
		self.inbuttonwin5.scrollok(1)
		if mucous_config["mucous"]["autobuddy"] != None:
			self.inbuttonwin5.addstr(mucous_config["mucous"]["autobuddy"])
		self.inbuttonwin5.refresh()
		
		self.buttonwin6 = curses.newwin(3,16,10,16)
 		self.buttonwin6.border()
		self.buttonwin6.addstr(0, 1, "< Slots >",  green | curses.A_BOLD)
 		self.buttonwin6.refresh()
		
		self.inbuttonwin6 = self.buttonwin6.subwin(1,15,11,17)
		self.inbuttonwin6.scrollok(1)
		if self.config != {}:
			self.inbuttonwin6.addstr(self.config["transfers"]["upload_slots"])
		self.inbuttonwin6.refresh()
		
		self.set_edit_title("Setup")

	def hotkeys(self):
		self.bottomwin = curses.newwin(1, self.w-1, self.h-1, 0)
		self.bottomwin.addstr(" 1", white | curses.A_BOLD)
		if self.display_which_text == "chat":
			self.bottomwin.addstr("Chat", curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Chat",  cyanbg)
		self.bottomwin.addstr(" 2", white | curses.A_BOLD)
		if self.display_which_text == "private":
			self.bottomwin.addstr("Private",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Private", cyanbg)
		self.bottomwin.addstr(" 3", white|  curses.A_BOLD)
		if self.display_which_text == "transfer":
			self.bottomwin.addstr("Transfers",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Transfers", cyanbg)
		
		self.bottomwin.addstr(" 4", white | curses.A_BOLD)
		if self.display_which_text == "search":
			self.bottomwin.addstr("Search",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Search", cyanbg)
		self.bottomwin.addstr(" 5", white | curses.A_BOLD)
		if self.display_which_text == "info":
			self.bottomwin.addstr("Info",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Info", cyanbg)
		self.bottomwin.addstr(" 6", white | curses.A_BOLD)
		if self.display_which_text == "browse":
			self.bottomwin.addstr("Browse",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Browse", cyanbg)

		self.bottomwin.addstr(" 7", white | curses.A_BOLD)
		if self.display_which_text == "buddies":
			self.bottomwin.addstr("Buddy",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Buddy",  cyanbg)

		self.bottomwin.addstr(" 8", white | curses.A_BOLD)
		if self.display_which_text == "banned":
			self.bottomwin.addstr("Ban",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Ban", cyanbg)

		self.bottomwin.addstr(" 9", white | curses.A_BOLD)
		if self.display_which_text == "ignored":
			self.bottomwin.addstr("Ignore",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Ignore", cyanbg)
			
		self.bottomwin.addstr(" 10", white | curses.A_BOLD)
		if self.display_which_text == "setup":
			self.bottomwin.addstr("Setup",curses.A_REVERSE |  greenbg)
		else:
			self.bottomwin.addstr("Setup",  cyanbg)
		self.bottomwin.refresh()

	# ---^  MODES ^
		
	# --- TEXT PLACEMENT v
	def log_to_file(self, messagetype, timestamp, place, message):
		path = os.path.join(log_dir, messagetype, place)
		dir = os.path.split(path)[0]
		if not os.path.isdir(dir):
			os.makedirs(dir)
		f = open(path, "a")
		f.write("%s %s\n" % (timestamp, message))
		f.close()
		
	def display_list_text(self, line):
		linenumber = line
		mtype = linenumber[0]
		username = linenumber[1]
		note = linenumber[2]		
		tabbeduser = username[:20]
		while len(tabbeduser) < 25:
			tabbeduser += ' '
		username = tabbeduser
		if self.display_which_text == "buddies":
			try:

				if mtype == 'Banned':
					self.textwin.addstr('\n'+username, curses.color_pair(1) | curses.A_BOLD)
					self.textwin.addstr(note)
				elif mtype == 'Ignored':
					self.textwin.addstr('\n'+username, curses.color_pair(2) | curses.A_BOLD)
					self.textwin.addstr(note)
				elif mtype == 'Normal':
					self.textwin.addstr('\n'+username, green | curses.A_BOLD)
					self.textwin.addstr(note)
				else:
					self.textwin.addstr('\n'+username)
					self.textwin.addstr(note)
				self.textwin.refresh()
			except:
				self.textwin.refresh()

					
		elif self.display_which_text == "banned":
			try:
				if mtype == 'Buddies':
					self.textwin.addstr('\n'+username, green | curses.A_BOLD)
				elif mtype == 'Ignored':
					self.textwin.addstr('\n'+username, curses.color_pair(2) | curses.A_BOLD)
				elif mtype == 'Normal':
					self.textwin.addstr('\n'+username, curses.color_pair(1) | curses.A_BOLD)
				else:
					self.textwin.addstr('\n'+username)
				self.textwin.refresh()
			except:
				self.textwin.refresh()
				
				
		elif self.display_which_text == "ignored":
			try:
				if mtype == 'Buddies':
					self.textwin.addstr('\n'+username, green | curses.A_BOLD)
				elif mtype == 'Banned':
					self.textwin.addstr('\n'+username, curses.color_pair(1) | curses.A_BOLD)
				elif mtype == 'Normal':
					self.textwin.addstr('\n'+username, curses.color_pair(2))
				else:
					self.textwin.addstr('\n'+username)
			except:
				self.textwin.refresh()
			
			self.textwin.refresh()
		else:
			self.textwin.addstr('\n'+username)
			self.textwin.refresh()


	def display_room_text(self, room, roomline):
		roomlinenumber = roomline
		mtype = roomlinenumber[0]
		timestamp = roomlinenumber[1]
		username =roomlinenumber[2]
		message =  roomlinenumber[3]

		if mtype == "Me":
			try:
				self.textwin.addstr("\n"+timestamp)
				self.textwin.addstr(" * %s %s" % (username, message), green | curses.A_BOLD)
			except:
				self.textwin.refresh()
		elif mtype == "List":
			
			try:
				
				self.textwin.addstr("\nUsers in %s: "% room)
				for username, color in message:
					if color == "Me":
						self.textwin.addstr(username, curses.A_BOLD)
					elif color == "Left":
						self.textwin.addstr(username, yellow)
					elif color == "Banned":
						self.textwin.addstr(username, red)
					elif color == "Buddies":
						self.textwin.addstr(username, green)
					elif color == "NotLast":
						self.textwin.addstr(username)
					elif color == "Normal":
						self.textwin.addstr(username)
				self.textwin.refresh()
			except:

				self.textwin.refresh()
		else:
			
			try:
				self.textwin.addstr("\n"+timestamp)
				if mtype == "Status":
					self.textwin.addstr(" ")
				else:
					self.textwin.addstr(" [")
				if username == self.username:
					self.textwin.addstr(username, curses.A_BOLD)
				elif username not in self.rooms[room].keys():
					self.textwin.addstr(username, yellow)
				elif username in self.config["banned"].keys():
					self.textwin.addstr(username, red)
				elif username in self.config["buddies"].keys():
					self.textwin.addstr(username, green)
				else:
					self.textwin.addstr(username)

				if mtype == "Status":
					self.textwin.addstr(" ")
				else:
					self.textwin.addstr("] ")
				if mtype == "Mentioned":
					x = message.split(" ")
					for e in x:
						if self.username not in e:
							self.textwin.addstr(e)
						elif self.username in e:
							self.textwin.addstr(e, cyan | curses.A_BOLD)
						if e is not  x[-1]:
							self.textwin.addstr(" ")
				elif mtype == "Normal":
					self.textwin.addstr(message)
				elif mtype == "Status":
					self.textwin.addstr(message)

			except:
				self.textwin.refresh()
		self.textwin.refresh()
				
	def say(self, mtype, room, user, message):
		
		if room == None:
			room = self.current_room

		self.roomlogs[room].append([mtype, time.strftime("%H:%M:%S"), user, message])
		if self.display_which_text == "chat":
			
			if room == self.current_room:
				
				self.chatwin.attron(green)
				self.chatwin.border()
				self.chatwin.addstr(1, self.w-1, "^",  green | curses.A_BOLD)
				self.chatwin.addstr(self.h-13, self.w-1, "v",  green | curses.A_BOLD)
				self.chatwin.addstr(0, 3, "< Chat Rooms >",  green | curses.A_BOLD)
				self.chatwin.addstr(self.h-12, self.w-18, "< "+str(abs(self.scrollup))+"/"+str(self.scrollup_static)+" >", green | curses.A_BOLD)
				self.chatwin.refresh()
				self.textwin.scrollok(1)
				self.scrollup_static = len(self.roomlogs[self.current_room])
				roomline = -1
				self.display_room_text(room, [mtype, time.strftime("%H:%M:%S"), user, message])
				
	def start_pm(self, user):

		if user not in self.privatelog:
			self.privatelog[user] = []
		if user not in self.pm_users:
			self.pm_users.append(self.pm_user)
		if self.display_which_text == 'private':
			self.private_mode()
			
	def private_log(self, pmtype, user, message):
	
		timestamp = time.strftime("%H:%M:%S")
		if user not in self.privatelog.keys():
			self.privatelog[user]=['']

		if message[:4] == "/me ":
			if pmtype == "outgoing":
				self.privatelog[user].append("\n%s * %s %s" % (timestamp, self.username,  message[4:]))
			elif pmtype == "incoming":
				self.privatelog[user].append("\n%s * %s %s" % (timestamp, user,  message[4:]))
		else:
			if pmtype == "outgoing":
				self.privatelog[user].append("\n%s You told %s: %s" % (timestamp, user, message))
			elif pmtype == "incoming":
				self.privatelog[user].append("\n%s %s said: %s" % (timestamp, user, message))
				
		if self.display_which_pm == None:
			self.display_which_pm = user
			if self.display_which_text == "private":
				self.private_mode()
		elif self.display_which_pm == user:
			if self.display_which_text == "private":
				self.textwin.addstr(self.privatelog[user][-1])
				self.textwin.refresh()
		#else:
		#	if self.display_which_text == "private":
		self.private_mode()
			
	def info_log(self, s):
		self.infolog.append("\n%s" % s)
		if self.display_which_text == "info":
			self.textwin.addstr(self.infolog[-1], curses.A_BOLD)
			self.textwin.refresh()

	def buddy_log(self, mtype, user, note):
		self.buddylog.append([mtype, user, note])

	def ban_log(self, mtype, user, note):
		self.banlog.append([mtype, user, note])

	def ignore_log(self, mtype, user, note):
		self.ignorelog.append([mtype, user, note])

	def log_window(self, user, room, did, what):
		
		if did == "ticker" and what != '':
			if user in self.rooms[room].keys():
				self.statuslogs[room].append("\n%s %s set ticker to %s" % (time.strftime("%H:%M:%S"), user, what))
				if room == self.current_room and self.display_which_text == "chat":
					self.logwin.addstr(self.statuslogs[room][-1])
		elif did == "join":
			self.statuslogs[room].append("\n%s %s joined" % (time.strftime("%H:%M:%S"), user))
			if room == self.current_room and self.display_which_text == "chat":
				self.logwin.addstr(self.statuslogs[room][-1])
		elif did == "left":
			self.statuslogs[room].append("\n%s %s left" % (time.strftime("%H:%M:%S"), user))
			if room == self.current_room and self.display_which_text == "chat":
				self.logwin.addstr(self.statuslogs[room][-1])
		elif did == "change":
			for rooms in self.joined:
				if user in self.rooms[rooms].keys():
					string = "\n%s %s is %s" % (time.strftime("%H:%M:%S"), user, what)
					if self.statuslogs[rooms] == []:
						self.statuslogs[rooms].append(string)
						if rooms == self.current_room and self.display_which_text == "chat":
							self.logwin.addstr(self.statuslogs[rooms][-1])
					elif string[10:] != self.statuslogs[rooms][-1][10:]:
						self.statuslogs[rooms].append(string)
						if rooms == self.current_room and self.display_which_text == "chat":
							self.logwin.addstr(self.statuslogs[rooms][-1])
		if self.display_which_text == "chat":
			self.logwin.refresh()
		
	def search_log(self, s):

		self.searchlog.append("\n%s" % s)
		if self.display_which_text == "search":
			self.textwin.addstr("\n"+self.searchlog[-1])
			self.textwin.refresh()
		
	def browse_log(self, s):
		self.browselog.append("\n%s" % s)

		if self.display_which_text == "browse":
			self.textwin.addstr(self.browselog[-1])
			self.textwin.refresh()
			
	def uptransfer_log(self, s):
		self.uptransferlog.append("\n%s" % s)

		if self.display_which_text == "transfer":
			self.upwin.addstr(self.uptransferlog[-1])
			self.upwin.refresh()
			
	def downtransfer_log(self, s):
		self.downtransferlog.append("\n%s" % s)

		if self.display_which_text == "transfer":
			self.downwin.addstr(self.downtransferlog[-1])
			self.downwin.refresh()
			
	def search_status(self, s):
		self.searchwinlog = "\nResults: %s" % s
		self.searchwin.addstr(self.searchwinlog, curses.A_UNDERLINE)
		self.searchwin.refresh()
		
	def upload_status(self, s):
		self.uploadwin.addstr("\nUp: %s" % s , curses.A_UNDERLINE)
		self.uploadwin.refresh()
		
	def download_status(self, s):	
		self.downloadwin.addstr("\nDown: %s" % s, curses.A_UNDERLINE)
		self.downloadwin.refresh()
		
	def alert_status(self, s):	
		self.alertwinlog = "\n%s" % s[:14]
		self.alertwin.addstr(self.alertwinlog, curses.color_pair(1) | curses.A_UNDERLINE)
		self.alertwin.refresh()
				
		
	# --- TEXT PLACEMENT ^
	
	


c = mucous()
line = ""
try:
	while 1:
		stdscr = curses.initscr()
		curses.start_color()
		curses.mousemask(curses.BUTTON1_CLICKED)
		curses.mouseinterval(110)
		
		if curses.has_colors() == True:
			try:
				curses.use_default_colors()
				curses.can_change_color()
				curses.init_pair(1, curses.COLOR_RED, -1)
				curses.init_pair(2, curses.COLOR_YELLOW, -1)
				curses.init_pair(3, curses.COLOR_CYAN, -1)
				curses.init_pair(4, curses.COLOR_BLUE, -1)
				curses.init_pair(5, curses.COLOR_GREEN, -1)
				curses.init_pair(6, curses.COLOR_BLACK, -1)
				curses.init_pair(7, curses.COLOR_WHITE, -1)
				curses.init_pair(8, curses.COLOR_MAGENTA, -1)
				curses.init_pair(9, 0, curses.COLOR_CYAN)
				curses.init_pair(10, curses.COLOR_GREEN, curses.COLOR_BLACK )
				curses.init_pair(11, curses.COLOR_YELLOW, curses.COLOR_BLUE)
				red = curses.color_pair(1)
				yellow = curses.color_pair(2)
				cyan =  curses.color_pair(3)
				blue = curses.color_pair(4)
				green =  curses.color_pair(5)
				black = curses.color_pair(6)
				white = curses.color_pair(7)
				magenta = curses.color_pair(8)
				cyanbg = curses.color_pair(9)
				greenbg = curses.color_pair(10)
				hotkey = curses.color_pair(11)
			except AttributeError:
				curses.init_pair(1, curses.COLOR_RED, 0)
				curses.init_pair(2, curses.COLOR_YELLOW, 0)
				curses.init_pair(3, curses.COLOR_CYAN, 0)
				curses.init_pair(4, curses.COLOR_BLUE, 0)
				curses.init_pair(5, curses.COLOR_GREEN, 0)
				curses.init_pair(6, curses.COLOR_BLACK, curses.COLOR_WHITE)
				curses.init_pair(7, curses.COLOR_WHITE, 0)
				curses.init_pair(8, curses.COLOR_MAGENTA, 0)
				curses.init_pair(9, 0, curses.COLOR_CYAN)
				curses.init_pair(10, curses.COLOR_GREEN, curses.COLOR_BLACK )
				curses.init_pair(11, curses.COLOR_YELLOW, curses.COLOR_BLUE)
				red = curses.color_pair(1)
				yellow = curses.color_pair(2)
				cyan =  curses.color_pair(3)
				blue = curses.color_pair(4)
				green =  curses.color_pair(5)
				black = curses.color_pair(6)
				white = curses.color_pair(7)
				magenta = curses.color_pair(8)
				cyanbg = curses.color_pair(9)
				greenbg = curses.color_pair(10)
				hotkey = curses.color_pair(11)
		else:
			
			hotkey = greenbg =cyanbg = magenta = white = black = green =  blue = cyan = yellow = red =  curses.color_pair(0)
		#Disable cursor (bad idea)
		#curses.curs_set(0)
		
		curses.noecho()
		curses.cbreak()
		stdscr.keypad(1)
		c.build(stdscr, line)
		
		if c.socket is None:
			c.connect()
		try:
			c.process()
		except select.error:
			line = c.edit.line
			curses.endwin()
			continue
		break
except Exception, e:
	#print e
	#sleep(5)
	curses.nocbreak()
	stdscr.keypad(0)
	curses.echo()
	curses.endwin()
	print e
	#sys.exit()

curses.nocbreak()
stdscr.keypad(0)
curses.echo()
curses.endwin()