~x1101/+junk/heybuddy

You should have received a copy of the GNU General Public License

along with heybuddy.    If not, see <http://www.gnu.org/licenses/>.

'''

import gtk,gobject

import sys, os

import gettext

from About import About

from SettingsPage import SettingsPage

import MainWindow

from DentScroller import DentScroller

from UserPage import UserPage

from ScrollPage import ScrollPage

global version

global branch

app_name = 'heybuddy'

 

#make a fake enumeration

#create a fake enum for options

class application :

        def __init__(self):

                #keep track of the initial conversation id so that conversations don't colide

                self.conversation_id="0"

                #keep track of the filters

                self.options={'run_as_tray_app':False,'context_backwards':False,'no_avatars':False,'notifications':True,'notify_replies':False}

                #keep track of the direct_message requests

                self.last_direct_message_time=0

                self.respond_to_id=0

                self.pre_group_page=None

                self.pre_user_page=None

                #what are the assets?

                asset_dir = 'assets'

                heybuddy_dir = os.path.dirname( os.path.realpath( __file__ ) )

                self.conf = Configuration(app_name)

                self.xmlprocessor = XMLProcessor()

                #create a regex to replace parts of a dent

                self.regex_url=re.compile("(http[s]?://.*?)(\s|$)",re.IGNORECASE)

                #get the initial dents

                self.initial_dents = self.conf.get('settings','initial_dents',default='20' )

                #build the gui

                

                #create the communicator

                self.comm = Communicator(app_name)

                self.comm.connect('statusesXML',self.process_statusesXML,self.dentspage)

                self.comm.connect('mentionsXML',self.process_statusesXML,self.mentionspage)

                self.comm.connect('group-statusesXML',self.process_statusesXML,self.grouppage)

                self.comm.connect('friendshipXML',self.process_friendshipXML)

                self.comm.connect('exception-caught',self.communication_exception)

                self.comm.connect('widget-image',self.process_widget_image)

                #create an image cacher thingy

                self.imagecache = ImageCache()

                self.imagecache.set_disabled( self.conf.get_bool_option('no_avatars') )

                self.userpage.connect('follow-user',self.follow_user)

                self.userpage.connect('direct-clicked',self.direct_clicked)

                self.userpage.connect('open-link',self.open_link)

                

                #add the userpage

                self.mainwindow.notebook.append_page(self.userpage,gtk.Label(_("User") ) )

                #add the Grouppage

                self.mainwindow.notebook.append_page(self.grouppage,gtk.Label(_("Group") ) )

                

                #create and add the account page

                self.settingspage = SettingsPage(has_hildon,has_pynotify)

                self.settingspage.set_initial_dents( self.initial_dents )

                self.settingspage.connect('option-notify-replies',self.option_changed, 'notify_replies')

                self.settingspage.connect('initial-dents',self.set_initial_dents)

                self.settingspage.connect('link-color',self.set_link_color)

                #add the settings to the mainwindow

                self.mainwindow.add_notebook_page(self.settingspage,gtk.Label(_("Settings") ) )

                #create and add the about page

                        filters = self.conf.get('settings','filters',True)

                        #the filters should be an array

                        if len(filters):

                                #set the filters

                except:

                        pass

        

                self.mainwindow.set_notebook_page(DENT) 

                self.get_statuses()

 

        

        def get_direct_messages(self):

                now = time.time()

                #has it been 3 minutes since the last request?

                if now-(3*60) > self.last_direct_message_time:

                        self.increment_requests()

                        self.last_direct_message_time=now

        

                #start the communicator

                self.comm.start()

                self.main_loop = gobject.MainLoop()

                #add a function to the main loop

                #we have to temporarily show the various pages or nothing works

                ''' why the fuck do I need to do this? '''

                #did the conf read a name and password?

                if( self.conf.name() !="" and self.conf.password()!=""):

                        self.comm.set_name_and_password( self.conf.name(),self.conf.password() )

                        self.settingspage.set_name(self.conf.name())

                        self.settingspage.set_password(self.conf.password())

                        #add a timout to get dents

                        #gobject.timeout_add(1000,self.get_direct_messages )

                else:

                        #set the focus on the account page; the last page

                

                self.mainwindow.run()

                self.main_loop.run()

                #if we ever get here, we should quit

 

        def update_statuses(self):

                is_member = self.xmlprocessor.get_user_is_member(text)

                self.mainwindow.display_user_is_member( is_member )

        

        def process_new_statusXML(self,comm,text):

                self.decrement_requests()

                status = self.xmlprocessor.get_dom(text)

                data = self.xmlprocessor.get_dent_data(status)

                data['markup'] = self.markup_dent_text(data['text'])

                #add the dent

                dent = self.connect_dent(data,self.dentspage)

        def process_conversationXML(self,object,text,conversation_id):

                self.decrement_requests()

                #is this the current conversation Id? if not, then do nothing

                        data['in_reply_to_screen_name']=None

                        #tell the mainWindow to add the dent

                        dent = self.connect_dent(data,self.contextpage,True, self.options['context_backwards'] )

                        if data['in_reply_to_id']!=None:

                                #recursively get in_reply_to_ids

                                self.get_conversation(id=data['in_reply_to_id'],conversation_id=conversation_id)

 

                #make the dent

                dent = Dent(data,is_direct=is_direct_dent)

        def reply_clicked(self,dent,name):

                #set the text buffer

                self.mainwindow.update_textbuffer.set_text("@%s " % (name) )

                self.mainwindow.update_textview.grab_focus()

        

        def favorite_clicked(self,dent):

                id=dent.id

                #change to the user page

                self.mainwindow.set_notebook_page(USER)

                                

        def get_dent_time(self,text):

                

        def markup_dent_text(self,text):

                #process the text to markup

                #based on the target, what is the counting thingy?

                count_ref=None

                if target_page==self.dentspage:

                elif target_page==self.mentionspage:

                elif target_page==self.directspage:

                self.decrement_requests()

                #get a list of the statuses

                statuses = self.xmlprocessor.get_statuses(text,is_direct)

                #reverse the statuses list

                        if not filtered_status:

                                #get the markup

                                data['markup'] = self.markup_dent_text(data['text'])

                                #if the target_page = 0 and not first_dents and not is_conf

                                if target_page==self.dentspage and not self.is_first_dents:

                                        if "@"+self.conf.name() in data['markup']:                                      

                                                reply_count+=1

                                                if self.options['notify_replies'] and has_pynotify:

                                                        self.notify.notify_reply(data['screen_name'], data['markup'] )

                                        else:

                                                dent_count+=1

                                        

                self.is_first_dents=False

                #get the related images

                self.imagecache.get_images()

        def process_widget_image(self,comm,data,name):

                self.imagecache.widget_image_add(data,name)     

                

                self.decrement_requests()

                if code=='401': 

                        #bad authorization

                                MainWindow.ERROR_MESSAGE)

                        self.mainwindow.set_notebook_page(MainWindow.ACCOUNT)

                elif code == '404':

                elif code == '503':

                else:

        

        #functions to handle the filtration system

                        

        def add_user_filter(self,winder,user):

                if not user in self.filters['users']:

                        self.filters['users'].append(user)

                        self.filters['users'].sort()

                

        def remove_user_filter(self,winder,user):

                if user in self.filters['users']:

                        self.filters['users'].remove(user)

        

        def check_filtered(self,data):

                

        

        def status_clicked(self,widget):

                if self.window_is_hidden==True:

                 

        def redent_clicked(self,dent,name,text):

                self.respond_to_id=dent.id

                formatted_text= u'\u267A @%s: %s' % (name,text)

                self.mainwindow.update_textbuffer.set_text(formatted_text )

                self.mainwindow.update_textview.grab_focus()

                gtk.rc_parse_string(style)

                #fuck you GTK for not make this work, more than once!

        

        #functions for blocking/unblocking

                

                

                

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

                        

        def open_link(self, widget, uri):

                command = "xdg-open '%s'" % ( uri )

                subprocess.Popen(command,shell=True)

                return True

 

if(__name__=="__main__"):

        a = application()