#! /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 UserDict import UserDict

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

version = "0.6.2b1"

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
	-l,	--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:
	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", "roomlistminsize": 5, "roombox": "big", "log_dir": "~/.mucous/logs/", "now-playing": "default", "now-playing-prefix": None, "browse_display_mode": "filesystem", "url reader": "firefox", "url custom prefix": "", "url custom suffix": ""}, \
	"tickers":{'default_ticker': "http://thegraveyard.org/daelstorm/mucous.html", 'tickers_enabled': 'yes', "ticker_cycle": "yes", "rooms":{} }, \
	"aliases": {"mucous":"Mucous is a Curses client for the Museek Soulseek Daemon. Website: http://thegraveyard.org/daelstorm/mucous.html", "museek":"Museek is a Soulseek Daemon/Client. The website is http://museek.thegraveyard.org/"},\
	"rooms": {"default_room":"museek"}\
	}
		

	
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"


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', 'roombox', 'tickers_enabled', "ticker_cycle", 'default_room', "autobuddy", "now-playing", "log_dir", "now-playing-prefix", "browse_display_mode", "url reader", "url custom prefix", "url custom suffix"] :
				mucous_config[i][j] = val
			elif i == 'aliases':
				mucous_config[i][j] = val
			else:
				try:
					mucous_config[i][j] = eval(val, {})
				except:
					mucous_config[i][j] = None

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, history, history_count, line = ""):
		self.win = win
		self.escaped = escaped
		self.tabbing = tabbing
		self.history = history
		self.history_count = history_count
		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 = []
		elif c not in ("KEY_UP", "KEY_DOWN"):
			self.history_count = -1
		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"):
			# Scrolling
			if not self.escape:
				self.escaped(c, self.line)
			elif self.escape:
				self.line, self.history_count = self.history(c, self.line, self.history_count)
				self.x = len(self.line)
		elif c in ("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
			self.escaped(c, self.line)
			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()

		try:
			self.win.addstr(self.line[self.scroll:self.scroll+self.w-1])
		except:
			pass
		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.info_user = None
		self.info_users = []
		self.current_room = None # Current Chatroom
		self.user_status = {}
		self.user_stats = {}
		# Temporary Logs
		self.log = [""] * 4
		self.onlinestatuslog ="\nOffline"
		self.usernamelog = [""] 
		self.uploadlog = "\nUp: ", 0
		self.downloadlog ="\nDown: ", 0
		self.searchwinlog = "\nResults: ", 0
		self.buddylog = [""] 
		self.banlog = [""]
		self.ignorelog = [""]
		self.uptransferlog = [""]
		self.downtransferlog = [""]
		
		self.historylog=[]
		self.history_count = 0
		
		self.alertwinlog = ""
		self.privatelog = {}
		self.userinfolog = {}
		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/close (close current PM)",\
"\n/msg <message>\n"]

		self.searchlog={}
		self.searchlog["default__"] = ["Global search commands:",\
"\n/searchfor <query>",\
"\n/searchbuddy <query>",\
"\n/download <number>",\
"\n/close (close current search)",\
"\nPress Insert to toggle between searches.",\
"\nPress PageUp/Down to toggle Global/Buddy searches",\
"\nOr, type in the query, below."]

		self.chosen_search="default__"
		self.browselog={}
		self.browselog["default__"] = ["--Global browsing commands--",\
"\n/buser <user>",\
"\n/bsearch <query> (Search thru all Shares)",\
"\n/download <number>",\
"\n/close (close current shares)",\
"\nPress Insert to toggle between shares. Click on FileSystem/List to toggle modes",\
"\n--File System browsing commands--",\
"\nget, getdir, cd, ls, ls -l, lsdirs",\
"\nFirst, 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.url = None
		self.display_which_text = "chat" # default mode
		self.display_which_list  = "buddies"
		self.chatroomscroll = "roomchat"
		self.roomboxlist ={}
		if "roombox" in mucous_config["mucous"].keys():
			self.chatdisplaymode = mucous_config["mucous"]["roombox"]
		else:
			self.chatdisplaymode = "big"
		if "roomlistminsize" in mucous_config["mucous"].keys():
			pass
		else:
			mucous_config["mucous"]["roomlistminsize"] = 1
		self.display_which_pm = None
		
		self.ip_requested = None
		self.info_requested = None
		self.stat_requested = None
		
		self.browse_requested = []
		self.browsed=[]
		
		if "browse_display_mode" in mucous_config["mucous"]:
			pass
		else:
			mucous_config["mucous"]["browse_display_mode"] = "filesystem"
			
		self.browse_list_results = {}
		self.browse_current_dir = ''
		self.browse_current = "default__"
		
		self.users_status={}
		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_last = 0
		self.scrollup_static = 0
		self.end = 0
		self.start = 0
		self.requested_room_list = False
		
		self.all_roomlist = {}
		
		# searches
		self.search_visible = 1
		self.s_tickets = []
		self.s_query = {}
		self.sfilter= None
		self.search_results = {}
		self.search_number = 0
		self.search_type = "globally"
		
		# transfers
		self.browse_results = {}
		self.browse_number = {}
		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 = {}
		self.trans_speed_display = True
		# config
		self.config = {}
		self.invalidpass = 0
		self.stats = []
		self.setup_input_mode = "default"
		self.setup_display_mode = "mucous"
		self.unhide = "false" # show password?
		
		# tickers
		self.ticker_room = None
		self.master_ticklist = {}
		
		self.ticker_timer = threading.Timer(3.0, self.ticker_display)
		if "ticker_cycle" in mucous_config["tickers"].keys():
			pass
		else:
			mucous_config["tickers"]["ticker_cycle"] = "yes"
		# Help lists
		self.commandlist =  ["/me", "/join", "/part", "/leave", "/talk", "/say", "/alias", "/list", "/users", \
"/cd", "/ls", "/ls -l", "/get", "/getdir", "/nick",\
"/help", "/info",  "/autojoin", "/noauto", "/roombox", "/roomlist", "/roomlistrefresh", \
"/inrooms", "/pm", "/pmclose", "/msg", "/infoclose", "/np", "/npset", "/npcheck",\
"/npprefix", "/tickroom", "/tickcycle", "/settick", "/listtick", "/tickers", "/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", "/retryall", "/clearup", "/cleardown", "/clearroom", "/clearsearchs", "/url", "/urlreader", "/urlcustom",\
"/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"]

 		for alias in mucous_config["aliases"].keys():
			self.commandlist.append("/"+alias)
		
		self.help_chat = ["----[Chat Commands]----", \
"/join <room>\t/part <room>\t/leave <room>",\
"/j <room>\t/talk <room>\t/say <room> <message>",\
"/users <room>\t\t(lists of users in room)",\
"/autojoin <room>\t(autojoin room next session)",\
"/noauto <room>\t\t(don't autojoin next session)",\
"/roomlist <num users> \t(list of rooms >= number)",\
"/roomlistrefresh\t(redownload roomlist from server)",\
"/inrooms\t\t(list of joined rooms)",\
"/clearroom <room>\t(clear <room>, or current room)",\
"/pm <user> \t\t(private message)",\
"/msg <message>\t\t(send message to last user)",\
"/url /urlcustom (command$command) /urlreader (lynx|links|elinks|firefox|custom)",\
"/np\t\t\t(XMMS/BMP Now playing script)",\
"/npcheck\t\t(display Now playing script command)",\
"/npset <command>\t(Set Now playing script to command)",\
"/npprefix <text>\t(set to np: or /me is now playing:)",\
"/alias <alias> <text>\t/unalias <alias>"]

		
		self.help_ticker = ["----[Ticker Commands]---- ",\
"/tickroom <room> \t\t(Choose room to set ticker)",\
"/settick <message>\t(set ticker for last room)",\
"/listtick <room>\t(Lists tickers in room)",\
"/tickcycle \t\t(Toggle cycling tickers in chat rooms)",\
"/tickers \t\t(Toggle tickers)"]

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

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

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

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

		self.help_mode_text = ["----[Mode Commands]---- ",\
"/chat\t\t[Chat Mode]",\
"/transfer\t[Transfer Mode]",\
"/info\t\t[Info Mode]",\
"/browse\t\t[Browse Mode]",\
"/private\t[Private Message Mode]",\
"/search\t\t[Search Mode]",\
"/buddylist\t[Buddy Mode]",\
"/banlist\t[Ban Mode]",\
"/ignorelist\t[Ignore Mode]",\
"/setup\t\t[Setup Mode]",\
"/help\t\t[Help Mode]"]

		self.help_help = ["----[Help Commands]---- ",\
"/help\t\t(This Message)",\
"/help connect\t(Connection Commands)",\
"/help setup\t(Setup Commands)",\
"/help mode\t(Mode Commands)",\
"/help chat\t(Chatroom Commands)",\
"/help ticker\t(Ticker Commands)",\
"/help user\t(User Commands)",\
"/help transfer\t(Transfer Commands)",\
"/help browse\t(Browse Commands)",\
"/help search\t(Search Commands)",\
"/help download\t(Download Commands)",\
"/help keys\t(Special Keys)",\
"/quit"]
		
		self.help_search = ["----[Search Commands]----",\
"/search\t[Switch to Search Mode]",\
"/searchfor <query>",\
"/searchbuddy <query>",\
"/download <search number>",\
"/downdir <search number>",\
"/close (Close Current Search)",\
"/clearsearchs (Removes all searches)",\
"/filter (Turn OFF Filter)\t/filter <query> (Set Filter)"]

		self.help_browse = ["----[Browse Commands]----",\
"/browse\t[Switch to Browse Mode]",\
"/browseuser /buser <user>",\
"/download <browse number>",\
"/close (Close Current Shares)",\
"--File System browsing commands--",\
"ls, ls -l, lsdirs (list) cd (change dir) get, getdir (download)",\
"/browsesearch /bsearch <query> (search browsed files)"]
		
		self.help_download = ["----[Manual Download Commands]----",\
"/downuser <user> (sets download user)",\
"/downpath <path> (download file from user)",\
"/downpathdir <path> (download dir from user)"]

		self.help_keys =["------[Keys]------ ",\
"ESC or Alt + [, ], <-, ->\t(Change Room / Transfer display mode)",\
"Insert\t\t\t\t(Same as above)",\
"Tab\t\t(Completes nicks)",\
"Home/End\t(switches Upload & Download scrolling)",\
"Up, PageUp\t(Scroll Up a line, a page)",\
"Down, PageDown\t(Scroll Down a line, a page)",\
"F1->Chat\t\tF6->Browse",\
"F2->Private Messages\tF7->Buddy List",\
"F3->Transfers\t\tF8->Ban List",\
"F4->Search\t\tF9->Ignore List",\
"F5->Info\t\tF10->Setup"]

		self.helplog =["----[Help Commands]---- ",\
"\n/help\t\t(This Message)",\
"\n/help connect\t(Connection Commands)",\
"\n/help setup\t(Setup 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 browse\t(Browse Commands)",\
"\n/help search\t(Search Commands)",\
"\n/help download\t(Download Commands)",\
"\n/help keys\t(Special Keys)",\
"\n/quit"]		
	
	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:
		try:
			
			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)
			
							
			self.onlinestatus =  curses.newwin(1, 8, 0, 0)
			self.onlinestatus.scrollok(1)
			self.onlinestatus.idlok(1)
			try:
				self.onlinestatus.addstr(self.onlinestatuslog)
			except:
				pass
			self.onlinestatus.refresh()
			
			self.uploadwin = curses.newwin(1, 10, 0, 25)
			self.uploadwin.scrollok(1)
			self.uploadwin.idlok(1)
			try:
				self.uploadwin.addstr(self.uploadlog[0])
				self.uploadwin.addstr(str(self.uploadlog[1]), curses.A_BOLD)
			except:
				pass
			self.uploadwin.refresh()
			
			self.downloadwin = curses.newwin(1, 10, 0, 35)
			self.downloadwin.scrollok(1)
			self.downloadwin.idlok(1)
			try:
				self.downloadwin.addstr(self.downloadlog[0])
				self.downloadwin.addstr(str(self.downloadlog[1]), curses.A_BOLD)
			except:
				pass
			self.downloadwin.refresh()
			

			self.searchwin = curses.newwin(1, 15, 0, self.w-30)
			self.searchwin.scrollok(1)
			self.searchwin.idlok(1)
			try:
				self.searchwin.addstr(self.searchwinlog[0])
				self.searchwin.addstr(str(self.searchwinlog[1]), curses.A_BOLD)
			except:
				pass
			self.searchwin.refresh()


			self.alertwin = curses.newwin(1, 15, 0, self.w-15)
			self.alertwin.scrollok(1)
			self.alertwin.idlok(1)
			try:
				self.alertwin.addstr(self.alertwinlog, red | curses.A_BOLD)
			except:
				pass
			self.alertwin.refresh()

			self.usernamewin = curses.newwin(1, 16, 0, 9)
			self.usernamewin.scrollok(1)
			self.usernamewin.idlok(1)
			if self.username != None:
				try:
					self.usernamewin.addstr('\n'+self.username[:15])
				except:
					pass
			self.usernamewin.refresh()

			
			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 == "lists":
				self.list_mode()
				
			elif self.display_which_text == "rooms":
				self.rooms_mode()
				
			elif self.display_which_text == "setup":
				self.setup_mode()
				
			elif self.display_which_text == "help":
				self.help_mode()


		except Exception, e:
			self.help_log(e)
		try:
			self.edit = editor(self.editwin, self.escaped, self.tabbing, self.listline, self.textwin, self.history, self.history_count, line)
			self.stdscr.nodelay(1)	
		except:
			self.help_log(e)
		
		
	def nickcheck(self):
		if self.username == None:
			self.help_mode()
			self.help_log("Connection is taking a while to start, maybe you are trying to connect to a FTP daemon?")
			self.help_log("Killing connection..")
			self.help_log("Try using /interface to connect to a different port.")
			for line in self.help_connect:
				self.help_log(line)
			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(10.0, self.nickcheck)
						self.timer.start()
						driver.Driver.connect(self, mucous_config["connection"]["interface"],  mucous_config["connection"]["passw"], 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.help_mode()
				#self.help_log(str(e))
				if self.timer != None:
					self.timer.cancel()
				if e == "INVPASS":
					self.help_log("Incorrect Password, try another.")
				elif e == [111, "Connection refused"]:
					self.help_log(e[1] +", make sure the daemon is running, or change the interface.")
				self.help_log("Connection failed, try changing your interface or password")
				for lines in self.help_connect:
					self.help_log(lines)
				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:]
						
						try:
							if self.edit.process(c):
								line = self.edit.line
								yes = self.commands(line)
								
								if yes == 0:
									break
								elif yes == 2:
									return
								else:
									self.edit.reset()
						except:
							pass


	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:]
				try:
					
					if self.edit.process(c):
						line = self.edit.line
						yes = self.commands(line)
						
						if yes == 0:
							break
						elif yes == 2:
							return
						else:
							self.edit.reset()
							
				except Exception, e:
					self.help_log(e)
					
	def commands(self, line):
		if line[:1] == "/" and line[:4] != "/me " and line[:2] != '//':
		
			if line == "/quit" or line == "/exit":
				return 2
			elif line[:11] == "/disconnect":
				self.disconnect()
			elif line[:5] == "/help":
				
				self.help_mode()
				if line[5:] == " chat":
					for line in self.help_chat:
						self.help_log(line)
				elif line[5:] == " mode":
					for line in self.help_mode_text:
						self.help_log(line)
				elif line[5:] == " user":
					for line in self.help_user:
						self.help_log(line)
				elif line[5:] == " search":
					for line in self.help_search:
						self.help_log(line)
				elif line[5:] == " browse":
					for line in self.help_browse:
						self.help_log(line)
				elif line[5:] == " transfer":
					for line in self.help_transfer:
						self.help_log(line)
				elif line[5:] == " ticker":
					for line in self.help_ticker:
						self.help_log(line)
				elif line[5:] == " download":
					for line in self.help_download:
						self.help_log(line)
				elif line[5:] == "":
					for line in self.help_help:
						self.help_log(line)
				elif line[5:] == " keys":
					for line in self.help_keys:
						self.help_log(line)
				elif line[5:] == " connect":
					for line in self.help_connect:
						self.help_log(line)
				elif line[5:] == " setup":
					for line in self.help_setup:
						self.help_log(line)
				try:
					self.edit.reset()
				except:
					pass
				'''
				Chatrooms
				'''
			elif line[:6] == "/talk ": 
				self.set_room(line[6:])
				
			elif line[:6] == "/join ":
				self.send(messages.JoinRoom(line[6:]))
			elif line[:3] == "/j ":
				self.send(messages.JoinRoom(line[3:]))
				
			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[:7]))
				
			elif line[:10] == "/autojoin " and line[10:] != '':
				if line[10:] in self.joined:
					room = line[10:]
					self.mod_config("autojoin", room, '')
				else:
					self.help_log("You aren't in room: %s" % line[5:])
					
			elif line == "/autojoin":
				if self.current_room != None:
					room = self.current_room
					self.mod_config("autojoin", room, '')
				
			elif line[:8] == "/noauto ":
				if line[8:] in self.joined:
					room = line[8:]
					self.mod_config("unautojoin", room, '')

			elif line == "/close":
				if self.display_which_text == 'private':
					self.close_private_chat(self.pm_user)
				elif self.display_which_text == 'info':
					self.close_userinfo(self.info_user)
				elif self.display_which_text == 'browse':
					if self.browse_current != "default__":
						self.close_browse(self.browse_current)
				elif self.display_which_text =='search':
					if self.chosen_search != "default__":
						self.close_search(self.chosen_search)
					
			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 == "/pmclose":
				if self.pm_user != None:
					self.close_private_chat(self.pm_user)
			elif line == "/infoclose":
				if self.info_user != None:
					self.close_userinfo(self.info_user)
			elif line[:11] == "/infoclose " and line[11:] != '':
				user = line[11:]
				self.close_userinfo(user)
			elif line[:9] == "/pmclose " and line[9:] != '':
				user = line[9:]
				self.close_private_chat(user)
					
			elif line[:5] == "/msg " and line[5:] != '':
				if self.pm_user != None:
					message = line[5:]
					
					self.send_private_message(self.pm_user, message)
				else:
					self.help_mode()
					self.help_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[:5] == "/say " and line[5:] !='':
				# /say <room> /me is hungry
				sine = line[5:]
				splited = sine.split(' ')
				if len(splited) > 1:
					
					if splited[0] in self.joined:
						room = splited[0]
						if splited[1].isspace():
							pass
						else:
							message = string.join(map(str, splited[1:]))
							self.say_in_chat("chat", room, message)
					else:
						if len(splited) > 2:
							s = ''
							n = 0
							
							self.help_log(splited)
							for i in range(len(splited)):
								if i == 0:
									s =splited[i]
								else:
									s += ' ' +splited[i]
								n += 1
								if s in self.joined:
									break
		
							if s not in self.joined:
								self.help_log(s)
								pass
							else:
								room = s
								message = string.join(map(str, splited[n:]))
								if message.isspace():
									pass
								else:
									self.say_in_chat("chat", room, message)
							
		
			elif line[:4] == "/url" and line[4:] == '':
				self.url = None
				logfile = None
				if self.display_which_text == "chat" and self.current_room != None:
					logfile = self.roomlogs[self.current_room]
				elif self.display_which_text == "private" and self.pm_user != None:
					logfile = self.privatelog[self.pm_user]
				if logfile != None:
					lene = len(logfile)
					if lene > self.h-7:
						x = 3
					else:
						x = lene
					if x != 0:
						if self.display_which_text == "chat":
							for line in logfile:
								if "://" in line[3]:
									urline = line[3].split(" ")
									for x in urline:
										if "://" in x:
											self.url = x
						elif self.display_which_text == "private":
							for line in logfile:
								if "://" in line:
									urline = line.split(" ")
									for x in urline:
										if "://" in x:
											self.url = x
						
		
				if self.url != None:
					if mucous_config["mucous"]["url reader"] == "links":
						if os.path.expandvars("$TERM") != "linux" and os.path.exists("/usr/bin/links"):
							os.system("xterm -e 'TERM=xterm-color links "+self.url +"' &")
					elif mucous_config["mucous"]["url reader"] == "elinks":
						if os.path.expandvars("$TERM") != "linux" and os.path.exists("/usr/bin/elinks"):
							os.system("xterm -e 'TERM=xterm-color elinks "+self.url +"' &")
					elif mucous_config["mucous"]["url reader"] == "lynx":
						if os.path.expandvars("$TERM") != "linux" and os.path.exists("/usr/bin/lynx"):
							os.system("xterm -e 'TERM=xterm-color lynx "+self.url +"' &")	
					elif mucous_config["mucous"]["url reader"] == "firefox":
						os.system("mozilla -a firefox -remote 'openURL("+self.url +",new-tab)' &")
					elif mucous_config["mucous"]["url reader"] == "custom":
						os.system(mucous_config["mucous"]["url custom prefix"]+self.url+mucous_config["mucous"]["url custom suffix"]+" &")
						
			elif line[:11] == "/urlreader " and line[11:] != '':
				mucous_config["mucous"]["url reader"] = line[11:]
			elif line[:11] == "/urlcustom " and line[11:] != '':
				if "$" in line[11:]:
					custom = line[11:].split("$")
					if len(custom) > 1 and len(custom) < 3:
						mucous_config["mucous"]["url custom prefix"] = custom[0]
						mucous_config["mucous"]["url custom suffix"] = custom[1]
					elif len(custom) == 1:
						mucous_config["mucous"]["url custom prefix"] = custom[0]
						mucous_config["mucous"]["url custom suffix"] = ''
			elif line[:3] == "/np" and line[3:] == '':
				self.now_playing()
				
						
			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.help_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 == "/npprefix":
				if "now-playing-prefix" in mucous_config["mucous"]:
					mucous_config["mucous"]["now-playing-prefix"] = None
			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:
					self.logging = False
				else:
					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.display_which_list = "buddies"
				self.list_mode()
				
			elif line[:8] == "/banlist"   and line[8:] == '':
				self.display_which_list = "banned"
				self.list_mode()
				
			elif line[:11] == "/ignorelist"   and line[11:] == '':
				self.display_which_list = "ignored"
				self.list_mode()
				
			elif line[:6] == "/setup"   and line[6:] == '':
				self.setup_mode()
				
				'''
				CONFIG
				'''
			elif line[:5] == "/save" and line[5:] == '':
				update_config()
				self.help_mode()
				self.help_log("Config Saved")
			elif line[:11] == "/interface " and line[11:] != "":
				mucous_config["connection"]["interface"] = line[11:]
				self.help_log("Museekd interface set to: " + line[11:])
		
			elif line[:10] == "/password " and line[10:] != "":
				mucous_config["connection"]["passw"] = line[10:]
				self.help_log("New password set")
		
			elif line[:8] == "/version":
				self.help_mode()
				self.help_log("\nMucous version: %s" % version)
			elif line[:8] == "/connect":
				self.connect()
			
				'''
				Tickers
				'''
			elif line[:9] == "/tickroom":
				if line[9:] == '':
					self.ticker_room =  self.current_room
					#self.help_log("You picked room: " +self.ticker_room+" to set a ticker.")
					#self.help_mode()
				elif line[9:10] == " " and line[10:] != '':
					self.ticker_room = line[10:]
					#self.help_log("You picked room: " +self.ticker_room+" to set a ticker.")
					#self.help_mode()
					
			elif line[:7] == "/ticker" and line[7:] == '':
				if mucous_config["tickers"]["tickers_enabled"] == 'no':
					mucous_config["tickers"]["tickers_enabled"] = 'yes'
					
				elif mucous_config["tickers"]["tickers_enabled"] == 'yes':
					mucous_config["tickers"]["tickers_enabled"] = 'no'
					
			elif line[:10] == "/tickcycle" and line[10:] == '':
				if mucous_config["tickers"]["ticker_cycle"] == 'no':
					mucous_config["tickers"]["ticker_cycle"] = 'yes'
					
				elif mucous_config["tickers"]["ticker_cycle"] == 'yes':
					mucous_config["tickers"]["ticker_cycle"] = 'no'
					
					try:
						self.ticker_timer.cancel()
						if self.display_which_text=="chat":
							self.display_status_log_border()
							self.display_status_log()
					except Exception, e:
						self.help_log(e)
		
			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.help_log("You set your ticker in " +self.ticker_room+" to "+message)
				else:
					self.help_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 rooms12 in self.master_ticklist:
					alpha_list[rooms12] = self.master_ticklist[rooms12]
				if mucous_config["tickers"]["tickers_enabled"] == 'yes':
					for rooms13, ticks in alpha_list.items():
						if rooms13 == woom:
							
							ttickers =[]
							ttickers = ticks.keys()
							if ttickers != []:
								self.info_log("Tickers in room: "+str(rooms13))
							ttickers.sort()
							for names in ttickers:
								self.info_log(" ["+str(names)+'] '+str(ticks[names]))
		
		
				'''
				User Management
				'''
			elif line[:5] == "/ban " and line[5:] != '':
				username = line[5:]
				self.mod_config("ban", username, '')
				
				
			elif line[:7] == "/unban " and line[7:] != '':
				username = line[7:]
				self.mod_config("unban", username, '')
				
					
			elif line[:8] == "/ignore " and line[8:] != '':
				username = line[8:]
				self.mod_config("ignore", username, '')
				
			elif line[:10] == "/unignore " and line[10:] != '':
				username = str(line[10:])
				self.mod_config("unignore", username, '')
						
			elif line[:7] == "/buddy " and line[7:] != '':
				username = str(line[7:])
				self.mod_config("buddy", username, '')
				
			elif line[:9] == "/unbuddy " and line[9:] != '':
				username = str(line[9:])
				self.mod_config("unbuddy", username, '')
				
			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.help_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.help_log("Irradiated: %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.help_log("AutoBuddy Disabled")
				elif mucous_config["mucous"]["autobuddy"]  == "no":
					mucous_config["mucous"]["autobuddy"] = "yes"
					self.help_log("AutoBuddy Enabled")
					
		
				'''
				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)
					
			elif line[:6] == "/users":
				self.startup = 0
				if line [6:7] == ' ':
					woom = line[7:]
				else:
					woom = self.current_room
				if woom != None:
					self.show_nick_list(woom)
					
			elif line == "/roombox":
				if self.chatdisplaymode == "nothing":
					self.chatdisplaymode = "small"
					self.chatroomscroll  = "roombox"
				elif self.chatdisplaymode == "small":
					self.chatdisplaymode = "big"
					self.chatroomscroll  = "roombox"
				elif self.chatdisplaymode == "big":
					self.chatdisplaymode = "nostatuslog"
					self.chatroomscroll  = "roomchat"
				elif self.chatdisplaymode == "nostatuslog":	
					self.chatdisplaymode = "chat-only"
					self.chatroomscroll  = "roomchat"
				elif self.chatdisplaymode == "chat-only":
					self.chatdisplaymode = "nothing"
					self.chatroomscroll  = "roomchat"
					
				mucous_config["mucous"]["roombox"] = self.chatdisplaymode
				self.chat_mode()
				
				'''
				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] == ' ':
					if line[10:].isdigit():
						self.size = int(line[10:])
						self.display_room_list()
					else:
						self.help_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.help_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.help_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.help_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', ' ') and len(query) > 2:
					self.send(messages.Search(0, query))
					
				else:
					self.search_log("Query \""+ query+"\" was ignored", "default__")
					
			elif line[:13] == "/searchbuddy " and line[13:] != '':
				query = line[13:]
				self.send(messages.Search(1, query))
				
					
			elif line[:10] == "/download " or line[:9] == "/downdir ":
				linput = None
				if line[:10] == "/download " and line[10:] != '':
					dtype = "file"
					linput = line[10:]
				elif line[:9] == "/downdir "  and line[9:] != '':
					dtype = "dir"
					linput = line[9:]
				if linput != None:
					if linput.isdigit():
						self.download_path_file(dtype, linput)
					else:
						self.help_log("Enter an Integer")
						
			elif line[:8] == "/filter " and line[8:] != '':
				
				self.sfilter=line[8:]
				if self.display_which_text=='search':
					self.search_mode()
			elif line == "/filter":
				self.sfilter=None
				if self.display_which_text=='search':
					self.search_mode()
				'''
				Browse Shares & Download from them
				'''
			elif line[:4] == "/cd " and line[4:] != '':
				self.user_shares_cd(line[4:])
				
			elif line == "/ls" or line == "/ls ":
				self.user_shares_list(line, "")
				
			elif line == "/ls -l":
				self.user_shares_list(line, "info")
				
			elif line == "/ls":
				self.user_shares_list(line, "")
			elif line == "/lsdirs":
				self.user_shares_list(line, "dirs")
				return 1
				
			elif line[:4] == "/get" and line[4:] != '':
				linput = None
				if line[:5] == "/get " and line[5:] != '':
					dtype = "file"
					linput = line[5:]
				elif line[:8] == "/getdir "  and line[8:] != '':
					dtype = "dir"
					linput = line[8:]
				if linput != None:
					if linput.isdigit():
						self.download_path_file(dtype, linput)
					else:
						self.help_log("Enter an Integer")
						
				
			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.send(messages.UserShares(user))
					if user not in self.browse_requested:
						self.browse_requested.append(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", self.browse_current)
					for item, path in self.browse_results.items():
						if re.match( search, path[1]):
							self.browse_log("Found: [" + str(item) +'] ' +path[1], self.browse_current)
						

		
			elif line[:11] == "/hidesearch":
				self.search_visible = 0
				self.help_log("Searches hidden")
				
			elif line[:11] == "/showsearch":
				self.search_visible = 1
				self.help_log("Searches made visible")
				'''
				Manage Transfers
				'''
			elif line[:8] == "/abortd " or line[:11] == "/abortdown ":
				transfer = None
				if line[:8] == "/abortd " and line[8:] != '':
					if line[8:].isdigit():
						transfer = int(line[8:])
					else:
						self.help_log("Enter an Integer")
				elif line[:11] == "/abortdown " and line[11:] != '':
					try:
						transfer = int(line[11:])
					except:
						self.help_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.help_log(username +' '+ path)
							self.help_log("Aborting download: [%s] %s" % (username, path))
							self.send(messages.TransferAbort(0, username, path))
					else:
						self.help_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.help_log("Enter an Integer")
				elif line[:9] == "/abortup " and line[9:] != '':
					try:
						transfer = int(line[9:])
					except:
						self.help_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.help_log("Aborting upload: [%s] %s" % (username, path))
							self.send(messages.TransferAbort(1, username, path))
					else:
						self.help_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.help_log("Enter an Integer")
				elif line[:10] == "/removeup " and line[10:] != '':
					try:
						transfer = int(line[10:])
					except:
						self.help_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.help_log("Removing upload: [%s] %s" % (username, path))
							self.send(messages.TransferRemove(1, username, path))
					else:
						self.help_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.help_log("Enter an Integer")
				elif line[:12] == "/removedown " and line[12:] != '':
					try:
						transfer = int(line[12:])
					except:
						self.help_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.help_log("Removing download: [%s] %s" % (username, path))
							self.send(messages.TransferRemove(0, username, path))
					else:
						self.help_log("No such transfer #" + str(transfer))
		
						
			elif line[:7] == "/retry " and line[7:] != '':
				transfer = None
				try:
					transfer = int(line[7:])
				except:
					self.help_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.help_log("Retrying download: [%s] %s" % (username, path))
							self.send(messages.DownloadFile(username, path))
					else:
						self.help_log("No such transfer #" + str(transfer))
						
			elif line[:9] == "/retryall":
				for user_path, transfer  in self.transfers["downloads"].items():
					if int(transfer[3]) in (10, 11, 12, 13, 14):
						self.send(messages.DownloadFile(transfer[1], transfer[2]))
		
			elif line[:7] == "/slots " and line[7:] != "":
				slots = None
				try:
					slots = int(line[7:])
				except:
					self.help_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.help_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[:6] == "/nick " and line[6:] != '':
				if self.username != None:
					self.send(messages.ConfigSet("server", "username", line[6:]))
			elif line == "/clearsearchs":
				self.clear_searchs()
			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]))
						
			elif line[:10] == "/clearroom":
				if line[10:] == '':
					
					self.roomlogs[self.current_room] = []
					if self.display_which_text == "chat":
						self.chat_mode()
				elif line[10:11] == ' ' and line[11:] != '':
					if line[11:] in self.roomlogs.keys():
						self.roomlogs[line[11:]] = []
						if self.display_which_text == "chat":
							self.chat_mode()
			elif line == "/aliases":
				self.help_log("Aliases:")
				for alias in mucous_config["aliases"].keys():
					self.help_log("/"+alias+": "+str(mucous_config["aliases"][alias]))
					self.help_log("")
					
			elif line[:7] == "/alias " and line[7:] != '':
				if line[7:].find(" ") != -1:
					splited = line[7:].split(" ")
					if len(splited) > 1:
						alias = splited[0]
						splited = splited[1:]
						if splited[0] != None:
							message = ''
							for i in splited:
								if i != splited[0]:
									message += ' ' +i
								else:
									message += i
							mucous_config["aliases"][alias] = str(message)
							if alias in mucous_config["aliases"].keys():
								self.help_log("Modified alias: "+alias)
							else:
								self.help_log("Created alias: "+alias)
							if "/"+alias not in self.commandlist:
								self.commandlist.append("/"+alias)
				else: 
					return 0
				
			elif line[:9] == "/unalias " and line[9:] != '':
				alias = line[9:]
				if alias in mucous_config["aliases"].keys():
					self.help_log("Deleted alias: "+alias)
					del mucous_config["aliases"][str(alias)]
					if "/"+alias in self.commandlist:
						self.commandlist.remove("/"+alias)
						
			elif line[:1] == "/":
				good = 0
				for alias in mucous_config["aliases"].keys():
					if line == '/'+alias:
						if self.display_which_text == "chat":
							if self.current_room != None:
								self.say_in_chat("chat", self.current_room, mucous_config["aliases"][alias])
								good = 1
								break
							
						elif self.display_which_text == "private":
							if self.pm_user != None:
								self.say_in_chat("private", self.pm_user, mucous_config["aliases"][alias])
								good = 1
								break
						
				if good != 1:
					return 0
				
			else:
				return 1
			
			
		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.help_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.say_in_chat("chat", self.current_room, line)
					
					
					elif self.display_which_text == "private":
						#Normal Private Messaging
						if self.pm_user != None:
							# Private Message
							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
							query = line
							if self.search_type == "globally":
								self.send(messages.Search(0, query))
								
								
							# Buddies Search
							elif self.search_type == "buddies":
								self.send(messages.Search(1, line))
								
								
					elif self.display_which_text == "browse":
						# Browse User's shares
						if mucous_config["mucous"]["browse_display_mode"] == "filesystem":
							if line[:3] == "cd ":
								self.user_shares_cd(line[3:])
								return 1
							elif line == "ls" or line == "ls ":
								self.user_shares_list(line, "")
								return 1
							elif line == "ls -l":
								self.user_shares_list(line, "info")
								return 1
							elif line == "lsdirs":
								self.user_shares_list(line, "dirs")
								return 1
							elif line[:3] == "get" and line[3:] != '':
								linput = None
								if line[:4] == "get " and line[4:] != '':
									dtype = "file"
									linput = line[4:]
								elif line[:7] == "getdir "  and line[7:] != '':
									dtype = "dir"
									linput = line[7:]
								if linput != None:
									if linput.isdigit():
										self.download_path_file(dtype, linput)
									else:
										self.help_log("Enter an Integer")
									return 1
						if line not in self.browse_requested:
							self.browse_requested.append(line)
						self.send(messages.UserShares(line))
						self.browse_log("\nStarted browsing %s's Shares" % line, self.browse_current)
						
						
					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 == "lists":
						if self.display_which_list == "buddies":
							if line not in self.config["buddies"].keys():
								self.send(messages.ConfigSet("buddies", line, "buddied by mucous"))
						elif self.display_which_list == "banned":
							if line not in self.config["banned"].keys():
								self.send(messages.ConfigSet("banned", line, "banned by mucous"))
							
						elif self.display_which_list == "ignored":
							if line not in self.config["ignored"].keys():
								self.send(messages.ConfigSet("ignored", line, "ignored by mucous"))
					elif self.display_which_text == "rooms":
						self.send(messages.JoinRoom(line))
					elif self.display_which_text == "setup":
						self.setup_input_parse(line)
			try:
				self.edit.reset()
			except:
				pass

	def setup_input_parse(self, line):
	
		if self.setup_input_mode == "interface":
			mucous_config["connection"]["interface"] = line
		elif self.setup_input_mode=="interface-password":
			mucous_config["connection"]["passw"] = line
			self.password = line
		elif self.setup_input_mode=="custom-url":
			if "$" in line:
				custom = line.split("$")
				if len(custom) > 1 and len(custom) < 3:
					mucous_config["mucous"]["url custom prefix"] = custom[0]
					mucous_config["mucous"]["url custom suffix"] = custom[1]
				elif len(custom) == 1:
					mucous_config["mucous"]["url custom prefix"] = custom[0]
					mucous_config["mucous"]["url custom suffix"] = ''
		elif self.setup_input_mode=="museek-interface-password":
			self.send(messages.ConfigSet("interfaces", "password", line))
		elif self.setup_input_mode=="museek-interface-bind":
			self.send(messages.ConfigSet("interfaces.bind", line))
		elif self.setup_input_mode=="server-host":
			self.send(messages.ConfigSet("server", "host", line))
		elif self.setup_input_mode=="server-port":
			self.send(messages.ConfigSet("server", "port", line))
		elif self.setup_input_mode=="soulseek-username":
			self.send(messages.ConfigSet("server", "username", line))
		elif self.setup_input_mode=="soulseek-password":
			self.send(messages.ConfigSet("server", "password", line))
		elif self.setup_input_mode=="download-dir":
			self.send(messages.ConfigSet("transfers", "download-dir", line))
		elif self.setup_input_mode=="incomplete-dir":
			self.send(messages.ConfigSet("transfers", "incomplete-dir", line))
		elif self.setup_input_mode=="userinfo":
			self.send(messages.ConfigSet("userinfo", "text", line))
		elif self.setup_input_mode=="userinfo-image":
			self.send(messages.ConfigSet("userinfo", "image", line))
		self.setup_mode()

	# -- v Museek Messages v

	
	def cb_login_error(self, reason):
		if reason == "INVPASS":
			self.invalidpass = 1
			self.help_log("couldn't log in: Invalid Password")
			self.connect()
		else:
			self.invalidpass = 0
			self.help_log("couldn't log in: " + reason)

	def cb_login_ok(self):
		self.invalidpass = 0
		self.helplog.append("\nLogging in...")
		
	def cb_disconnected(self):
		self.onlinestatuslog="\nClosed"
		try:
			self.onlinestatus.addstr(self.onlinestatuslog, red)
		except:
			pass
		self.onlinestatus.refresh()
		
		for room in self.joined:
			msg = ("--- Disconnected from the Museek Daemon ---")
			self.say("Status", room, '!!!!', msg)
		uploadlist = []
		self.up_transfer_numbers = {}
		self.transfers["downloads"] = {}
		self.transfers["uploads"] = {}
		for room in self.rooms.keys():
			self.rooms[room] = {}
			
		if self.display_which_text == "chat":
			self.chat_mode()
		elif self.display_which_text == "transfer":
			self.transfer_mode()
		
		
	def cb_server_state(self, state, username):

		self.username = username
		try:
			self.usernamewin.addstr('\n'+self.username[:15])
			self.usernamewin.refresh()
		except:
			pass
		
		
		self.upload_status("0")
		self.download_status("0")
		self.search_status(0)
		
		if state:
			self.helplog.append("\nConnected to Server, username: " + username)
			self.onlinestatuslog="\nOnline"

			if self.joined:
				for room in self.joined:
					msg = ("--- Connected ---")
					self.say("Status", room, '!!!!', msg)
			
		else:
			self.help_log("not connected to soulseek")

			self.onlinestatuslog="\nOffline"
			try:
				self.onlinestatus.addstr(self.onlinestatuslog)
			except:
				pass
			self.onlinestatus.refresh()

			if self.joined:
				for room in self.joined:
					msg = ("--- Disconnected from the Server ---")
					self.say("Status", room, '!!!!', msg)
	
	def cb_room_state(self, roomlist, joined, tickers):
		for rooms1, numbers in roomlist.items():
			self.all_roomlist[rooms1] = numbers
			
		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.user_status[users] = joined[room][users][0]
			self.master_roomlist[room] = roomlist

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

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

			for rooms2, ticks in alpha_list.items():
				if rooms2 == room:
					self.master_ticklist[room] = alpha_list[room]
					
			#SMALL ROOM USER PRINTOUT
			
			if self.chatdisplaymode not in ('big', 'small', "nostatuslog"):
				if len(joined[room]) <= 30:
					self.show_nick_list(room)
				else:
					self.say("List", room, '!!!!', [[str(len(joined[room])), "Normal"]])

			if mucous_config["tickers"]["tickers_enabled"] == 'yes':
				if len(joined[room]) <= 30:
					for rooms3, ticks in self.master_ticklist.items():
						if rooms3 == room:
							ttickers =[]
							ttickers = ticks.keys()
							if ttickers != []:
								self.info_log("Tickers in room: "+str(rooms3))
								ttickers.sort()
								for names in ttickers:
									self.info_log(" ["+str(names)+'] '+str(ticks[names]))
								self.info_log("")

				
		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 rooms4, tickers in mucous_config["tickers"]["rooms"].items():
			if rooms4 in self.joined:
				if self.username not in self.master_ticklist[rooms4].keys():
					self.send(messages.RoomTickerSet(rooms4, tickers))
				elif self.master_ticklist[rooms4][self.username] != tickers:
					self.send(messages.RoomTickerSet(rooms4, tickers))
			
	def cb_room_list(self, roomlist):
		for name in  roomlist:
			alpha_list[name] = roomlist[name]
		
		self.all_roomlist = {}
		
		for x, y in alpha_list.items():
			self.all_roomlist[x] = y
			
			
	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):
		try:
			if room not in self.roomlogs:
				self.roomlogs[room] = []
				self.statuslogs[room] = []
				
			self.rooms[room] = users
			if room not in self.joined:
				self.joined.append(room)
			if self.chatdisplaymode not in ('big', 'small'):
				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"]))
		except Exception, e:
			self.help_log(e)
	
	def cb_room_left(self, room):
		try:
			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)
		except Exception, e:
			self.help_log(e)	
	
	def cb_room_user_joined(self, room, user, data):
		try:
			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][len(self.roomlogs[self.current_room])-self.texth:]:
						if lines[2] == user:
							self.set_room(self.current_room)
							break
		except Exception, e:
			self.help_log(e)

	
	def cb_room_user_left(self, room, user):
		try:
			did = "left"
			what = None
			self.log_window(user, room, did, what)
			del self.rooms[room][user]
			if room in self.master_ticklist:
				if user in self.master_ticklist[room]:
					del self.master_ticklist[room][user]
			if self.display_which_text == "chat":
				if self.current_room == room:
					self.roomstatusbox()
					for lines in self.roomlogs[room][len(self.roomlogs[self.current_room])-self.texth:]:
						if lines[2] == user:
							self.set_room(room)
							break
		except Exception, e:
			self.help_log(e)
	
	def cb_peer_status(self, user, status):
		
		if status == 1:
			what = "away"
		elif status == 2:
			what = "online"
		elif status == 0:
			what = "offline"
			
		
		for rooms6 in self.rooms.keys():
			for users in self.rooms[rooms6].keys():
				if user == users:
					self.rooms[rooms6][users][0] = status
					if self.display_which_text == "chat":
						if rooms6 == self.current_room:
							self.roomstatusbox()
							
		self.user_status[user] = status
		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
			self.info_user = user
			message = info.split('\n')
			self.userinfo_log(user, message, [queue, uploads, slotsfree])
			if picture != '':
				r = file(config_dir+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:

			self.user_stats[user] = avgspeed, numdownloads, numfiles, numdirs
			self.info_log("Peer Stats for: %s \nSpeed: %s \tDownloads: %s \nFiles: %s \tDirectories: %s" % (user,  avgspeed, numdownloads, numfiles, numdirs))
			self.info_log("")
			self.stat_requested = None
			if self.display_which_text != "info":
				self.alert_status("New Stats")
			else:
				    self.display_userinfo_log()
		if user == self.username:
			self.stats = user,  avgspeed, numdownloads, numfiles, numdirs
			if self.display_which_text == "setup":
				self.setup_mode()

	def cb_private_message(self, direction, timestamp, user, message):
		if self.logging == True:
			if direction == 0:
				self.log_to_file("private", time.strftime("%d %b %Y %H:%M:%S"), user, user+" said: "+ message )
			elif direction == 1:
				self.log_to_file("private", time.strftime("%d %b %Y %H:%M:%S"), user, "You said: "+ message )
		
		if self.pm_user == None:
			self.pm_user = user
			
		if user not in self.pm_users:
			self.pm_users.append(user)
		if direction == 0:	
			pmtype = "incoming"
		elif direction == 1:
			pmtype = "outgoing"
		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)
			try:
				self.inputwin.addstr(0, self.w-10, "< ")
				self.inputwin.addstr(0, self.w-8, "Close ", cyan | curses.A_BOLD)
				self.inputwin.addstr(0, self.w-2, ">")
			except:
				pass	
			self.inputwin.refresh()
		
	def cb_server_status_set(self, status):
		self.status = status
		if status:
			stat = "Away"
		else:
			stat = "Online"
		self.onlinestatuslog="\n"+stat
		try:
			self.onlinestatus.addstr(self.onlinestatuslog)
			self.onlinestatus.refresh()
		except:
			pass
		
			
	def cb_room_ticker_set(self, room, user, message):
		what = message
		did = "ticker"
		self.log_window(user, room, did, what)
		for rooms7, tickle in self.master_ticklist.items()[:]:
			if room == rooms7:
				tickle[user] = message
				
	def cb_search_ticket(self, query, ticket):
		self.s_query[str(ticket)] = query
		self.chosen_search=str(ticket)
		self.begin_search(self.chosen_search, query)
		self.search_mode()
		
	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[str(ticket)]) + " Results from: User: "+ user, str(ticket) )

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

			result_list = str(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
				if free:
					free = 'Y'
				else:
					free = 'N'
				self.search_log("[" +str(self.search_number)+"] "+ path, str(ticket) )
				self.search_log("\tSize: "+str(size)+ " Bitrate: "+ str(bitrate) + " Length: " + str(minutes)+":"+seconds +" Queue: "+str(queue)+" Speed: "+str(speed) +" Free: " +free, str(ticket))
					#self.search_log(" ", str(ticket))
	
	def cb_user_shares(self, user, shares):
		try:
			if shares == {}:
				self.browse_log(user + " has no files shared.", "default__")
				return
			if user in self.browse_requested and shares != {}:
				if user not in self.browsed:
					self.browsed.append(user)
				self.browse_requested.remove(user)
				self.browse_current = user
				
				
				self.browse_log("Browsing files: " + user, user)
				self.browse_list_results[user] = {}
				self.browse_number[user] = 0
				
				# Debugging
				#self.help_log(shares.keys())
				#########
				sdirs = shares.keys()
				sdirs.sort()
				self.browse_current_dir=sdirs[0]
				self.set_edit_title("Browse "+user+"'s files in " + self.browse_current_dir + " ")
				
				for dirs, files in shares.items():
					
					self.browse_list_results[user][dirs] =[]
					result_list = []
					if files != {} and mucous_config["mucous"]["browse_display_mode"] == "list":
						self.browse_log("------\nDIR: " + dirs, user)
					for file, stats in files.items():
						self.browse_number[user] = self.browse_number[user] +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[user]] = result_list
						fstats = str(size), ftype, length, bitrate
						self.browse_list_results[user][dirs].append([file, fstats])
						if mucous_config["mucous"]["browse_display_mode"] == "list":
							self.browse_log('['+str(self.browse_number[user])+'] ' + " Size: " + str(size) + " Type: " + ftype + " Length: " + length + " Bitrate: " + bitrate + "\nFile: " +  file, user)
				
				
				self.browse_mode()
				if mucous_config["mucous"]["browse_display_mode"] == "filesystem":
					self.user_shares_list(line, "info")
		except Exception, e:
			self.help_log(e)
			
	def cb_transfer_state(self, downloads, uploads):
		for transfer in uploads:

			self.transfers["uploads"][(transfer.user, transfer.path)] =  [transfer.is_upload, transfer.user, transfer.path, int(transfer.state), transfer.error, transfer.filepos, transfer.filesize, transfer.rate]

		for transfer in downloads:

			self.transfers["downloads"][(transfer.user, transfer.path)] =  [transfer.is_upload, transfer.user, transfer.path, int(transfer.state), transfer.error, transfer.filepos, transfer.filesize, transfer.rate]
			
		self.upload_manager()
		self.download_manager()
		
		
 	def cb_transfer_update(self, transfer):

		if transfer.is_upload:
			self.transfers["uploads"][(transfer.user, transfer.path)] =   [transfer.is_upload, transfer.user, transfer.path, int(transfer.state), transfer.error, transfer.filepos, transfer.filesize, transfer.rate]
			self.upload_manager()
		else:
			self.transfers["downloads"][(transfer.user, transfer.path)] =  [transfer.is_upload, transfer.user, transfer.path, int(transfer.state), transfer.error, transfer.filepos, transfer.filesize, transfer.rate]
			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()

	def cb_config_set(self, domain, key, value):
		if key in self.config[domain].keys():
			self.help_log("Modified <"+key+"> in <" +domain+"> to <"+value + ">")
			self.config[domain][key] = value
		else:
			if value == '':
				self.help_log("Added <"+key+"> to <" +domain+">")
			else:
				self.help_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.help_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_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
			try:
				self.textwin.addstr('\n'+x)
				self.textwin.refresh()
			except:
				pass
			
		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 say_in_chat(self, mode, place, message):
		
		if place != None:
			if '\\n' in message:
				splited =  message.split('\\n')
				
				if len(splited) > 7:
					
					for i in range(8):
						if self.display_which_text == "chat":
							
							self.send(messages.SayRoom(place, splited[i]))
						elif self.display_which_text == "private":
							self.send(messages.PrivateMessage(1, place, splited[i]))
						
				else:
					for i in range(len(splited)):
						if self.display_which_text == "chat":
							self.send(messages.SayRoom(place, splited[i]))
						elif self.display_which_text == "private":
							self.send(messages.PrivateMessage(1, place, splited[i]))
				

			elif '\n' in message:
				splited =  message.split('\n')
				
				if len(splited) > 5:
					for i in range(5):
						if self.display_which_text == "chat":
							self.send(messages.SayRoom(place, splited[i]))
						elif self.display_which_text == "private":
							self.send(messages.PrivateMessage(1, place, splited[i]))
				else:
					for i in range(len(splited)):
						if self.display_which_text == "chat":
							self.send(messages.SayRoom(place, splited[i]))
						elif self.display_which_text == "private":
							self.send(messages.PrivateMessage(1, place, splited[i]))
			else:
				
				if self.display_which_text == "chat":

					self.send(messages.SayRoom(place, message))
				elif self.display_which_text == "private":
					self.send(messages.PrivateMessage(1, place, message))
		
	def display_userinfo_log(self):
		try:
			self.infostatswin.clear()
			if self.info_user != None:
				self.textwin.clear()
				
				for s in self.userinfolog[self.info_user][0]:
					try:
						self.textwin.addstr('\n'+s)
					except:
						pass
	
				self.textwin.refresh()
				try:
					self.infostatswin.addstr('Queue: '+str(self.userinfolog[self.info_user][1][0]))
					self.infostatswin.addstr('\nUploads: '+str(self.userinfolog[self.info_user][1][1]))
					self.infostatswin.addstr('\nSlots: '+str(self.userinfolog[self.info_user][1][2]))
				except:
					pass
				if self.info_user in self.user_stats.keys():
					try:
						self.infostatswin.addstr('\nSpeed: '+str(self.user_stats[self.info_user][0]))
						self.infostatswin.addstr('\nDown: '+str(self.user_stats[self.info_user][1]))
						self.infostatswin.addstr('\nFiles: '+str(self.user_stats[self.info_user][2]))
						self.infostatswin.addstr('\nDirs: '+str(self.user_stats[self.info_user][3]))
					except:
						pass
			self.infostatswin.refresh()
		except:
			pass
				
	def userinfo_log(self, user, message, stats):
		if self.info_user == None:
			self.info_user = user
		if user not in self.userinfolog:
			self.userinfolog[user] = []
		if user not in self.info_users:
			self.info_users.append(user)
		self.userinfolog[user] = message, stats
		if user not in self.user_stats.keys():
			self.send(messages.PeerStats(user))
		if self.display_which_text == 'info':
			self.info_mode()
			
	
				
	def send_private_message(self, user, message):
		self.send(messages.PrivateMessage(0, 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 begin_search(self, ticket, query):
		if query not in self.searchlog:
			self.searchlog[str(ticket)] = []
		
		self.search_log("Started search for: %s" % query, str(ticket))
		
	def search_log(self, s, ticket):
		if str(ticket) in self.searchlog:
			self.searchlog[str(ticket)].append("\n%s" % s)
		
			if self.display_which_text == "search":
				try:
					self.textwin.addstr(self.searchlog[str(ticket)][-1])
					self.textwin.refresh()
				except Exception, e:
					pass
				

				
	def user_shares_cd(self, line):
		if self.browse_current_dir== '' or line[0:1] == '\\' or line[1:2] == ":":
			if self.browse_current in self.browse_list_results.keys():
				if line[0:1] == '\\':
					if line in self.browse_list_results[self.browse_current].keys():
						self.browse_current_dir = line
					else:
						self.browse_log("No such directory: %s" % line[1:], self.browse_current)
				if line[1:2] == ":":
					if line in self.browse_list_results[self.browse_current].keys():
						self.browse_current_dir = line
					else:
						self.browse_log("No such directory: %s" % line, self.browse_current)
				else:
					if line in self.browse_list_results[self.browse_current].keys():
						self.browse_current_dir = line
					else:
						self.browse_log("No such directory: %s" % line, self.browse_current)
			
		elif line =='..':
			z = self.cd_dot_dot()
			if z != 0:
				self.browse_current_dir = z
			else:
				self.browse_log("No parent directory", self.browse_current)
		else:
			if self.browse_current_dir + '\\'+line in self.browse_list_results[self.browse_current].keys():
				self.browse_current_dir += '\\'+line
			else:
				self.browse_log("No such directory: %s" % line, self.browse_current)
				
		if self.browse_current == None:
			self.set_edit_title("Choose a user to Browse Shares")
		else:
			s = "Browse "+self.browse_current+"' files in "
			ls = len(s)
			self.set_edit_title(s  + self.browse_current_dir[:self.w-ls-4] + " ")
			
	def cd_dot_dot(self):
		splitit = self.browse_current_dir
		splitit = splitit.split("\\")
		s = len(splitit)
		z=''
		for r in range(s-1):
			if r == 0:
				z += splitit[r]
			else:
				z += "\\"+splitit[r]
				
		if z in self.browse_list_results[self.browse_current].keys():
			return z
		else:
			return 0
		
			
	def user_shares_list(self, line, args):
		if self.browse_current != None:
		#if self.browse_current_dir == None:
					
			currentdirlist = re.compile(self.browse_current_dir+'.*', re.DOTALL | re.I)
			a = self.browse_current_dir
			a =a.replace('\\', '\\\\')
			#self.browse_log(a)
			currentdirlimit = re.compile(a+r'\\.*\\.*', re.DOTALL | re.I)
			subdirs=[]
			other_subdirs=[]
			for dirs in self.browse_list_results[self.browse_current].keys():
				#if re.match(currentdirlimit, dirs):
				#	self.browse_log(dirs)
				if dirs.startswith(self.browse_current_dir):
					if re.match(currentdirlimit, dirs):
						pass
						#self.browse_log(dirs)
					else:
						dirs = dirs[len(self.browse_current_dir)+1:]
						subdirs.append(dirs)
				else:
					other_subdirs.append(dirs)
			subdirs.sort()
			other_subdirs.sort()
			z = self.cd_dot_dot()
			if z != 0:
				self.browse_log("ParentDir: [ .. ] ", self.browse_current)
			subdirlist = ""
			if subdirs != []:
				for dirs in subdirs:
					if str(dirs) == '':
						pass
					elif dirs == subdirs[-1]:
						subdirlist += str(dirs)
					else:
						subdirlist += str(dirs) +', '
			if subdirlist != '':
				self.browse_log("SubDirs: [ " + subdirlist +' ] ', self.browse_current)

			if other_subdirs != []:
				check = 0
				for dirs in other_subdirs:
					for x in other_subdirs:
						if dirs.startswith(x):
							if dirs != x:
								check += 1
					if check == 0:
						self.browse_log("Dir: [ " + str(dirs) +' ] ', self.browse_current)
					check = 0	
					
			for dirs, path in self.browse_list_results[self.browse_current].items():
				#self.browse_log(dirs)
				#if dirs.startswith(self.browse_current_dir):
				if self.browse_current_dir ==  dirs:
					spath = path
					spath.sort()
					for files in spath:
						bitem=0
						if args == '':
							for item, path in self.browse_results.items():
								if path[1] == dirs+'\\'+files[0]:
									bitem = item
							self.browse_log("["+str(bitem)+"] "+str(files[0]) +" " +files[1][0], self.browse_current)
						elif args == "dirs":
							pass
						elif args == 'info':
							for item, path in self.browse_results.items():
								if path[1] == dirs+'\\'+files[0]:
									bitem = item
							if files[1][2]!='': time = " Time:" + files[1][2]
							if files[1][3]!='': rate= " "+files[1][3]+" Kbps"
							self.browse_log("["+str(bitem)+"] "+str(files[0]), self.browse_current)
							self.browse_log("\tSize: " + files[1][0] + time + rate, self.browse_current)
							
							
							
							#self.browse_log("Found: [" + str(item) +'] ' +path[1])

	
	#Add new/replace old keys to self.config
	def mod_config(self, changetype, username, value):
		if changetype == "buddy":
			if username not in self.config["buddies"].keys():
				self.send(messages.ConfigSet("buddies", username, "buddied by mucous"))
		elif changetype == "unbuddy":
			if username in self.config["buddies"].keys():
				self.send(messages.ConfigRemove("buddies", username))
			else:
				self.help_log("User not in buddy list: %s" % username)
		elif changetype == "ban":
			if username not in self.config["banned"].keys():
				self.send(messages.ConfigSet("banned", username, "banned by mucous"))
		elif changetype == "unban":
			if username in self.config["banned"].keys():
				self.send(messages.ConfigRemove("banned", username))
			else:
				self.help_log("User not in ban list: %s" % username)
		elif changetype == "ignore":
			if username not in self.config["ignored"].keys():
				self.send(messages.ConfigSet("ignored", username, ""))
				self.help_log("Ignored: %s" % username)
		elif changetype == "unignore":
			if username in self.config["ignored"].keys():
				self.send(messages.ConfigRemove("ignored", username))
			else:
				self.help_log("User not in ignore list: %s" % username)
		elif changetype == "autojoin":
			room = username
			if room not in self.config["autojoin"].keys():
				self.send(messages.ConfigSet("autojoin", room, ""))
			else:
				self.help_log("Room already autojoined: %s" % room)

		elif changetype == "unautojoin":
			room = username
			if room in self.config["autojoin"].keys():
				self.send(messages.ConfigRemove("autojoin", room))
			else:
				self.help_log("Room not autojoined: %s" % room)
				
		
	def display_config_update(self, domain):
		if domain in ("buddies", "banned", "ignored", "autojoin"):
			if self.display_which_text == "lists":
				if self.display_which_list == "buddies":
					self.buddy_mode()
				elif self.display_which_list == "banned":
					self.ban_mode()
				elif self.display_which_list == "ignored":
					self.ignore_mode()
			elif self.display_which_text == "chat":
				self.roomstatusbox()
		elif domain in ("clients", "transfers", "server", "interfaces", "interfaces.bind") and self.display_which_text == "setup":
			self.setup_mode()
		
	def download_path_file(self, dtype, number):
		try:
			number = int(number)
			if self.display_which_text=="search":
				if self.search_results != {}:
					if self.search_results[number] != None:
						user = self.search_results[number][1]
						path = self.search_results[number][5]
					else:
						self.help_log("No such file")
				else:
					self.help_log("You need to search, first ;)")
			elif self.display_which_text=="browse":
				if self.browse_results != {}:
					if self.browse_results[number] != None:
						user = self.browse_results[number][0]
						path = self.browse_results[number][1]
					else:
						self.help_log("No such file")
				else:
					self.help_log("You need to browse, first ;)")
			if user != None and path != None:
				if dtype == "file":
					self.send(messages.DownloadFile(user, path))
					self.help_log("Try to Download file: %s from %s" % (path, user))
				elif dtype == "dir":
					r = path.split('\\')
					directory = ''
					for s in r:
						if s != r[-1]:
							directory += s+'\\'
					self.send(messages.GetFolderContents(user, directory))
					self.help_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.help_log("Auto-Buddied: %s" % user)
				
			
		except Exception, e:
			self.help_log(e)
	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 = {}
			userlist = self.transfers["uploads"].keys()
			userlist.sort()
			
			#for users, vals in self.transfers["uploads"].items():
			for users in userlist:
				vals = self.transfers["uploads"][users]
				upload, user, path, status, error, filepos, filesize, rate = vals[0], vals[1], vals[2], vals[3], vals[4], vals[5], vals[6], 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 >= 1073741824:
							filefrmt = str(filesize/1024/1024/1024) +" Gb"
						elif filesize >= 1048576 and filesize <= 1073741824:
							filefrmt = str(filesize/1024/1024) +" Mb"
						elif filesize < 1048576 and filesize >= 1024:
							if filesize/1024 > 1000:
								filefrmt = str(filesize/1024) +"Kb"
							else:
								filefrmt = str(filesize/1024) +" Kb"
						elif filesize < 1024 and filesize > 0:
							if filesize/1024 > 1000:
								filefrmt = str(filesize) +"b"
							else:
								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 = {}
					if self.trans_speed_display == True:
						ratefrmt =''
						if rate >= 1048576 and rate <= 1073741824:
							ratefrmt = str(rate/1024/1024) +"MB"
						elif rate < 1048576 and rate >= 1024:
							ratefrmt = str(rate/1024) +"KB"
						elif rate < 1024 and rate > 0:
							ratefrmt = str(rate) +"B"
						elif rate == 0:
							ratefrmt = str(rate) +"B"
						while len(ratefrmt) < 5:
							ratefrmt = ' '+ratefrmt

						ea = "\n[%s|%s|%s] [%s]%s%s%s%s" % (str(ae), ratefrmt, filefrmt , user[:9], spacer, states[status], spacer2, path[-self.w+51:])
					else:
						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()
			try:
				if self.trans_speed_display == True:
					self.upwin.addstr("[Numb|Speed| Size ] [Username]\t[Status]\t[Path]", green)
				else:
					self.upwin.addstr("[Numb|Perc| Size ] [Username]\t[Status]\t[Path]", green)
			except Exception, e:
				self.help_log(e)
				
			
			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)
					try:
						self.upwin.addstr(transfers[0], attr)
					except:
						pass
			else:
				try:
					self.upwin.addstr("\nNo transfers in this category, hit INSERT to switch to another.")
				except:
					pass
			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 = {}
			userlist = self.transfers["downloads"].keys()
			userlist.sort()
			1
			for users in userlist:
				vals = self.transfers["downloads"][users]
				download, user, path, status, error, filepos, filesize, rate = vals[0], vals[1], vals[2], vals[3], vals[4], vals[5], vals[6], 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 >= 1073741824:
							filefrmt = str(filesize/1024/1024/1024) +" Gb"
						elif 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 += " "
					
					if self.trans_speed_display == True:
						ratefrmt =''
						if rate >= 1048576 and rate <= 1073741824:
							ratefrmt = str(rate/1024/1024) +"MB"
						elif rate < 1048576 and rate >= 1024:
							ratefrmt = str(rate/1024) +"KB"
						elif rate < 1024 and rate > 0:
							ratefrmt = str(rate) +"B"
						elif rate == 0:
							ratefrmt = str(rate) +"B"
						while len(ratefrmt) < 5:
							ratefrmt = ' '+ratefrmt

						ea = "\n[%s|%s|%s] [%s]%s%s%s%s" % (str(ae), ratefrmt, filefrmt , user[:9], spacer, states[status], spacer2, path[-self.w+51:])
					else:
						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()
			try:
				if self.trans_speed_display == True:
					self.downwin.addstr("[Numb|Speed| Size ] [Username]\t[Status]\t[Path]", green)
				else:
					self.downwin.addstr("[Numb|Perc| Size ] [Username]\t[Status]\t[Path]", green)
			except:
				pass
			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)
					try:
						self.downwin.addstr(transfers[0], attr)
					except:
						pass
			else:
				try:
					self.downwin.addstr("\nNo transfers in this category, hit INSERT to switch to another.")
				except:
					pass
			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] = []
			alphanicks=[]
			#for username in self.rooms[room].keys():
			alphanicks = self.rooms[room].keys()
			alphanicks.sort()
			for username in alphanicks:
				#for username in self.rooms[room]:
				#print self.rooms[room][username][3]
				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"])
				self.colorednicks[room].append([" ["+str(self.rooms[room][username][3])+"]", "Normal"])
				if username is not alphanicks[-1]:
					self.colorednicks[room].append([", ", "NotLast"])
			mtype = "List"
			user = "!!!!"
			msg = self.colorednicks[room]
			self.say("List", room, '!!!!', msg)
			
	def close_userinfo(self, user):
		if user in self.info_users:
			self.info_users.remove(user)
		if self.info_users != []:
			for users in self.info_users:
				self.info_user = users
				break
		else:
			self.info_user = None
		if self.display_which_text == 'info':
			self.info_mode()
			
	def close_private_chat(self, user):
		if user in self.pm_users:
			self.pm_users.remove(user)
		if self.pm_users != []:
			for users in self.pm_users:
				self.pm_user = users
				break
		else:
			self.pm_user = None
		if self.display_which_text == 'private':
			self.private_mode()
			
	def close_search(self, ticket):
		if ticket in self.s_query.keys():
			del self.s_query[ticket]
		if ticket in self.searchlog:
			del self.searchlog[ticket]
		if self.s_query.keys() != []:
			self.chosen_search = self.s_query.keys()[0]
		else:
			self.chosen_search = "default__"
		self.search_mode()
		
	def close_browse(self, user):
		if user in self.browsed:
			self.browsed.remove(user)
		if user in self.browselog:
			del self.browselog[user]
		if self.browsed != []:
			if self.browse_current == user:
				self.browse_current = self.browsed[0]
		else:
			self.browse_current = "default__"
		self.browse_mode()
		
	def clear_searchs(self):
		self.s_query = {}
		self.searchlog = {}
		self.searchlog["default__"] = ["Global search commands:\n/searchfor <query>\n/searchbuddy <query>\n/download <number>\nOr, type in the query, below."]
		self.search_number = 0
		self.chosen_search="default__"
		self.search_mode()
		
	# 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
			try:
				self.inputwin.addstr(0, self.w-14, "< ")
				self.inputwin.addstr(0, self.w-12, "Next Room", cyan | curses.A_BOLD)
				self.inputwin.addstr(0, self.w-2, ">")
				# Clean screen
				self.inputwin.refresh()
			except:
				pass
			
			try:
				self.editwin.refresh()
				self.textwin.clear()
			except:
				pass
			
			# Display chat log
			if self.roomlogs[self.current_room] != None:
				self.wrap_text(self.roomlogs[self.current_room], 1)
				
			# 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 
			try:
				if self.chatroomscroll == "roomchat":
					self.chatwin.attron(green)
				else:
					self.chatwin.attroff(green)
				self.chatwin.border()
				self.drawchatwindow()
				
				self.chatwin.refresh()
			except:
				pass
		try:
			self.textwin.refresh()
		except:
			pass
		
	def wrap_text(self, wrap, clipped):
		display = []
		if clipped != 0:
			if len(self.roomlogs[self.current_room]) > self.chath-2:
				numlines = abs(len(self.roomlogs[self.current_room])-self.chath)
			else:
				numlines = 0
		else:
			numlines = 0
		for lines in wrap[numlines:]:
			length = len(lines[3])+len(lines[2])+13
			sub = len(lines[2])-12
			if length >= self.textw:
				display.append([lines[0], lines[1], lines[2], lines[3][:self.textw-sub]])
				display.append([lines[0], '', '', lines[3][self.textw-sub:(self.textw*2)-sub]])
				
				if length >= self.textw*2:
					display.append([lines[0], '', '', lines[3][(self.textw*2)-sub:(self.textw*3)-sub]])
					
					if length >= self.textw*3:
						display.append([lines[0], '', '', lines[3][(self.textw*3)-sub:(self.textw*4)-sub]])
						
						if length >= self.textw*4:
							display.append([lines[0], '', '', lines[3][(self.textw*4)-sub:(self.textw*5)-sub]])
							
							if length >= self.textw*5:
								display.append([lines[0], '', '', lines[3][(self.textw*5)-sub:(self.textw*6)-sub]])
								if length >= self.textw*6:
									display.append([lines[0], '', '', lines[3][(self.textw*6)-sub:]])


			else:
				display.append(lines)
				
		if len(display) > self.texth:
			numlines = abs(len(display)-self.texth)
		else:
			numlines = 0
		
		if self.scrollup != 0:
			for lines in display[0:]:
				if lines == display[0]:
					self.display_room_text(self.current_room, lines, 1)
				else:
					self.display_room_text(self.current_room, lines, 0)
		else:
			for lines in display[numlines:]:
				if lines == display[numlines]:
					self.display_room_text(self.current_room, lines, 1)
				else:
					self.display_room_text(self.current_room, lines, 0)
			
	def set_edit_title(self, r):
		self.current = r
		self.inputwin.clear()
		self.inputwin.border()
		if self.current:
			try:
				self.inputwin.addstr(0, 2, "< ")
				self.inputwin.addstr(0, 4, self.current, cyan | curses.A_BOLD)
				self.inputwin.addstr(0, 4+len(self.current), " >")
			except:
				pass
		try:
			self.inputwin.refresh()
			self.editwin.refresh()
		except:
			pass
		
	# 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
			try:
				self.chatwin.addstr(self.h-6, self.w-18, "< "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
				self.chatwin.refresh()
			except:
				pass
			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
			try:
				self.chatwin.addstr(self.h-6, self.w-18, "< "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
				self.chatwin.refresh()
			except:
				pass
			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 = {}
		if "buddies" in self.config:
			for users in self.config["buddies"].keys():
				usercompletionlist[users] = 0
		if "banned" in self.config:
			for users in self.config["banned"].keys():
				usercompletionlist[users] = 0
		if "ignored" in self.config:
			for users in self.config["ignored"].keys():
				usercompletionlist[users] = 0
		if self.rooms.keys() != []:
			for room in self.rooms.keys():
				for users in  self.rooms[room].keys():
					usercompletionlist[users] = 0
		if self.transfers["uploads"].keys() != []:
			for userpath, values in self.transfers["uploads"].items():
				usercompletionlist[values[1]] = 0
		if self.transfers["downloads"].keys() != []:
			for userpath, values in self.transfers["downloads"].items():
				usercompletionlist[values[1]] = 0
		if self.display_which_text == "browse":
			if self.browse_current != None:
				if self.browse_current in self.browse_list_results:
					for dirs in self.browse_list_results[self.browse_current].keys():
						usercompletionlist[dirs] = 0
		for values in self.commandlist:
			usercompletionlist[values] = 0
			
		if usercompletionlist.keys() != []:
			self.tab_complete_list = usercompletionlist.keys()
			self.tab_complete_list.sort()
		else:
			self.tab_complete_list=[]
		
	# Rebuild Ignorelist from self.config
	def ignorelist(self):
		if self.config !=  {}:
			if "ignored" in self.config.keys():
				self.ignorelog = []
				alpha_list = SortedDict()
				for keyname, keyvalue in self.config["ignored"].items():
					alpha_list[keyname] = keyvalue
				try:
					self.chatwin.addstr(self.h-6, self.w-18, "< "+str(len(alpha_list.keys()))+" >", green | curses.A_BOLD)
					self.chatwin.refresh()
				except:
					pass
				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"):
			if self.display_which_text == "chat":
				if self.chatroomscroll == "roomchat":
					selected_log = self.roomlogs[self.current_room]
				elif self.chatroomscroll == "roombox":
					selected_log = self.roomboxlist[self.current_room]
			elif self.display_which_text == "help":
				selected_log = self.helplog
			elif self.display_which_text == "search":
				selected_log = self.searchlog[self.chosen_search]
			elif self.display_which_text == "info":
				if self.info_user != None:
					
					selected_log = self.userinfolog[self.info_user][0]
				else:
					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[self.browse_current]
			elif self.display_which_text == "lists":
				if self.display_which_list == "buddies":
					selected_log = self.buddylog
				elif self.display_which_list == "banned":
					selected_log = self.banlog
				elif self.display_which_list == "ignored":
					selected_log = self.ignorelog
			elif self.display_which_text == "rooms":
				selected_log = self.all_roomlist
			
				
			if key == "KEY_UP":	
				# SCROLLING UP
				# Redisplay chat log with one less line every time the Up key is pressed
				self.scrollup_last = self.scrollup
				self.scrollup = self.scrollup -1
				self.textwin.scrollok(0)
			elif key == "KEY_DOWN":
				#SCROLLING DOWN
				self.textwin.scrollok(1)
 				if self.scrollup_last == 1:
 					if self.display_which_text not in ("lists", "rooms") and self.chatroomscroll != "roombox":
 						return
				self.scrollup_last = self.scrollup
				self.scrollup = self.scrollup +1
			elif key == "KEY_PPAGE":
				self.textwin.scrollok(0)
				self.scrollup_last = self.scrollup
				self.scrollup = self.scrollup - self.texth
			elif key == "KEY_NPAGE":
				self.textwin.scrollok(1)
				if self.scrollup_last == 0:
					return
				self.scrollup_last = self.scrollup
				self.scrollup = self.scrollup + self.texth
			log_scroll = []
			if selected_log != None:
				
				if self.display_which_text != "rooms":
					log_scroll = selected_log
					#for line in selected_log:
					#	log_scroll.append(line)
					
				if self.display_which_text == "rooms":
					for line in selected_log.keys():
						if self.all_roomlist[line] >= mucous_config["mucous"]["roomlistminsize"]:
							log_scroll.append(line)
					self.window_height = self.texth
					log_scroll.sort()
					
				elif self.display_which_text == "chat":
					if self.chatroomscroll  == "roombox":
						if self.chatdisplaymode != "nothing":
							if self.chatdisplaymode == "big":
								self.window_height = self.h-7
							elif self.chatdisplaymode == "small":
								self.window_height = 4
						else:
							self.window_height = 4

					else:
						self.window_height = self.texth
					
				elif self.display_which_text in ("private", "info", "search", "browse", "help"):
					self.window_height = self.texth
					
					if self.display_which_text == "search":
						# Filter search while browsing
						if self.sfilter != None:
							s = []
							for x in log_scroll:
								good =0
								if self.sfilter in x:
									good =1
								if good == 1:
									s.append(x)
							log_scroll = s
								
				else:
					self.window_height = self.texth
					self.textwin.scrollok(1)
				#self.chatwin.addstr(0, 19, " | |    ")
				#self.chatwin.addstr(0, 19, "%d|%d|%d" %(len(log_scroll), self.window_height, self.scrollup))
				#self.chatwin.refresh()
				if len(log_scroll) + 2 < self.window_height:
					self.scrollup = 0
					return
				
				if self.display_which_text not in ("lists", "rooms") and self.chatroomscroll != "roombox":

					if len(log_scroll) <=self.window_height:
						self.scrollup=0
					else:
						if abs(self.scrollup) >= len(log_scroll):
							self.scrollup = -self.window_height +len(log_scroll)
						
						if 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
					if self.scrollup > 0:
						self.scrollup_last = 1
						self.scrollup = 0

					end = len(log_scroll) +self.scrollup
					start = end -self.window_height
					if start <= 0:
						start = 0
					self.start = start
					self.end = end
					
				else:
					
					if self.scrollup > len(log_scroll)  - self.window_height:
						self.scrollup = len(log_scroll)  - self.window_height 
					if self.scrollup < 0:
						self.scrollup = 0
					
					self.end = end = self.scrollup + abs(self.window_height)
					start = self.scrollup
					if start <= 0:
						start = 0
						
					self.start = start
					self.end = end
				
				if self.display_which_text == "chat":
					#start -= 1
					if self.chatroomscroll  == "roomchat":
						self.textwin.clear()
						self.wrap_text(log_scroll[start:end], 0)
						self.drawchatwindow()
						self.textwin.refresh()
						
					elif  self.chatroomscroll  == "roombox":
						self.roomstatuswin.clear()
						for lines in log_scroll[start:end]:
							self.showroomstatusbox(lines)
					
				elif self.display_which_text == "rooms":
					self.textwin.clear()
					for lines in log_scroll[start:end]:
						self.display_room_list_mode(lines)
					self.textwin.refresh()
					
				elif self.display_which_text == "lists":

					self.textwin.clear()
					for lines in log_scroll[start:end]:
						self.display_list_text(lines)
					self.textwin.refresh()
					
				elif self.display_which_text in ("info", "private"):
					self.textwin.clear()
					for lines in log_scroll[start:end]:
						try:
							if self.display_which_text == "info" and self.info_user == None or self.display_which_text == "private":
								try:
									self.textwin.addstr(lines)
								except:
									pass
							else:
								try:
									self.textwin.addstr('\n'+lines)
								except:
									pass
							
						except: 
							pass
					self.textwin.refresh()	
					
				elif self.display_which_text == "search":
					self.textwin.clear()
					for lines in log_scroll[start:end]:
						self.display_search(lines)
					self.textwin.refresh()
				else :
					if  len(log_scroll) > self.window_height:
						self.textwin.clear()
						for lines in log_scroll[start:end]:
							try:
								self.textwin.addstr(lines)
							except:
								pass
						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":	
				self.scrollup = self.scrollup -1
			elif key == "KEY_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.firsttab ==0:
			self.completion_list()
		if self.tab_complete_list !=[]:
			
			if self.display_which_text in ("rooms", "chat", "lists", "info", "private", "browse", "transfer", "setup", "search"):
				if self.firsttab ==0:
					self.keepit=[]
					if self.display_which_text == "rooms":
						for words in self.all_roomlist.keys():
							if words.startswith(word[0:1]):
								self.keepit.append(words)
					else:
						for words in self.tab_complete_list:
							if word[0:1] == '/':
								if words.startswith(word[0:2]):
									self.keepit.append(words)
								# Be more picky with /commands
							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 len(split_line[-1]) > 1:
						x = len(split_line[-1])
					else:
						x = 1
					# WOO HOO
					# The above x fixes the previously broken tabbing
					if words.startswith(split_line[-1][0:x]) 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
		return self.listline, self.firsttab
							
	def history(self, key, line, history_count):
		self.history_count = history_count
		if line not in self.historylog and line !='':
			self.historylog.append(line)
		if key == "KEY_UP":
			self.history_count += 1
		if key == "KEY_DOWN":
			self.history_count -= 1

		last_line = len(self.historylog) -1 - self.history_count
		if last_line < 0:
			last_line = len(self.historylog) -1
			self.history_count = 0
		elif last_line > len(self.historylog) -1:
			last_line = len(self.historylog) -1
			self.history_count += 1
		line = self.historylog[ last_line]
		
		return line, self.history_count

	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"):
			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.list_mode()
		elif key == "KEY_F(8)":
			self.rooms_mode()
		elif key == "KEY_F(9)":
			self.setup_mode()
		elif key == "KEY_F(10)":
			self.help_mode()
		elif key == chr(10) or key == "KEY_ENTER":
			if line not in self.historylog and line !='':
				self.historylog.append(line)

		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()
			if self.display_which_text == "chat":
				if self.chatroomscroll == "roomchat":
					if self.chatdisplaymode != "nothing":
						self.chatroomscroll = "roombox"
				elif self.chatroomscroll == "roombox":
					self.chatroomscroll = "roomchat"
				self.chat_mode()
			if 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()
		elif key == "KEY_MOUSE":
			(id,x,y,z,event)=curses.getmouse()
			#self.help_log(str(id)+" "+str(x)+" "+str(y)+" "+str(z)+" "+str(event))
#			self.help_log("%d %d %d %d %d" % (id, x, y, z,event))
# 1Chat 2Private 3Transfers 4Search 5Info 6Browse 7Users 8Rooms 9Setup 10Help
			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 < 35:
					self.search_mode()
				elif x >= 35 and x < 41:
					self.info_mode()
				elif x >= 41 and x < 49:
					self.browse_mode()
				elif x >= 49 and x < 56:
					self.list_mode()
				elif x >= 56 and x < 63:
					self.rooms_mode()
				elif x >= 63 and x < 70:
					self.setup_mode()
				elif x >= 70 and x < 76:
					self.help_mode()

			if self.display_which_text == "chat":
				# Clickable room switch
				if y == self.h-3 or y == self.h-4:
					if x >=self.w-14 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 private message switch
				if self.pm_user != None:
					if y in (2, 3, 4):
						if len(self.pm_users) > 1:
							s = self.pm_users.index(self.pm_user)
							self.pm_user = self.pm_users[s-1]
							self.start_pm(self.pm_user)
							self.private_mode()
							
					if y == self.h-3 or y == self.h-4:
						if x >=self.w-10 and x < self.w-1:
							self.close_private_chat(self.pm_user)
			elif self.display_which_text == "browse":
				if y in (2, 3, 4):
					if len(self.browsed) >= 1:
						if self.browse_current == "default__":
							self.browse_current = self.browsed[0]
						s = self.browsed.index(self.browse_current)
						self.browse_current = self.browsed[s-1]
						sdirs =  self.browse_list_results[self.browse_current].keys()
						sdirs.sort()
						self.browse_current_dir=sdirs[0]
						
						self.browse_mode()
				
				elif y in (5, 6, 7):
					if x >=self.w-14:
						if mucous_config["mucous"]["browse_display_mode"]=="filesystem":
							mucous_config["mucous"]["browse_display_mode"]="list"
						elif mucous_config["mucous"]["browse_display_mode"]=="list":
							mucous_config["mucous"]["browse_display_mode"]="filesystem"
						self.browse_mode()
						
				elif y in ( self.h-3, self.h-4, self.h-5):
					if self.browse_current != "default__":
					
						if x >=self.w-19-2-16 and x < self.w-12:
							
							self.browse_current="default__"
							self.browse_mode()
							
						elif x >=self.w-10 and x < self.w-1:
							self.close_browse(self.browse_current)
							
			elif self.display_which_text == "info":
				# Clickable private message switch
				
				if y in (2, 3, 4):
					if len(self.info_users) >= 1:
						if self.info_user == None:
							self.info_user = self.info_users[0]
						s = self.info_users.index(self.info_user)
						self.info_user = self.info_users[s-1]
						self.display_userinfo_log()
						self.info_mode()
				if self.info_user != None:
					if y in ( self.h-3, self.h-4, self.h-5):
						if x >=self.w-19-2-16 and x < self.w-12:
							
							self.info_user=None
							self.info_mode()
						elif x >=self.w-10 and x < self.w-1:
							self.close_userinfo(self.info_user)
			
			elif self.display_which_text == "search":
				if y in (2, 3, 4):
					if len(self.s_query.keys()) >= 1:
						if self.chosen_search == "default__":
							self.chosen_search = self.s_query.keys()[0]
						s = self.s_query.keys().index(self.chosen_search)
						self.chosen_search = self.s_query.keys()[s-1]
						self.search_mode()

				elif y ==self.h-4:
					if x >= 10 and x <= 20:
						# Toggle type of search
						if self.search_type == "globally":
							self.search_type = "buddies"
						elif self.search_type == "buddies":
							self.search_type = "globally"
						self.search_mode()
						
				elif y in ( self.h-3, self.h-4, self.h-5):
					if self.chosen_search != "default__":
						if x >=self.w-19-2-16 and x < self.w-12:
							self.chosen_search="default__"
							self.search_mode()
						elif x >=self.w-10 and x < self.w-1:
							self.close_search(self.chosen_search)
							
			elif self.display_which_text == "setup":
				if y in (0, 1):
					if x >=1 and x <=16:
						self.setup_display_mode="mucous"
					elif x >=20 and x <=35:
						self.setup_display_mode="museek"
					self.setup_mode()
				elif y in (2, 3, 4):
					if x >=1 and x <=35:
						if self.setup_display_mode=="museek":
							self.setup_input_mode="server-host"
						elif self.setup_display_mode=="mucous":
							self.setup_input_mode="interface"
						self.setup_mode()
					if x >=36 and x <=64:
						if self.setup_display_mode=="museek":
							self.setup_input_mode="soulseek-username"
							self.setup_mode()
				elif y in (5, 6, 7):
					if self.setup_display_mode=="museek":
						if x >=36 and x <=64:
							self.setup_input_mode="soulseek-password"
						elif x >=1 and x <=35:	
							self.setup_input_mode="museek-interface-password"
						self.setup_mode()
					elif self.setup_display_mode=="mucous":
						if x >=1 and x <=35:
							self.setup_input_mode="interface-password"
						self.setup_mode()
				elif y in (8, 9, 10):
					if x >=1 and x <=16:
						#Buddies-only
						if self.setup_display_mode=="museek":
							if "transfers" in self.config:
								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 self.setup_display_mode=="mucous":
							if mucous_config["tickers"]["tickers_enabled"] == 'no':
								mucous_config["tickers"]["tickers_enabled"] = 'yes'
								
							elif mucous_config["tickers"]["tickers_enabled"] == 'yes':
								mucous_config["tickers"]["tickers_enabled"] = 'no'
							self.setup_mode()
					elif x >=17 and x <=31:
						if self.setup_display_mode=="museek":
							#buddy-privs
							if "transfers" in self.config:
								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 self.setup_display_mode=="mucous":
							# Minimum size of rooms displayed in room list
							if x >=17 and x <=23:
								mucous_config["mucous"]["roomlistminsize"] -= 1
							elif x >=24 and x <=31:
								mucous_config["mucous"]["roomlistminsize"] += 1
							if mucous_config["mucous"]["roo