def activate(self, text=None):
     self.user = GconfStore.get_instance().get_client().get_string(GCONF_TWITTER_USER)
     self.password = GconfStore.get_instance().get_client().get_string(GCONF_TWITTER_PASSWORD)
     api = twitter.Api()
     pynotify.init("Deskbar Twitter Plugin")
     message = "Your post to Twitter might have had a problem"
     try:
         results = api.PostUpdate(self.user, self.password, self._name)
         if self._name == results.text:
             message = "Your post to Twitter was successful"
         n = pynotify.Notification("Twitter Results", message)
         n.set_icon_from_pixbuf(ICON)
         n.show()
     except URLError, e:
         if e.code == 401:
             message = "Incorrect Twitter Username and/or Password"
         if e.code == 403:
             message = "Your request Twitter was forbidden"
         if e.code == 404:
             message = "The URL for Twitter was not found"
         if e.code == 408:
             message = "The request to Twitter timed out.  Try again later."
         n = pynotify.Notification("Twitter Results", message)
         n.set_icon_from_pixbuf(ICON)
         n.show()

    def show_command_results(self, status, output):
        """
        Shows the output to the users.

        For now, it will write the output to stdout,
        change the icon depending on the status (green
        if the tests are passing, red otherwise) and,
        if pynotify is installed, show a notification.

        If you use this in Ubuntu, I'm sorry for you.
        Canonical just decided to break libnotify in so
        many ways that it is *impossible* to use it sanely.

        """

        sys.stdout.write(output)

        self.current_status = status

        if self.timer.running:
            self._set_icon()

        if pynotify is not None:
            pynotify.init('dojotools')
            message = pynotify.Notification('Dojotools', self.html_escape(output))
            message.attach_to_status_icon(self.status_icon)
            message.set_urgency(
                pynotify.URGENCY_NORMAL if status == 0
                else pynotify.URGENCY_CRITICAL
            )
            message.show()

  def _setup_notification (self):
    """Creates the pynotify object"""

    pynotify.init ("Brightness Notifications")

    self._notification = pynotify.Notification ("Brightness")
    self._notification.set_timeout (self._config.show_for)

def menuitem_response(w, buf):
    if buf == "_about" :
        md = gtk.MessageDialog(None,0, gtk.MESSAGE_INFO,
             gtk.BUTTONS_OK)
        md.set_markup("<b>sshlist v%s</b>" % ver)
        md.format_secondary_markup("""A simple sshmenu like replacement for appindicator menu.

To add items to menu, simply edit the file <i>.sshlist</i> in your home directory (one host per line).

Author: [email protected]
http://www.gulecha.org""")
        md.run()
        md.destroy()
    elif buf == "_refresh":
        newmenu = build_menu()
        ind.set_menu(newmenu)
        # Initialize pynotify, without this it crashes on "Refresh"
        pynotify.init("SSHList Notification")
        pynotify.Notification("sshlist refreshed","Menu list was refreshed from ~/.sshlist").show()
    elif buf == "_quit":
        newmenu = build_menu()
        ind.set_menu(newmenu)
        gtk.mainquit()
    else:
        print "gnome-terminal -x ssh " + buf + " &"
        run_program("gnome-terminal -x ssh " + buf + " &")

def sendmessage(title, message):
    pynotify.init("Steam players notification")
    n = pynotify.Notification(title, message)
    n.set_urgency(pynotify.URGENCY_NORMAL)

    n.show()
    return

    def pownce(self):
        print "Trying Pownce update"
        pownce_account = Account ("pownce.com", "Pownce API")
        user, password, key = pownce_account.get_credentials()
        url = "http://%s:%[email protected]/2.0/send/message.json" % (user, password)
        pynotify.init("Deskbar Wayd Plugin - Pownce")
        message = "Your post to Pownce might have had a problem"
        data = urlencode({"app_key" : "4d7p84417z5u1871edn578j300t14c4s", 
                          "note_body" : self.text,
                          "note_to" : "public"})

        try:
            result = simplejson.load(urlopen(url,data))
            if result.has_key("error"):
                message = result['error']['message']
            else:
               if result['body'] == self.text:
                    message = "Your post to Pownce was successful"
            n = pynotify.Notification("Pownce Results", message, "stock_internet")
            n.show()
        except urllib.URLError, e:
            if e.code == 401:
                message = "Incorrect Pownce Username and/or Password"
            if e.code == 403:
                message = "Your Pownce request was forbidden"
            if e.code == 404:
                message = "The URL for Pownce was not found"
            if e.code == 408:
                message = "The request to Pownce timed out.  Try again later."
            n = pynotify.Notification("Pownce Results", message, "stock_internet")
            n.show()

    def __init__(self):
        wx.Frame.__init__(self, id=-1, parent=None, name=u'RCWatchFrame',
                          size=wx.Size(WIDTH, HEIGHT), title=u'RC Status')
        self.Bind(wx.EVT_CLOSE, self.OnClose)

        self.rc_statusText = wx.StaticText(self, -1, "UNKWN")

        pygame.mixer.init()
        self.alertSound = pygame.mixer.Sound("crossing.wav")
        self.alertChannel = pygame.mixer.Channel(False)

        self.setFont(self.rc_statusText)

        self.notification = pynotify.Notification("RC Link Warning!",
                                                  "RC Link status not OK!",
                                                  "dialog-warning")

        self.rc_status = -1

        pynotify.init("RC Status")

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.rc_statusText, 1, wx.EXPAND)
        self.SetSizer(sizer)
        sizer.Layout()
        self.interface = IvyMessagesInterface("radiowatchframe")
        self.interface.subscribe(self.message_recv)
        self.update_timer = wx.CallLater(UPDATE_INTERVAL, self.gui_update)

	def __init__(self):
		self._statusicon = gtk.StatusIcon()
		pynotify.init('Snappy screen capture')
		self._statusicon.connect('activate', self._emit_proxy, 'activate')
		self._statusicon.connect('popup_menu', self._emit_proxy, 'popup_menu')
		self._statusicon.set_visible(True)
		super(SimpleGTKStatusIcon, self).__init__()

    def display_notification(self, return_code=None):
        if return_code is None and settings.aborted.show:
            description = settings.aborted.description % self.string_duration()
            timeout = settings.aborted.timeout

        elif return_code == 0 and settings.success.show:
            description = settings.success.description % self.string_duration()
            timeout = settings.success.timeout

        elif return_code is not None and settings.failed.show:
            description = settings.failed.description % (return_code, self.string_duration())
            timeout = settings.failed.timeout

        else:
            return

        if hasattr(notify, "GrowlNotifier"):
            g = notify.GrowlNotifier(u"naf", notifications=["command_finished"])
            g.register()
            g.notify("command_finished", self.command, description)
        elif hasattr(notify, "Notification"):
            if return_code == 0:
                icon = gtk.STOCK_DIALOG_INFO
            else:
                icon = gtk.STOCK_DIALOG_ERROR
            notify.init("Notify At Finish")
            notification = notify.Notification(self.command, description, icon)
            notification.set_timeout(timeout)
            notification.show()

	def __init__(self, config, verbose=False):
		"""
		initialized the logging and notification
		"""
		self.statusIcon = None
		self.indicator = None
		self.status_button = None
		self.status_text = None
		self.config = config
		#init logging 
		self.log = logging.getLogger("")
		os.popen("touch %s"%self.config.getAttribute('LOGFILE'))
		hdlr = logging.handlers.RotatingFileHandler(self.config.getAttribute('LOGFILE'), "a", 1000000, 3)
		fmt = logging.Formatter("%(asctime)s %(levelname)-5s %(message)s", "%x %X")
		hdlr.setFormatter(fmt)
		self.log.addHandler(hdlr)
		self.verbose = verbose

		#init notify
		self.notifyid = "Persy"
		try:
			pynotify.init(self.notifyid)
		except Exception as e:
			self.log.warn(str(e))

		self.resetError()

    def __init__(self, event, tray_icon, config):
        AlertDisplay.__init__(self, event, config)

        import pynotify
        pynotify.init('wuja')

        title = event.entry.title + " - Wuja"
        start_time = event.time.strftime("%a %b %d %Y - %I:%M%P")
        duration = str(timedelta(seconds=event.entry.duration))
        calendar = str(event.entry.calendar.title)
        where = str(event.entry.location)
        description = event.entry.description

        body = start_time + "\n" + \
            "Duration - " + duration + "\n"  + \
            "Calendar - " + calendar + "\n" + \
            "Location - " + where
        if description != None:
            body += "\n" + description

        pynotify.init(title)
        notif = pynotify.Notification(title, body)
        notif.attach_to_widget(tray_icon)
        notif.set_timeout(0)
        notif.add_action('accept', 'Accept', self.accept_event)
        notif.add_action('snooze', 'Snooze', self.snooze_event)

        notif.show()

def sendmessage(title, message):
    pynotify.init("image")
    notice = pynotify.Notification(
        title,
        message,
        "/usr/share/icons/gnome/48x48/status/appointment-missed.png").show()
    return notice

 def __init__(self):
     self.logger = logging.getLogger(__name__)
     self.logger.debug('Initializing notify object')
     if sys.platform == 'linux2':
         self.user = ''
         who = Popen(['/usr/bin/who'], stdout=PIPE).stdout.read()
         for line in who.splitlines():
             if 'tty7' in line:
                 self.user = line.split()[0]  
                 if '(' in line.split()[-1]:
                     self.display = line.split()[-1].replace('(','').replace(')','')
                 else:
                     self.display = ':0'
                 break
         if not self.user:
             self.logger.error('User not found in tty7. Probably no one logged in or in other terminal') 
             raise Exception('No user found.')              
         self.logger.debug('Set user : {0}'.format(self.user))
         self.logger.debug('Set display : {0}'.format(self.display))
         self.logger.debug('Initializing pynotify')
         pynotify.init('Summary')
         self.__notifier = pynotify.Notification
         self.message = self.__message
                    
     if sys.platform == 'win32':
         self.logger.debug('Initializing WindowsBalloonTip')
         self.__notifier = WindowsBalloonTip()
         self.message = self.__message

def run_command(directory, test_cmd):
    """
    As the name says, runs a command and wait for it to finish
    """
    process = subprocess.Popen(
        test_cmd,
        shell = True,
        cwd = directory,
        stdout = subprocess.PIPE,
        stderr = subprocess.PIPE,
    )

    output = process.stdout.read()
    output += process.stderr.read()
    status = process.wait()

    sys.stdout.write(output)

    if pynotify:
        pynotify.init('dojotools')
        message = pynotify.Notification('Dojotools', output)

        message.set_urgency(pynotify.URGENCY_NORMAL if status == 0 else pynotify.URGENCY_CRITICAL)

        message.show()

    def twitter(self):
        print "Trying Twitter update"
        twit_account = Account ("twitter.com", "Twitter API")
        user, password, key = twit_account.get_credentials()
        api = twitter.Api(user, password)
        pynotify.init("Deskbar Wayd Plugin - Twitter")
        message = "Your post to Twitter might have had a problem"

        if len(self.text) > 140:
            message="Your post is too long for Twitter."
            n = pynotify.Notification("Twitter Results", message, "stock_internet")
            n.show()
            return

        try:
            results = api.PostUpdate(self.text)
            if self.text == results.text:
                message = "Your post to Twitter was successful"
            n = pynotify.Notification("Twitter Results", message, "stock_internet")
            n.show()
        except urllib2.URLError, e:
            if e.code == 401:
                message = "Incorrect Twitter Username and/or Password"
            if e.code == 403:
                message = "Your request Twitter was forbidden"
            if e.code == 404:
                message = "The URL for Twitter was not found"
            if e.code == 408:
                message = "The request to Twitter timed out.  Try again later."
            n = pynotify.Notification("Twitter Results", message, "stock_internet")
            n.show()

    def __exit__(self, typ, val, traceback):
        if self.task_process is not None:
            try:
                self.task_process.kill()
            except (OSError, AttributeError):
                pass

        if self.pid is not None:
            if self.current_run < self.num_repeats:
                self.task_process = self.spawnProcess(logging_target=self.logging_target)
                self.task_process.communicate()

                return self.__exit__(typ, val, traceback)

            self.logfile.close()
            # clean up the log file (remove backspace characters)
            logfile = open(self.log_filename)
            logfile_content_old = logfile.readlines()
            logfile.close()

            logfile = open(self.log_filename,"w+")
            for line in logfile_content_old:
                line = line.replace("\010","")
                logfile.write(line)
            logfile.close()

            try:
                import pynotify
                pynotify.init("Basic")
                n = pynotify.Notification("%s has finished running" % str(self.task), self.output_directory)
                n.show()
            except ImportError:
                pass

    def jaiku(self):
        print "Trying Jaiku update"
        jaiku_account = Account ("jaiku.com", "Jaiku API")
        user, password, key = jaiku_account.get_credentials()
        url = "http://api.jaiku.com/json?user=%s&personal_key=%s" % (user, key)
        pynotify.init("Deskbar Wayd Plugin - Jaiku")
        message = "Your post to Jaiku might have had a problem"
        data = urlencode({"method": "presence.send", "message": self.text})

        try:
            result = simplejson.load(urlopen(url,data))
            if result['status'] == 'ok':
                message = "Your post to Jaiku was successful"
            else:
                message = result['message']
            n = pynotify.Notification("Jaiku Results", message, "stock_internet")
            n.show()
        except urllib2.URLError, e:
            if e.code == 401:
                message = "Incorrect Jaiku Username and/or Password"
            if e.code == 403:
                message = "Your Jaiku request was forbidden"
            if e.code == 404:
                message = "The URL for Jaiku was not found"
            if e.code == 408:
                message = "The request to Jaiku timed out.  Try again later."
            n = pynotify.Notification("Jaiku Results", message, "stock_internet")
            n.show()

	def msg(self,mstr):
		#mstr='The scoreis 102/3'
		title="SCORE"
		#os.environ.setdefault('DISPLAY', ':0.0')
		#os.system('notify-send -i "notification-message-IM" "'+title+'" "'+mstr+'"')
		pynotify.init('my apps')
		pynotify.Notification(''+title+'',''+mstr+'').show()

	def notify_show(self):
		pynotify.init('batt')
		self.notify = pynotify.Notification('Подключите питание!','Ваш  заряд' + str(self.real_state()) + '%')
		self.notify.show()
		time.sleep(5)
		self.notify.close()
		return True

    def activate(self, shell):
        gtk.gdk.threads_init()
        pynotify.init('Rhythmbox')
        
        self.shell=shell
        self.pl=shell.get_property('shell-player')
        self.db=shell.get_property('db')

        
        self.config_dialog=ConfigDialog(self)
        self.settings=Settings()
        self.post=Post(self)
        
        self.get_conf=self.settings.get_conf

        self.uim = shell.get_ui_manager()
                        
        self._register_icons()
        
        self.add_ui()
        self._attach_box()
        
        self.sending=False
        
        threading.Thread(target=self._check_4_update).start()