~muelnet/heybuddy/pulltimes

'''

this is a part of the heybuddy project

copyright 2010 jezra lickter http://www.jezra.net

'''

import gtk

import gobject

from DentScroller import DentScroller

from Dent import Dent

try:

	import gtkspell

	has_gtkspell=True

except:

	has_gtkspell=False

from PlatformSpecific import has_hildon

#make a fake enumeration

DENT,MENTION,DIRECT,CONVERSATION,USER,GROUP,ACCOUNT,ABOUT = range(8)

STATUS_MESSAGE,ERROR_MESSAGE = range(2)

class MainWindow(gtk.Window,gobject.GObject):

	__gsignals__ = {

		'update-status': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

							 (gobject.TYPE_STRING,)

			),

		'get-conversation': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

							 (gobject.TYPE_INT,)

			),

		'show-user': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

							 (gobject.TYPE_STRING,)

			),

		'show-group': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

							 (gobject.TYPE_STRING,)

			),

		'notebook-page-change': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

							 (gobject.TYPE_INT,gobject.TYPE_INT)

			),

		'follow-user' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				(gobject.TYPE_STRING,gobject.TYPE_BOOLEAN)

			),

		'join-group' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				(gobject.TYPE_STRING,gobject.TYPE_BOOLEAN)

			),

		'add-tag-filter': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

						 (gobject.TYPE_STRING,)

			),

		'remove-tag-filter' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				(gobject.TYPE_STRING,)

			),

		'add-user-filter': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

						 (gobject.TYPE_STRING,)

			),

		'remove-user-filter' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				(gobject.TYPE_STRING,)

			),

		'add-group-filter': (

			gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,

						 (gobject.TYPE_STRING,)

			),

		'remove-group-filter' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				(gobject.TYPE_STRING,)

			),

		'clear-respond-to-id' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				()

			),

		'quit' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				()

			),

		'window-to-tray' : (

			gobject.SIGNAL_RUN_FIRST,gobject.TYPE_NONE,

				()

			)		 

	}

	def __init__(self,app_name,version,branch):

		gtk.Window.__init__(self,gtk.WINDOW_TOPLEVEL)	

		gobject.GObject.__init__(self)

		self.textlimit = 140 #this is default

		self.last_clicked_label=None

		self.do_submit=False

		self.is_fullscreen=False

		self.set_title(app_name)

		self.set_default_size(500,500)

		self.notebook_current_page=DENT

		self.string_update_textview=_("Update Status")

		self.string_direct_message=_("Direct Message to")

		self.string_status_frame=self.string_update_textview

		self.conversation_page=None

		self.pre_conversation_page=None

		self.user_page=None

		self.pre_user_page=None

		self.pre_group_page=None

		self.is_direct_message_mode=False

		#create an accellerator group for this window

		accel = gtk.AccelGroup()

		#add the ctrl+q to quit

		accel.connect_group(gtk.keysyms.q, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.quit )

		#add ctrl+w to set tray app and close to tray

		accel.connect_group(gtk.keysyms.w, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.window_to_tray )

		#add the ctrl+c to copy

		accel.connect_group(gtk.keysyms.c, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.copy )

		#add the ctrl+Page_Up and ctrl Page_Down to notebook focus

		accel.connect_group(gtk.keysyms.Page_Up, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.focus_notebook )

		accel.connect_group(gtk.keysyms.Page_Down, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.focus_notebook )

		#set focus for ctrl+u		

		accel.connect_group(gtk.keysyms.u, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.focus_update_textview )

		#set focus for ctrl+l		

		accel.connect_group(gtk.keysyms.l, gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, self.focus_update_textview)

		#lock the group

		accel.lock()

		#add the group to the window

		self.add_accel_group(accel)

		''' make the GUI stuff '''

		#start with vbox

		self.main_vbox = gtk.VBox()

		#add the vbox to the self

		self.add(self.main_vbox)

		#make a notebook

		self.notebook = gtk.Notebook()

		#pack the note book in the vbox

		self.main_vbox.pack_start(self.notebook)

		#make the update status area

		self.update_textbuffer = gtk.TextBuffer()

		self.update_textview = gtk.TextView(self.update_textbuffer)

		#the text view needs to be multiline

		self.update_textview.set_wrap_mode(gtk.WRAP_WORD_CHAR)

		#try and add spell checking to the textview

		if has_gtkspell:

			#what if there is no aspell library?

			try:

				self.spell = gtkspell.Spell(self.update_textview)

				self.has_spell_library=True

			except Exception:

				#bummer

				self.has_spell_library=False

				print Exception.message

		#add a shadowed frame around the textview

		tvframe = gtk.Frame();

		tvframe.set_shadow_type(gtk.SHADOW_IN)

		tvframe.add(self.update_textview)

		#what happens when text is inserted in the buffer?

		self.update_textbuffer.connect('insert-text', self.update_textbuffer_insert)

		#what happens when the buffer is changed?

		self.update_textbuffer.connect('changed', self.update_textbuffer_changed)

		update_frame = gtk.Frame()

		self.update_status_label = gtk.Label(self.string_status_frame)

		update_frame.add(tvframe)

		update_frame.set_label_widget(self.update_status_label)

		#make an hbox for the update frame and throbber

		update_hbox = gtk.HBox(False)

		self.throbber = gtk.Image()

		update_hbox.pack_start(update_frame,True,True)

		update_hbox.pack_start(self.throbber,False,False)

		self.main_vbox.pack_start(update_hbox,False,False,0)

		#make a message label that we might need to display to the user

		self.message_label = gtk.Label()

		self.main_vbox.pack_start(self.message_label,False,False,0)

		#check for a keypress

		self.connect('key-press-event',self.keypressed)

	def keypressed(self,widget,event):

		if event.keyval == 65475:

			self.toggle()

	def toggle(self):

		if self.is_fullscreen :

			self.unfullscreen()

			self.is_fullscreen=False

		else:

			self.fullscreen()

			self.is_fullscreen=True

	def run(self):

		#we don't want any signals until the app is running

		self.notebook.connect('switch-page', self.notebook_page_switch )

	def show_some(self):

		self.show_all()

		#hide *some* stuff

		self.message_label.hide()

	def add_notebook_page(self,widget,title):

		self.notebook.append_page(widget,title)

	def set_notebook_page(self,index):

		self.notebook.set_current_page(index)

	def get_notebook_index(self):

		return self.notebook.get_current_page()

	def add_dent(self,data,target_index,is_conv=False,conv_backwards=False):

		d = Dent(data)

		d.connect('reply-clicked', self.reply_clicked)

		d.connect('view-conversation-clicked', self.view_conversation)

		d.connect('user-clicked', self.view_user)

		d.connect('text-label-clicked',self.dent_text_clicked)

		d.connect('redent-clicked',self.redent_clicked)

		#add this to the dent it's targeting

		target = self.get_target_scroller(target_index)

		target.add_dent(d,is_conv,conv_backwards)	

		#return the dent

		return d

	#filters

	def add_tag_filter(self,filterframe,tag):

		self.emit('add-tag-filter',tag)

	def remove_tag_filter(self,filterframe,tag):

		self.emit('remove-tag-filter',tag)

	def set_tag_filters(self, filters ):

		self.filterpage.set_tag_filters(filters)

	def add_user_filter(self,filterframe,user):

		self.emit('add-user-filter',user)

	def remove_user_filter(self,filterframe,user):

		self.emit('remove-user-filter',user)

	def set_user_filters(self, filters ):

		self.filterpage.set_user_filters(filters)

	def add_group_filter(self,filterframe,group):

		self.emit('add-group-filter',group)

	def remove_group_filter(self,filterframe,group):

		self.emit('remove-group-filter',group)

	def set_group_filters(self, filters ):

		self.filterpage.set_group_filters(filters)

	def update_textbuffer_insert(self, textbuffer, iter, text, length):

		if text=="\n" :

			#TODO: delete the fucking \n. PS fuck you PYGTK for making this

			#so fucking hard

			#textbuffer.backspace(iter,True,True) doesn't work

			self.do_submit=True

	def set_textlimit(self, limit):

		self.textlimit = int(limit)

	def emit_update_textview(self):

		#get the text from the buffer

		start_iter = self.update_textbuffer.get_start_iter()

		end_iter = self.update_textbuffer.get_end_iter()

		text=self.update_textbuffer.get_text(start_iter,end_iter).strip()

		if(text!=""):

			#disable the textview

			self.update_textview.set_sensitive(False)

			self.emit('update-status',text)

	'''function process_update_response

	@param self self

	@param response the string response returned by the communicator

	'''

	def emit_update_textview_responsed(self, error = False):

		if not error:

			#detach the spellchecker

			self.detach_gtkspell()

			#clear the text area

			self.update_textbuffer.set_text('')

			#reattach the spellchecker

			self.connect_gtkspell()

		#enable the textview

		self.update_textview.set_sensitive(True)

	'''function update_textbuffer_changed

	@param self self

	@param textbuffer - the textbuffer that called the function

	'''

	def update_textbuffer_changed(self,textbuffer):

		if self.do_submit:

			self.emit_update_textview()

			self.do_submit=False

			return 

		#we aren't submitting, check the amount of characters

		char_count = textbuffer.get_char_count()

		self.string_update_textview_append_count(self.textlimit-char_count)

		if (char_count > self.textlimit ):

			#prune the text to self.textlimit chars

			start_iter = textbuffer.get_iter_at_offset(self.textlimit)

			end_iter = textbuffer.get_end_iter()

			textbuffer.delete(start_iter,end_iter)

		elif(char_count==0 and not self.is_direct_message_mode):

			#the text has possibly been deleted, clear associated stuff

			self.emit('clear-respond-to-id')

	def notebook_page_switch(self,nb,page,page_num):

		old_page = self.notebook_current_page

		self.notebook_current_page=page_num

		self.emit('notebook-page-change',old_page,page_num)

	def string_update_textview_append_count(self,count):

		if count<self.textlimit:

			string = "%s %d" % (self.string_status_frame,count)

		else:

			string = self.string_status_frame

		self.update_status_label.set_text(string)

	def set_message(self,message,type=STATUS_MESSAGE):

		if type==ERROR_MESSAGE:

			markup = "<span color='#dd0000'>%s</span>" % message

		else:

			markup = message

		self.message_label.set_markup(markup)

		#show the self.message label

		self.message_label.show()

	def close_conversation(self,widget):

		self.conversation_vbox.hide_all()

		self.notebook.set_current_page(self.pre_conversation_page)

	def quit(self,accel_group, acceleratable, keyval, modifier):

		self.emit("quit")

	def userpage_hide(self,widget):

		self.userpage.hide_all()

		self.set_notebook_page(self.pre_user_page)

	def grouppage_hide(self,widget):

		self.grouppage.hide_all()

		self.set_notebook_page(self.pre_group_page)

	def follow_user(self,widget,name,bool):

		self.emit('follow-user',name,bool)

	def join_group(self,widget,name,bool):

		self.emit('join-group',name,bool)

	def copy(self,accel_group,acceleratable,keyval,modifier):

		'''the user want to copy some text'''

		#can we get the selected text?

		try:

			#get the bounds of the last clicked label

			bounds = self.last_clicked_label.get_selection_bounds()

			#is the bounds empty or not?

			if bounds != ():

				#get the text from the last clicked label

				text = self.last_clicked_label.get_text()

				#get the text within the bounds

				selection = text[bounds[0]:bounds[1]]

				# get the clipboard

				clipboard = gtk.Clipboard()

				#set clipboard text

				clipboard.set_text(selection)

				#store that shit!

				clipboard.store()

		except:

			pass

	'''

	function window_to_tray

	emit 'window-to-tray' signal

	'''

	def window_to_tray(self,accel_group,acceleratable,keyval,modifier):

		self.emit('window-to-tray')

	def connect_gtkspell(self):

		if has_gtkspell and self.has_spell_library:

			self.spell = gtkspell.Spell(self.update_textview)

	def detach_gtkspell(self):

		if has_gtkspell and self.has_spell_library:

			self.spell.detach()

	def set_throbber(self,image_path):

		self.throbber.set_from_file(image_path)

	def dent_text_clicked(self,dent,text_label):

		self.last_clicked_label = text_label

	def set_is_direct_message_mode(self,mode,user=None):

		self.is_direct_message_mode=mode

		if mode:

			self.string_status_frame="%s %s" % (self.string_direct_message, user)

		else:

			self.string_status_frame=self.string_update_textview

			#clear the text

			self.update_textbuffer.set_text("")

		#update the label text

		self.update_status_label.set_text(self.string_status_frame)

	#we may need to set the focus on the notebook

	def focus_notebook(self,accel_group, acceleratable, keyval, modifier):

		#set the focus on the notebook

		self.notebook.grab_focus()

	#we may need to set the focus on the status update textview

	def focus_update_textview(self,accel_group, acceleratable, keyval, modifier):

		#set the focus on the notebook

		self.update_textview.grab_focus()

		if keyval==gtk.keysyms.l:

			self.update_textbuffer.set_text('')