示例#1
0
def main():
    parser = ArgumentParser()
    parser.add_argument('-c', '--config', help='A path to config file',
                        default="~/.pyvpn")
    args = parser.parse_args()
    Notify.init('SofToken')

    try:
        config = get_config(expanduser(args.config))
        token = SoftToken(config['tuser'], config['consoleui'], config['wine'])
        password = token.get_password(config['tpassword'])
        copy_to_clipboard(password)
        notification = Notify.Notification.new(
            "SoftToken",
            "VPN password copied to clipboard",
            "dialog-information"
        )
        notification.show()
    except Exception as e:
        notification = Notify.Notification.new(
            "SoftToken",
            str(e),
            "dialog-information"
        )
        notification.show()
def notifiersystem(last_comm):

	Notify.init("Football score")
	
	notification = Notify.Notification.new(last_comm)
	
	notification.show()
def main(argv):
	reload(sys);
	sys.setdefaultencoding('utf-8');
	
	#타겟 준비
	targets = argv[1:]
	
	#알림 메시지 초기화
	Notify.init("make_comic_book")
	title = u'그림책 만들기'
	
	if not targets:
		msg = u'대상을 선택해 주세요!'
		Notify.Notification.new(title, msg, '').show()
		sys.exit(1)
	
	#변환
	for target in targets:
		try:
			cbz = MakeCbz().make(target, u'.')
		except Exception, err:
			Notify.Notification.new(title, unicode(err), '').show()
			raise SystemExit()
			
		ufp.trashPut(target)
		
		#메시지 작성
		msg = u"<b>%(target)s</b>를 <b>%(cbz)s</b>로 묶었습니다." % locals()
		
		#알림 메시지 보이기
		Notify.Notification.new(title, msg, '').show()
示例#4
0
		def __init__(self, app, daemon):
			Notify.init("Syncthing GTK")
			# Prepare stuff
			self.app = app
			self.daemon = daemon
			self.notify_folders = {}
			self.notify_devices = {}

			# Make deep connection with daemon
			self.signals = [
				self.daemon.connect("connected", self.cb_syncthing_connected)
			]
			if self.app.config["notification_for_error"]:
				self.signals += [
					self.daemon.connect("error", self.cb_syncthing_error),
					self.daemon.connect("folder-rejected", self.cb_syncthing_folder_rejected),
					self.daemon.connect("device-rejected", self.cb_syncthing_device_rejected)
				]
				log.verbose("Error notifications enabled")
			if self.app.config["notification_for_update"]:
				self.signals += [
					self.daemon.connect('item-started', self.cb_syncthing_item_started),
					self.daemon.connect('item-updated', self.cb_syncthing_item_updated),
				]
				log.verbose("File update notifications enabled")
			if self.app.config["notification_for_folder"]:
				self.signals += [
					self.daemon.connect('folder-sync-progress', self.cb_syncthing_folder_progress),
					self.daemon.connect('folder-sync-finished', self.cb_syncthing_folder_finished)
				]
				log.verbose("Folder notifications enabled")
示例#5
0
    def __init__(self, controls):
        FControl.__init__(self, controls)
        Gtk.Window.__init__(self, Gtk.WindowType.POPUP)

        self.set_position(Gtk.WindowPosition.MOUSE)
        self.connect("leave-notify-event", self.on_leave_window)
        Notify.init('Foobnix')
示例#6
0
def func():
 #Enter your Twilio accountSid and authToken
 accountSid = ""
 authToken = ""
 #Parser for the Cricbuzz XML Page in cricbuzz library
 cric = CricbuzzParser()
 #Connecting to the Twilio API
 twilioClient = TwilioRestClient(accountSid, authToken)
 myTwilioNumber = ""
 destCellPhone = ""
 #Getting the XML File and extracting the matches from it
 match = cric.getXml()
 details = cric.handleMatches(match)
 #Filtering out the NoneType Objects in 'details'
 details = filter(None,details)
 message = 'No Match Available'
 for i in details:
 #Traversing the list
      if 'Match State' in i:
      #If the match state key is present in the dict
         if i['Match State'] == 'inprogress':
          #If the match is in progress
             message =  i['Team']+ "      "+ i['Match Format'] + ' Match at ' + i['Venue']+  "\n" +i['Batting team'] + ' ' + i['Batting Team Runs'] + '/'+i['Batting Team Wickets'] + '  Overs: ' + i['Batting Team Overs']
 #Generates the message 
 Notify.init("Live Scores")
 #Shows Notification on the desktop
 Notify.Notification.new("Match currently in progress:",message).show()
 #Sends message to the phone number
 myMessage = twilioClient.messages.create(body = "Match Currently in progress: " + message, from_=myTwilioNumber, to=destCellPhone)
 #Defines an interval of 60 seconds
 time.sleep(60)
示例#7
0
def _main():
	parser = ArgumentParser()
	parser.add_argument(
		'-n','--name', help='name', default="notify-pipe")
	parser.add_argument(
		'-i','--icon', help='icon ', default="")

	args = parser.parse_args()

	Notify.init("notify-pipe")

	name = args.name

	Hello = Notify.Notification.new (name)
	Hello.show()

	lines_iterator = iter(sys.stdin.readline, b"")

	try:
		for line in lines_iterator:
			if line:
				print(line,end="")
				sys.stdout.flush()
				Hello.update(name, line, args.icon)
				Hello.show()
			else:
				break
	except KeyboardInterrupt:
		sys.exit(0)
示例#8
0
	def enable(self):
		self._max_mails = int(self.get_config()['max_visible_mails'])
		self._notification_server_wait_event.clear()
		self._notification_server_ready = False
		self._notifications = {}
		
		# initialize Notification
		if not self._initialized:
			Notify.init("Mailnag")
			self._is_gnome = os.environ.has_key('GDMSESSION') and \
				(os.environ['GDMSESSION'] == 'gnome')
			self._initialized = True
		
		def mails_added_hook(new_mails, all_mails):
			self._notify_async(new_mails, all_mails)
		
		def mails_removed_hook(remaining_mails):
			if remaining_mails == 0:
				# no mails (e.g. email client has been launched) -> close notifications
				self._close_notifications()
		
		self._mails_added_hook = mails_added_hook
		self._mails_removed_hook = mails_removed_hook
		
		controller = self.get_mailnag_controller()
		hooks = controller.get_hooks()
		
		hooks.register_hook_func(HookTypes.MAILS_ADDED, 
			self._mails_added_hook)
		hooks.register_hook_func(HookTypes.MAILS_REMOVED, 
			self._mails_removed_hook)
    def __init__(self):

        Notify.init("cricket score indicator")
        self.notification = Notify.Notification.new("")
        self.notification.set_app_name("Cricket Score")
        """
        Initialize appindicator and other menus
        """
        self.indicator = appindicator.Indicator.new("cricket-indicator",
                            ICON_PREFIX + DEFAULT_ICON+ ICON_SUFFIX ,
                            appindicator.IndicatorCategory.APPLICATION_STATUS)
        # if DEBUG:
        #     self.indicator.set_icon_theme_path(DARK_ICONS)

        self.indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
        self.indicator.set_label("Loading", "")
        self.indicator.connect("scroll-event", self.scroll_event_cb)
        self.menu_setup()

        # the 'id' of match selected for display as indicator label
        self.label_match_id = None

        self.open_scorecard = set()
        self.intl_menu = []
        self.dom_menu = []
示例#10
0
 def notification(self):
     while(True):
         live_scores, valid = Fixtures().fixture()
         for score in live_scores:
             match_time = score['time']
             status = score['status']
             team = score['team']
             score = score['score']
             score_time = score + '    (Time:' + match_time + ')'
             if status != 1:
                 if status == 3:
                     score_time = score + '    (FT)'
                 elif status == 4:
                     score_time = score + '    (HT)'
                 Notify.init("Live Score")
                 send_notification = Notify.Notification.new(team,
                                                             score_time,
                                                             )
                 send_notification.set_icon_from_pixbuf(self._icon)
                 send_notification.show()
                 time.sleep(3)
                 send_notification.close()
                 Notify.uninit()
         if not valid:
             break
         time.sleep(300)
示例#11
0
def status(project, args):
    try:
        import gi
        gi.require_version('Notify','0.7')
        from gi.repository import Notify
        from gi.repository import GLib
    except:
        return
    
    global inited

    if not inited:
        Notify.init("sgmake")
        inited = True

    try:
        #if not "step" in args and not "start" in args:
        if "success" == args:
            Notify.Notification.new(
                "sgmake",
                "Build Complete",
                'dialog-information'
            ).show()
        
        if "failure" == args:
            Notify.Notification.new(
                "sgmake",
                "Build Failure",
                'dialog-error'
            ).show()
    except GLib.Error:
        pass # notifications disabled
示例#12
0
def main():
    setup_logging()

    logging.info('Starting 60 min notifier')
    Notify.init('Check Tasks')

    notify_body = "eventually this will pull from org agenda"
    # Hello = Notify.Notification.new('Task Check', notify_body, 'alert.xpm')
    # show for 5 minutes
    # Hello.set_timeout(100000)
    while True:
        logging.info('Start of while true loop')
        to_sleep = 3600 - time.time() % 3600
        logging.debug('Sleep time is ' + str(to_sleep))
        # sleep for the remaining seconds until the half hour
        time.sleep(to_sleep)
        logging.info('Showing notification')
        args = ['uclock']
        out_bytes = subprocess.check_output(args)
        out_text = out_bytes.decode('utf-8')
        logging.debug(out_text)
        # alert_window()
        # Hello.show()

    logging.error('Somehow left while true loop')
示例#13
0
    def __init__(self):
        Notify.init("A3KTorrent")
        self.filename = 'path'
        self.filepath = 'folder'
        #default values to check!
        self.builder = Gtk.Builder()
        self.builder.add_from_file("layout.glade")
        self.builder.get_object('window1').connect('delete-event',Gtk.main_quit)

        self.dialog=self.builder.get_object('dialog1')
        self.dialog.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)

        self.dialog2=self.builder.get_object('dialog2')
        self.dialog2.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)

        self.dialog3 = self.builder.get_object("dialog3")
        self.dialog3.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        
        self.window = self.builder.get_object("window1")
        self.window.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)

        self.progressbar= self.builder.get_object("progressbar1") #PROGRESSBAR
        self.progressbar.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        
        self.aboutdialog = self.builder.get_object("aboutdialog1")
        self.aboutdialog.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)

        self.label = self.builder.get_object("label1")

        self.builder.get_object("filechooserbutton2").set_action(Gtk.FileChooserAction.SELECT_FOLDER)
        #filechooser 2

        self.search_field = self.builder.get_object("search_field")
        self.search_field.get_style_context().add_class(Gtk.STYLE_CLASS_PRIMARY_TOOLBAR)
        self.dow_label = self.builder.get_object("dow_speed")
示例#14
0
    def on_module_selected(self):
        if self.loaded:
            return

        print("Loading Notifications module")

        Notify.init("cinnamon-settings-notifications-test")

        page = SettingsPage()
        self.sidePage.add_widget(page)

        settings = page.add_section(_("Notification settings"))

        switch = GSettingsSwitch(_("Enable notifications"), "org.cinnamon.desktop.notifications", "display-notifications")
        settings.add_row(switch)

        switch = GSettingsSwitch(_("Remove notifications after their timeout is reached"), "org.cinnamon.desktop.notifications", "remove-old")
        settings.add_reveal_row(switch, "org.cinnamon.desktop.notifications", "display-notifications")

        switch = GSettingsSwitch(_("Show notifications on the bottom side of the screen"), "org.cinnamon.desktop.notifications", "bottom-notifications")
        settings.add_reveal_row(switch, "org.cinnamon.desktop.notifications", "display-notifications")

        button = Button(_("Display a test notification"), self.send_test)
        settings.add_row(button)

        settings = page.add_section(_("Media keys OSD"))

        combo = GSettingsComboBox(_("Media keys OSD size"), "org.cinnamon", "show-media-keys-osd", MEDIA_KEYS_OSD_SIZES)
        settings.add_row(combo)
示例#15
0
    def get_cpu_speeds(self):
	message = ''
	try:
		r = requests.post('https://www-wohnheim.uni-regensburg.de/utils/login.py/checkAuthentication', data=payload)
		soup = BeautifulSoup(r.text)
		title = soup.findAll('title')[0].get_text()
		login_page = title.find('Login')>0

		if(login_page):
			notify.init('indicator-cpuspeed')
			notify.Notification.new("<b>Login failed</b>", "<b>Change password?</b>", None).show()
			notify.uninit()
	
		rzdatatable = soup.find("table", {"id": "rzdatatable"})
		data = rzdatatable.findAll('tr')[1]

		wohnheim = data.findAll('td')[0].get_text()
		zimmer = data.findAll('td')[1].get_text()
		status = data.findAll('td')[2].span.get_text()
		empfangen = data.findAll('td')[3].get_text()
		gesendet = data.findAll('td')[4].get_text()
		summe = data.findAll('td')[5].get_text()
		limit = data.findAll('td')[6].get_text()

		# print(wohnheim + "(" + zimmer + "), status: " + status)
		# print("Volumen: " + str(summe) + "mb von " + str(limit) + "mb (" + str(round(100*float(summe)/float(limit),2)) + "%), davon " + gesendet + "mb gesendet und " + empfangen + "mb empfangen.")

		message = str(summe)

	except requests.ConnectionError:
		message = 'No Connection'
	return message
示例#16
0
文件: bspwm.py 项目: dj95/lemonbarpy
    def __init__(self, colors):
        super().__init__()

        # Save config
        self.__colors = colors

        # Start lemonbar in a subprocess
        self.__bar = subprocess.Popen(['lemonbar', '-B', colors['bg'], '-F', colors['fg'], '-f', "Terminesspowerline-8", '-f', "Ionicons-10", '-f', 'Icons-8', '-f', 'FontAwesome-10', '-f', "Serif-9", '-a', '30' ], stdin=subprocess.PIPE, stdout=subprocess.PIPE)

        # Init notifier for displaying volume stats with dunst
        Notify.init('bar')

        # Panel variables to save intermediate states 
        self.__calendar = None
        self.__volume = None
        self.__vpn = None
        self.__state = None
        self.__spotify = None
        self.spotify_callback_value = None
        self.keyboard_callback_value = None
        self.status = {'date':'', 'spotify':'', 'vol':'', 'wlan':'', 'eth':'', 'vpn':'', 'bat':''}
        self.workspaces = ''
        self.title = ''
        self.current_power = ''
        self.old_power = ''
        
        # Status toggles
        self.__show_eth = False
        self.__show_wlan = False
        self.__show_battery = False
        self.__show_spotify = False


        self.__run = True
示例#17
0
    def prepare_notify(self):
        try:
            from gi.repository import Notify
            self.has_notifications = True
        except ImportError:
            logging.warning ("libnotify not found.")
            return "libnotify not found"

        # Work-around Ubuntu's incompatible workaround for Gnome's API breaking mistake.
        # https://bugzilla.gnome.org/show_bug.cgi?id=702390
        old_add_action = Notify.Notification.add_action
        def new_add_action(*args):
            try:
                old_add_action(*args)
            except TypeError:
                old_add_action(*(args + (None,)))
        Notify.Notification.add_action = new_add_action

        Notify.init('Pithos')
        self.notification = Notify.Notification()
        self.notification.set_category('x-gnome.music')
        self.notification.set_hint_string('desktop-icon', 'pithos')

        caps = Notify.get_server_caps()
        if 'actions' in caps:
            logging.info('Notify supports actions')
            self.supports_actions = True

        if 'body-markup' in caps:
            self.escape_markup = True

        if 'action-icons' in caps:
            self.notification.set_hint('action-icons', GLib.Variant.new_boolean(True))
示例#18
0
  def abort_refresh(self, message, description):
    """Updates menu with failure state message."""
    # Remove previous message if already exists
    if (len(self.menuItems) > 4):
      self.menuItems.pop(2)
      self.menuItems.pop(1)

    self.menuItems.insert(2, gtk.MenuItem(message))
    self.menuItems.insert(3, gtk.SeparatorMenuItem())
    self.menuItems[2].set_sensitive(False)

    # Re-enable "Check now" button
    self.menuItems[0].set_sensitive(True)
    self.menuItems[0].set_label("Check now")

    # Refresh all menu items 
    for i in self.menu.get_children():
      self.menu.remove(i)

    for i in self.menuItems:
      self.menu.append(i)

    self.menu.show_all()

    # Push notification
    Notify.init("image")
    self.n = Notify.Notification.new(message,
      description,
      "error"
    ).show()
示例#19
0
 def somethingFinished(self, subject, body, soundfile):
     timerSound = os.path.join(os.path.dirname(__file__), soundfile)
     Notify.init("Timer finished")
     notification = Notify.Notification.new (subject, body, NOTIFICATION_ICON)
     notification.set_urgency(Notify.Urgency.CRITICAL)
     notification.show()
     subprocess.Popen(["paplay", timerSound])
示例#20
0
def notify_bat_low():
    print '\nBattery is at ' + str(bat_percentage()) + '%\n'
    Notify.init('Battery low!')
    message=Notify.Notification.new('Battery low!',
                                    'Battery is at ' + str(bat_percentage()) + '%',
                                    '/usr/share/icons/gnome/32x32/status/battery-empty.png')
    message.show()
 def __init__(self):
     dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
     self.bus = dbus.SessionBus()
     self.bus.add_signal_receiver(
         self.notify, signal_name="IrssiNotify", dbus_interface="org.irssi.Irssi", path="/org/irssi/Irssi"
     )
     Notify.init("irssi")
 def process_selection(self, filelist):
     self.conf.read(self.configfile)
     # Run in Preview Mode
     if self.conf.get(c, "preview_mode") == "True":
         if filelist != []:
             prelist = os.getenv('HOME') + '/.fileorganizer-preview.log'
             FILE = open(prelist, "w")
             FILE.close()
             damlist = os.getenv('HOME') + '/.fileorganizer-damaged.log'
             FILE = open(damlist, "w")
             FILE.close()
             for item in filelist:
                 item = fileops.MusicFile(self, item)
                 item.preview()
             Notify.init('Fileorganizer')
             title = 'Fileorganizer'
             note = 'Preview Has Completed'
             notification = Notify.Notification.new(title, note, None)
             Notify.Notification.show(notification)
             # Show Results of preview
             self.results(prelist, damlist)
     else:
         # Run Normally
         self.organize(filelist)
         Notify.init('Fileorganizer')
         title = 'Fileorganizer'
         note = 'Your selection is organised'
         notification = Notify.Notification.new(title, note, None)
         Notify.Notification.show(notification)
示例#23
0
    def fire_notify(self, msg="", title="GitPushNotify", add_callback=None, path=None):
        # raise Exception(999)
        Notify.init("New commit")

        self.log.info("Called fireNotify()")
        try:
            # n = notify2.Notification(title, msg, '')
            n = Notify.Notification.new(title, msg)
            if len(self.nn) > 10:
                self.nn = []
            self.nn.append(n)

            self.log.info("append data")
            n.set_urgency(1)
            self.log.info("set_urgency")
            if add_callback:
                self.log.info("add callback ")
                n.connect("closed", self.empty_cb)
                n.add_action("clicked", " pull all branches ", self.call_back_fire, path)
            self.log.info("show")
            try:
                n.show()
            except Exception as e:
                self.log.info("error while show: %s" % e)
            else:
                self.log.info("showed")
            finally:
                self.log.info("end show")
        except Exception as e:
            self.log.info("error in firenotify: %s" % e)
            traceback.print_exc()
        else:
            self.log.info("ok firenotify")
示例#24
0
def time_manager(work_seconds, sleep_seconds):
    mm = MouseManager()
    km = KeyboardManager()
    Notify.init("time manager")
    while True:
        time.sleep(work_seconds)
        mm.disable_mouse()
        km.disable_keyboard()
        message = Notify.Notification.new("主任, 该休息了!",
                'Time to sleep!!!',
                'dialog-information')
        message.show()

        # There's a bug in disabling mouse
        delta = 5
        m_sleep_seconds = sleep_seconds
        while m_sleep_seconds > 0:
            mm.disable_mouse()
            if m_sleep_seconds >= delta:
                time.sleep(delta)
                m_sleep_seconds -= delta
            else:
                time.sleep(m_sleep_seconds)
                break

        mm.enable_mouse()
        km.enable_keyboard()
    def __init__(self, token=None):
        self.indicator = AppIndicator3.Indicator.new(
            'digitalocean-indicator',
            '',
            AppIndicator3.IndicatorCategory.APPLICATION_STATUS)
        self.indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
        icon_uri = get_media_file("digitalocean-indicator.svg")
        icon_path = icon_uri.replace("file:///", '')
        self.indicator.set_icon(icon_path)

        Notify.init('DigitalOcean Indicator')

        self.PreferencesDialog = DoPreferencesDialog
        self.settings = Gio.Settings(
            "com.andrewsomething.digitalocean-indicator")
        self.settings.connect('changed', self.on_preferences_changed)
        self.preferences_dialog = None
        self.preferences_changed = False

        if token:
            self.do_api_token = token
        else:
            self.do_api_token = self.settings.get_string("do-api-token")

        self.menu = Gtk.Menu()

        # Add items to Menu and connect signals.
        self.build_menu()
        # Refresh menu every 10 min by default
        self.change_timeout = False
        self.interval = self.settings.get_int("refresh-interval")
        GLib.timeout_add_seconds(self.interval * 60, self.timeout_set)
示例#26
0
    def autoSuspender(self, minPercent=5):
        # update even full capacity in case the battery has been changed
        self.full = int(cat("/sys/class/power_supply/BAT0/energy_full"))

        self.update()

        # hibernate only if battery is discharging
        if self.state != "Discharging":
            return {}  # return empty dict, main loop expects it

        # test if everything is OK
        for var in (self.full, self.now, self.state, self.percent):
            if var is None:
                return {}  # return empty dict, main loop expects it

        # test battery level
        if self.percent <= minPercent:
            Notify.init("Hibernation")
            battLevel = Notify.Notification.new("Warning:", "Battery level at " + str(self.percent) + "%.", "")
            battLevel.set_urgency(Notify.Urgency.CRITICAL)
            battLevel.show()
            warning = Notify.Notification.new("Warning:", "Hibernation in 10 seconds...", "")
            warning.set_urgency(Notify.Urgency.CRITICAL)
            warning.show()
            time.sleep(10)
            battLevel.close()
            warning.close()
            Notify.uninit()
            subprocess.call("systemctl hibernate", shell=True)
        return {}  # return empty dict, main loop expects it
示例#27
0
    def __init__(self):
        # Create variables
        # See how to define this in a better way
        # (But for now 0 - ReadyToWork, 1 - Working, 2 - ReadyToBreak, 3 - InBreak)
        self.state = 0
        self.work_value = 0
        self.break_value = 0
        self.timer_value = 0
        self.read_options_file()
        self.counter_timeout_id = 0
        # Define icons and notifications by state
        self.icon_by_state = {0: 'work_gray', 1: 'work_red', 2: 'break_gray', 3: 'break_green'}
        self.notification_by_state = {1: 'Your work time is over. You should take a break!',
                                      3: 'Your break is over. Ready to get back to work?'}

        self.icons_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'icons/')

        # Create the Indicator instance
        self.ind = appindicator.Indicator.new_with_path(
                    "pTimer",
                    "work_gray",
                    appindicator.IndicatorCategory.APPLICATION_STATUS,
                    self.icons_path)
        self.ind.set_status(appindicator.IndicatorStatus.ACTIVE)
        self.ind.set_label(self.get_time_string(), "00:00:00")

        # Init notifications
        notify.init('pTimer')

        # Init menu class
        self.menu = PMenu(self)
        self.options_window = None
示例#28
0
    def __init__(self):
        cfg = fedmsg.config.load_config(None, [])
        moksha_options = {
            self.config_key: True,
            "zmq_subscribe_endpoints": ','.join(
                ','.join(bunch) for bunch in
                cfg['endpoints'].values()
            ),
        }
        cfg.update(moksha_options)

        moksha.hub.setup_logger(verbose=True)

        # Despite what fedmsg.config might say about what consumers are enabled
        # and which are not, we're only going to let the central moksha hub know
        # about *our* consumer.  By specifying this here, it won't even check
        # the entry-points list.
        consumers, prods = [self], []
        moksha.hub._hub = moksha.hub.CentralMokshaHub(cfg, consumers, prods)

        fedmsg.consumers.FedmsgConsumer.__init__(self, moksha.hub._hub)

        self.session_bus = dbus.SessionBus()
        bus_name = dbus.service.BusName(self.bus_name, bus=self.session_bus)
        dbus.service.Object.__init__(self, bus_name, self._object_path)

        Notify.init("fedmsg")
        Notify.Notification.new("fedmsg", "activated", "").show()
示例#29
0
文件: gui.py 项目: pss10c/Pymodoro
    def __init__(self, title=""):
        Gtk.Window.__init__(self, title=title)
        self.connect('delete-event', Gtk.main_quit)
        DBusGMainLoop(set_as_default=True)
        self._bus = dbus.SessionBus()
        self._daemon = self._bus.get_object(DBUS_BUS_NAME, DBUS_DAEMON_PATH)
        self._daemon_i = dbus.Interface(self._daemon, DBUS_BUS_NAME)
        self._daemon.connect_to_signal('state_changed', self._state_changed_handler)
        Notify.init("Pymodoro")
        self.status_icon = Gtk.StatusIcon.new_from_file(self.get_icon())
        self.status_icon.connect("popup-menu", self._right_click_handler)

        self.menu = Gtk.Menu()
        self.mi_start = Gtk.MenuItem()
        self.mi_start.set_label("Start")

        self.mi_stop = Gtk.MenuItem()
        self.mi_stop.set_label("Interrupt")

        self.mi_quit = Gtk.MenuItem()
        self.mi_quit.set_label("Quit")

        self.mi_start.connect("activate", self._daemon_i.start_pomodoro)
        self.mi_stop.connect("activate", self._daemon_i.reset_pomodoro)
        self.mi_quit.connect("activate", Gtk.main_quit)

        self.menu.append(self.mi_start)
        self.menu.append(self.mi_stop)
        self.menu.append(self.mi_quit)
        self._menu_setup()
示例#30
0
def let_it_rain():
    GObject.threads_init()
    Gst.init(None)
    signal.signal(signal.SIGINT, signal.SIG_DFL)
    Notify.init("silver-rain")
    # Create system directories
    if not os.path.exists(IMG_DIR):
        os.makedirs(IMG_DIR)
    # Initialize config
    config.setup()
    # Create directory for recordings
    if not os.path.exists(config.recs_dir):
        os.makedirs(config.recs_dir)
    # Load css
    css_load()
    # Init translation
    set_translation()
    # Init application
    silver_app = SilverApp()
    # Setup dbus service
    service = SilverService(silver_app)
    # Run loop
    Gtk.main()
    # Cleanup
    silver_app.clean()
    Notify.uninit()
示例#31
0
        src = parsing("SRC=", line)
        dst = parsing("DST=", line)
        proto = parsing("PROTO=", line)
        spt = parsing("SPT=", line)
        dpt = parsing("DPT=", line)

        commandIptables = "INPUT -p " + proto + " -i " + interface + " -s " + src + " -d " + dst
        if dpt != None :
            commandIptables = commandIptables + " --dport " + dpt
        commandIptables = commandIptables + " -j ACCEPT"

        commandUfw = "ufw allow from " + interface + " to " + out + " proto " + proto
        if dpt != None :
            commandUfw = commandUfw + " port " + dpt

        Notify.init('Ubuntu Firewall Notification')
        notif = Notify.Notification.new(
            _("Ubuntu Firewall Notification"), # title
            _("A packet has been bloqued by the firewall"), # message
            'dialog-information' # icon
        )
        # add the custom notification action
        notif.add_action(
            'permanent',
            _('Allow traffic permanently'), # Button text
            callback, # function callback de notre bouton
            commandUfw, # fonction qui supprime les user_datas
            0
        )
        notif.add_action(
            'session',
示例#32
0
def quit(_):
    Notify.uninit()
    gtk.main_quit()
示例#33
0
 def onQuit(self, *args):
     Notify.uninit()
     Gtk.main_quit()
示例#34
0
    def onShowOrHide(self, *args):
        if self.window_is_hidden:
            window.show()
        else:
            window.hide()

        self.window_is_hidden = not self.window_is_hidden

    def onQuit(self, *args):
        Notify.uninit()
        Gtk.main_quit()


# Handle pressing Ctr+C properly, ignored by default
signal.signal(signal.SIGINT, signal.SIG_DFL)

builder = Gtk.Builder()
builder.add_from_file('gtk-example.glade')
builder.connect_signals(Handler())

window = builder.get_object('window1')
window.set_icon_from_file(ICON)
window.show_all()

entry = builder.get_object('entry1')
menu = builder.get_object('menu1')
icon = TrayIcon(APPID, ICON, menu)
Notify.init(APPID)

Gtk.main()
示例#35
0
    def run(self):
        self.config = configparser.ConfigParser(
            interpolation=configparser.ExtendedInterpolation(),
            inline_comment_prefixes=('#', ','))
        self.config.read(configfile)

        log_count = self.config['Common'].getint('log-count', logcount)
        log_size = self.config['Common'].getint('log-size', logsize)
        log_level = self.config['Common'].get('log-level', loglevel)
        log_file = os.path.expanduser(self.config['Common'].get(
            'log-file', logfile))

        log_formatter = logging.Formatter(
            "%(asctime)s [%(levelname)-5.5s]  %(message)s",
            "%Y-%m-%d %H:%M:%S")

        log_file_handler = RotatingFileHandler(log_file,
                                               maxBytes=log_size,
                                               backupCount=log_count)
        log_file_handler.setFormatter(log_formatter)

        log_console_handler = logging.StreamHandler()
        log_console_handler.setFormatter(log_formatter)

        self.logger = logging.getLogger("borg")
        self.logger.addHandler(log_file_handler)
        self.logger.addHandler(log_console_handler)

        # parse and set log level
        level = logging.getLevelName(log_level.upper())
        if isinstance(level, int):
            self.logger.setLevel(level)
        else:
            self.logger.setLevel(logging.INFO)

        Notify.init("BorgBackup")

        self.notifications = []
        self.log = {}

        # instantiate our borg wrapper
        self.borg = Borg(self.logger, self.json_callback, self)

        # setup schedule that will regularily execute backups
        self.sched = sched.scheduler()

        # extract all sections beginning with 'repo-'
        self.repos = [
            self.config[repo] for repo in self.config.sections()
            if repo.startswith('repo-')
        ]

        for repo in self.repos:
            # schedule backups now, will reschedule itself
            self.handle_repo(repo)

        while True:
            Gtk.main_iteration_do(False)
            self.sched.run(blocking=False)

            time.sleep(1)
示例#36
0
def main():
    parser = argparse.ArgumentParser(
        formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument('--device-model-id', '--device_model_id', type=str,
                        metavar='DEVICE_MODEL_ID', required=False,
                        help='the device model ID registered with Google')
    parser.add_argument('--project-id', '--project_id', type=str,
                        metavar='PROJECT_ID', required=False,
                        help='the project ID used to register this device')
    parser.add_argument('--nickname', type=str,
                        metavar='NICKNAME', required=False,
                        help='the nickname used to register this device')
    parser.add_argument('--device-config', type=str,
                        metavar='DEVICE_CONFIG_FILE',
                        default=os.path.join(
                            os.path.expanduser('~/.config'),
                            'googlesamples-assistant',
                            'device_config_library.json'
                        ),
                        help='path to store and read device configuration')
    parser.add_argument('--credentials', type=existing_file,
                        metavar='OAUTH2_CREDENTIALS_FILE',
                        default=os.path.join(
                            os.path.expanduser('~/.config'),
                            'google-oauthlib-tool',
                            'credentials.json'
                        ),
                        help='path to store and read OAuth2 credentials')
    parser.add_argument('--query', type=str,
                        metavar='QUERY',
                        help='query to send as soon as the Assistant starts')
    parser.add_argument('-v', '--version', action='version',
                        version='%(prog)s ' + Assistant.__version_str__())

    args = parser.parse_args()
    with open(args.credentials, 'r') as f:
        credentials = google.oauth2.credentials.Credentials(token=None,
                                                            **json.load(f))

    device_model_id = None
    last_device_id = None
    try:
        with open(args.device_config) as f:
            device_config = json.load(f)
            device_model_id = device_config['model_id']
            last_device_id = device_config.get('last_device_id', None)
    except FileNotFoundError:
        pass

    if not args.device_model_id and not device_model_id:
        raise Exception('Missing --device-model-id option')

    should_register = (
        args.device_model_id and args.device_model_id != device_model_id)

    device_model_id = args.device_model_id or device_model_id

    note = Notify.Notification.new(Notify.get_app_name(),'Micno with Assistant は動作中です','mic-volume-high')
    note.set_urgency(Notify.Urgency.NORMAL)
    note.show()

    with Assistant(credentials, device_model_id) as assistant:
        global device_id_global, device_model_id_global
        events = assistant.start()

        device_id = assistant.device_id
        print('device_model_id:', device_model_id)
        print('device_id:', device_id + '\n')
        device_id_global = device_id
        device_model_id_global = device_model_id
        if should_register or (device_id != last_device_id):
            if args.project_id:
                register_device(args.project_id, credentials,
                                device_model_id, device_id, args.nickname)
                pathlib.Path(os.path.dirname(args.device_config)).mkdir(
                    exist_ok=True)
                with open(args.device_config, 'w') as f:
                    json.dump({
                        'last_device_id': device_id,
                        'model_id': device_model_id,
                    }, f)
            else:
                print(WARNING_NOT_REGISTERED)

        for event in events:
            if event.type == EventType.ON_START_FINISHED and args.query:
                assistant.send_text_query(args.query)
            process_event(event)
示例#37
0
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from __future__ import print_function

import subprocess

from gi.repository import Notify, Gtk
Notify.init('Micno With Assistant')

import argparse
import json
import os.path
import pathlib2 as pathlib

import google.oauth2.credentials

from google.assistant.library import Assistant
from google.assistant.library.event import EventType
from google.assistant.library.file_helpers import existing_file
from google.assistant.library.device_helpers import register_device

try:
    FileNotFoundError
    parser.add_argument(
        '--urgency',
        help='LOW, NORMAL, CRITICAL',
        choices=['LOW', 'NORMAL', 'CRITICAL'],
        default='NORMAL'
    )
    parser.add_argument(
        '--hints',
        help='list of comma sep options',
        action='append',
        default=[]
    )

    args = parser.parse_args()

    Notify.init('Interactive Notifications')

    notification = Notify.Notification.new(args.summary, args.body, args.icon)

    for hint in args.hints:
        key, value = hint.split(',', 1)
        notification.set_hint_string(key, value)

    for action in args.action:
        action_id, action_label = action.split(',', 1)
        notification.add_action(
            action_id,
            action_label,
            action_callback,
            None
        )
示例#39
0
 def __init__(self):
     Notify.init("mintUpload")
def main(indicator):
    indicator.set_status(appindicator.IndicatorStatus.ACTIVE)
    indicator.set_menu(build_menu())
    notify.init(APPINDICATOR_ID)
    gtk.main()
示例#41
0
    def __init__(self):
        logger = None
        if LOGGING:
            import logging
            logger = logging.getLogger(APP_NAME)
            logger.setLevel(logging.DEBUG)
            ch = logging.StreamHandler()
            ch.setLevel(logging.DEBUG)
            logger.addHandler(ch)
        self.logger = logger


log = log().log

Notify.init("Nemo pastebin extension")


class PastebinThread(Thread):
    def __init__(self, settings, filename):
        self.settings = settings
        self.filename = filename
        Thread.__init__(self)

    def run(self):
        log("PastebinThread started!")
        cmdline = ["pastebinit"]

        options = {}
        options['-b'] = "http://" + self.settings.get_string("pastebin")
        options['-a'] = self.settings.get_string("author")
示例#42
0
 def notify(self, detail):
     Notify.Notification("mintUpload", detail, ICONFILE).show()
示例#43
0
 def done(self):
     self.close()
     Notify.uninit()
     Gtk.main_quit()
示例#44
0
 def quit(self, source=None):
     # send dead signal to tcp server
     self.send('dead')
     notify.uninit()
     Gtk.main_quit()
def main():
    Notify.init("calendar-indicator")
    CalendarIndicator()
    Gtk.main()
示例#46
0
from gi.repository import Notify
Notify.init("App Name")
Notify.Notification.new("Hi").show()
示例#47
0
#!/usr/bin/env python3

import i3ipc
from gi.repository import Notify

Notify.init("i3-fullscreen-manager")
notify_pause = Notify.Notification.new("DUNST_COMMAND_PAUSE", "",
                                       "dialog-information")
notify_unpause = Notify.Notification.new("DUNST_COMMAND_RESUME", "",
                                         "dialog-information")


def on_window(self, e):
    if e.container.focused:
        if e.container.fullscreen_mode:
            notify_pause.show()
        else:
            notify_unpause.show()

    if e.container.floating.endswith("on") \
            and e.container.fullscreen_mode == 0 \
            and e.container.window_rect.width == 3840 \
            and e.container.window_rect.height == 2160:
        e.container.command("fullscreen enable")


conn = i3ipc.Connection()
conn.on('window', on_window)
conn.main()
示例#48
0
from base64 import b64encode
from os.path import expanduser

import gi

gi.require_version('Notify', '0.7')
gi.require_version('Gtk', '3.0')

from gi.repository import Notify
from gi.repository import Gtk

from .Base import Base

# One time initialization of libnotify
Notify.init('Screenshot clip and upload')


class ScreenshotNotification(Base, Notify.Notification):
    def __init__(self, **kwargs):
        super().__init__()
        """
        :param kwargs:
        """
        Notify.Notification.__init__(self,
                                     summary=kwargs['summary'],
                                     body=kwargs['body'])

        # icon = dialog-information, dialog-warn, dialog-error
        kwargs['icon'] = 'dialog-information'
示例#49
0
 def __init__(self):
     self.update_watched()
     Notify.init('Terminator')
     return None
示例#50
0
	def throwNotification(self):
		Notify.init("Book My Show Tracker")
		Notify.Notification.new("Tickets at " + self.name + " are open now").show()
示例#51
0
        """
        return False


class DesktopNotification(BaseDesktopNotification):
    pass


try:
    import gi
    gi.require_version('Notify', '0.7')
    from gi.repository import Notify
except (ImportError, ValueError):
    pass
else:
    if not Notify.init("i3pystatus"):
        raise ImportError("Couldn't initialize libnotify")

    # List of some useful icon names:
    # battery, battery-caution, battery-low
    # …

    class DesktopNotification(DesktopNotification):
        URGENCY_LUT = (
            Notify.Urgency.LOW,
            Notify.Urgency.NORMAL,
            Notify.Urgency.CRITICAL,
        )

        def display(self):
            notification = Notify.Notification.new(self.title, self.body,
示例#52
0
#!/usr/bin/python3
## -*- coding: utf-8 -*-
import sys, os, json, pyperclip, socketserver, socket, threading
from gi.repository import Notify
Notify.init("Cross Clip")


class Config:
    def __init__(self):
        self.readFile()

    def readFile(self):
        f = open('config.json')
        lines = f.readlines()
        self.json = json.loads("\n".join(lines))
        f.close()

    def save(self):
        f = open('config.json', 'w')
        json.dump(self.json, f)
        f.close()


config = Config()

#gCn bridge
connectedClients = []


class ClientThread(socketserver.BaseRequestHandler):
    stopnow = False
                    if Notify.init("Hello world"):
                        alert = Notify.Notification.new(
                            "ARP poisoning risk!",
                            "{} want {}\nBut {} is {}\n\nTarget {} ({})".
                            format(hwsrc, psrc, psrc, arp[psrc], hwdst,
                                   pdst), "dialog-error")
                        alert.show()
                print("{} ; {} want {} ; But {} is {} ; Target {} ({})".format(
                    strftime("%Y/%m/%d %H:%M:%S", gmtime()), hwsrc, psrc, psrc,
                    arp[psrc], hwdst, pdst))
        else:
            arp[psrc] = hwsrc


try:
    if Notify.init("Hello world"):
        alert = Notify.Notification.new("ARP poisoning detector", "Start",
                                        "dialog-information")
        alert.show()
        bash_notif = False
    else:
        commands.getoutput(
            "su - {} -c 'notify-send \"ARP poisoning detector\" \"Start\" --icon=dialog-information'"
            .format(user))
        bash_notif = True
except:
    commands.getoutput(
        "su - {} -c 'notify-send \"ARP poisoning detector\" \"Start\" --icon=dialog-information'"
        .format(user))
    bash_notif = True
    def __init__(self):
        super(PVPNApplet, self).__init__()
        self.country_codes = country_codes              # Keep a list of country codes

        # Init QSystemTrayIcon
        self.tray_icon = QSystemTrayIcon(self)
        self.tray_icon.setIcon(QIcon('icons/16x16/protonvpn-disconnected.png'))

        # Init libnotify
        Notify.init('ProtonVPN')

        # Refresh server list, store the resulting servers so we can populate the menu
        self.servers = self.update_available_servers()

        # Menu actions
        connect_fastest_action = QAction('Connect fastest', self)
        reconnect_action = QAction('Reconnect', self)
        disconnect_action = QAction('Disconnect', self)
        status_action = QAction('Status', self)
        connect_fastest_sc_action = QAction('Secure Core', self)
        connect_fastest_p2p_action = QAction('P2P', self)
        connect_fastest_tor_action = QAction('Tor', self)
        connect_random_action = QAction('Random', self)
        show_protonvpn_applet_version_action = QAction('About ProtonVPN-Applet', self)
        show_protonvpn_version_action = QAction('About ProtonVPN', self)
        quit_action = QAction('Exit', self)
        self.show_notifications_action = QAction('Show Notifications')
        self.show_notifications_action.setCheckable(True)
        self.show_notifications_action.setChecked(False)

        # Triggers
        quit_action.triggered.connect(qApp.quit)
        connect_fastest_action.triggered.connect(self.connect_fastest)
        disconnect_action.triggered.connect(self.disconnect_vpn)
        status_action.triggered.connect(self.status_vpn)
        show_protonvpn_applet_version_action.triggered.connect(self.show_protonvpn_applet_version)
        show_protonvpn_version_action.triggered.connect(self.get_protonvpn_version)
        connect_fastest_sc_action.triggered.connect(self.connect_fastest_sc)
        connect_fastest_p2p_action.triggered.connect(self.connect_fastest_p2p)
        connect_fastest_tor_action.triggered.connect(self.connect_fastest_tor)
        connect_random_action.triggered.connect(self.connect_random)
        reconnect_action.triggered.connect(self.reconnect_vpn)

        # Generate connection menu for specific countries
        connect_country_actions = []
        for country_name in self.get_available_countries(self.servers):

            # Get the ISO-3166 Alpha-2 country code
            country_name_to_code = {v: k for k, v in country_codes.country_codes.items()}
            country_code = country_name_to_code[country_name]

            # Dynamically create functions for connecting to each country; each function just passes its respective
            # country code to `self.connect_fastest_cc()`
            setattr(self, f'connect_fastest_{country_code}', functools.partial(self.connect_fastest_cc, country_code))

            # Generate an action for each country; set up the trigger; append to actions list
            country_action = QAction(f'{country_name}', self)
            country_action.triggered.connect(getattr(self, f'connect_fastest_{country_code}'))
            connect_country_actions.append(country_action)

        # Create a scrollable country connection menu
        connect_country_menu = QMenu("Country...", self)
        connect_country_menu.setStyleSheet('QMenu  { menu-scrollable: 1; }')
        connect_country_menu.addActions(connect_country_actions)

        # Generate connection menu
        connection_menu = QMenu("Other connections...", self)
        connection_menu.addMenu(connect_country_menu)
        connection_menu.addAction(connect_fastest_sc_action)
        connection_menu.addAction(connect_fastest_p2p_action)
        connection_menu.addAction(connect_fastest_tor_action)
        connection_menu.addAction(connect_random_action)

        # Draw menu
        tray_menu = QMenu()
        tray_menu.addAction(connect_fastest_action)
        tray_menu.addAction(reconnect_action)
        tray_menu.addMenu(connection_menu)
        tray_menu.addAction(disconnect_action)
        tray_menu.addAction(status_action)
        tray_menu.addSeparator()
        tray_menu.addAction(self.show_notifications_action)
        tray_menu.addAction(show_protonvpn_applet_version_action)
        tray_menu.addAction(show_protonvpn_version_action)
        tray_menu.addAction(quit_action)
        self.tray_icon.setContextMenu(tray_menu)
        self.tray_icon.show()

        # Polling thread
        self.start_polling()
示例#55
0
文件: test_notify.py 项目: z/snaps
def test_notification():
    Notify.init("Test")
    notification = Notify.Notification.new(summary="foo", body="Cool")
    notification.show()
    notification.close()
# Accept and parse notify arguments
parser = argparse.ArgumentParser()
parser.add_argument('--notify', action='store', \
                    choices=['GNOME'], \
                    help='Select notify mode')
parser.add_argument("-i", help="Define IP-address of machine ", type=str)

try:
    command_line = parser.parse_args()
except:
    sys.exit(2)

if command_line.notify == 'GNOME':
    from gi.repository import Notify
    Notify.init("Gnome")

incommingCommandSecond = ""
incommingCommandFirst = ""

host = '192.168.1.2'
port = 2081
statusMessageType = {
    '0x4': "Filter, ?",
    '0x5': "Filter, OK to start",
    '0x6': "Filter, OK to start",
    '0x7': "Beans, OK to start",
    '0xb': "Grinding",
    '0x20': "Filter, No carafe",
    '0x22': "Beans, No carafe",
    '0x23': "Beans, Not enough water",
示例#57
0
def main():
    """ given an optional parameter of a valid mailto url, open an appropriate
    gmail web page """

    global config

    args = parse_args()

    header = textwrap.dedent("""\
        # GNOME Gmail Configuration
        #
        # suppress_preferred
        #     If True ('1', 'yes'...) don't ask if GNOME Gmail should be made
        #     the default mail program.
        # suppress_account_selection
        #     If True ('1', 'yes'...) don't ask account to use, if you have
        #         only one.
        # new_browser
        #     If True ('1', 'yes'...) forcedly open Gmail in a new browser
        #         window.
        # last_email
        #     The email account used for the last run. It is used to populate
        #     the account selection dialog. This is updated automatically.
        #
        # use_browser
        #     What browser to use. If unspecified, uses system default browser.
        #     Examples: firefox | google-chrome
        #
        # browser_options
        #     Replace the command line arguments used to call the browser. Note
        #     that these options are not portable acrosss browsers. '%%s' is
        #     replaced with the url. Default options are:
        #         Chrome - "--app=%%s"
        #         Mozilla - "-new-window %%s"
        #         ...
        #
        """)

    config = GgConfig(
        fpath="~/.config/gnome-gmail/gnome-gmail.conf",
        section='gnome-gmail',
        initvals={
            'suppress_preferred': '0',
            'suppress_account_selection': '0',
            'new_browser': '1',
            'last_email': '',
            'use_browser': '',
            'browser_options': '',
        },
        header=header,
    )

    # anyone know how to do this right?
    glade_suffix = "share/gnome-gmail/gnomegmail.glade"
    glade_file = os.path.join('/usr', glade_suffix)
    for gpath in [os.path.join(x, glade_suffix) for x in ['/usr/local']]:
        if os.path.isfile(gpath):
            glade_file = gpath

    if not is_default_mailer() \
            and not config.get_bool('suppress_preferred'):
        do_preferred(glade_file, config)

    # quiet mode, to set preferred app in postinstall
    if args.quiet:
        sys.exit(0)

    Notify.init("GNOME Gmail")

    from_address = None
    message = None
    if args.rfc822:
        message = open(args.rfc822, 'r').read()
        from_address = fromFromMessage(message)
    else:
        last_from = config.get_str('last_email')
        from_address = getGoogleFromAddress(last_from, config, glade_file)
        if from_address:
            config.set_str('last_email', from_address)

    try:
        gm_url = GMailURL(args.mailto, from_address, message)
        gmailurl = gm_url.gmail_url(args.send)
    except GGError as gerr:
        notice = Notify.Notification.new("GNOME GMail", gerr.value,
                                         "dialog-information")

        notice.show()
        time.sleep(5)
    else:
        if not args.send:
            new_browser = config.get_bool('new_browser')
            browser().open(gmailurl, new_browser, True)
示例#58
0
    count = markup_cnt.format(count)
    lc = len(count)
    if lc > mlc:
        mlc = lc

    from_ = markup_from.format(from_)
    subj_ = markup_subj.format(subj_)
    tags = markup_tags.format(tags)
    tab.append((count, from_, subj_, tags, lc, lf, ls))

if len(tab) == 0 and threads_total == 0:
    sys.exit(0)

# Format a table
txt = []
for c, f, s, t, lc, lf, ls in tab:
    c += " " * (mlc-lc)
    f += " " * (mlf-lf)
    s += " " * (mls-ls)
    line = "{0} {1}  {2}  {3}".format(c, f, s, t)
    txt.append(line)
txt = '<span font_desc="DejaVu Sans Mono 7.5">' + "\n".join(txt) + '</span>'

# Display a notification
Notify.init("notmuch notify")
summary = "{0} threads, including {1} unread threads ({2} messages)".format(threads_total, threads_unread, msgs)
n = Notify.Notification.new(summary, txt, "/usr/share/emacs/site-lisp/notmuch-logo.png")
n.set_timeout(10000)
n.set_category("email.arrived")
n.show()
    for Line in myDatei:
        Line = Line.rstrip()
        #Line = Line.decode('utf8')
        myList.append(Line)
    myDatei.close()
    return (myList)


def writeFile(path, myList):  #self.filename
    myDatei = open(path, "w")
    #Liste aus Datei erstelle
    myDatei.writelines(myList)
    myDatei.close()


status = readFile(os.path.join(path, 'status.txt'))
if status[0] == "on":
    writeFile(os.path.join(path, 'status.txt'), ["off"])
    Notify.init("Rotation-ON")
    RotationOFF = Notify.Notification.new("Rotation",
                                          "Screenrotation is now turned OFF",
                                          "dialog-information")
    RotationOFF.show()
if status[0] == "off":
    writeFile(os.path.join(path, 'status.txt'), ["on"])
    Notify.init("Rotation-OFF")
    RotationON = Notify.Notification.new("Rotation",
                                         "Screenrotation is now turned ON",
                                         "dialog-information")
    RotationON.show()
示例#60
0
    def do_startup(self):
        Gtk.Application.do_startup(self)

        Notify.init(_("Music"))

        self.build_app_menu()