Python gtk_util.set_tooltip_text函数代码示例

 def microphone_state(*args):
     if not self.client.server_sound_receive:
         microphone.set_sensitive(False)
         set_tooltip_text(microphone, "Server does not support microphone forwarding")
         return
     microphone.set_sensitive(True)
     microphone.set_submenu(self.make_soundsubmenu(is_microphone_on, self.mic_on, self.mic_off, "microphone-changed"))

def populate_encodingsmenu(encodings_submenu, get_current_encoding, set_encoding, encodings, server_encodings):
    encodings_submenu.get_current_encoding = get_current_encoding
    encodings_submenu.set_encoding = set_encoding
    encodings_submenu.encodings = encodings
    encodings_submenu.server_encodings = server_encodings
    encodings_submenu.index_to_encoding = {}
    encodings_submenu.encoding_to_index = {}
    NAME_TO_ENCODING = {}
    i = 0
    for encoding in encodings:
        name = ENCODINGS_TO_NAME.get(encoding, encoding)
        descr = ENCODINGS_HELP.get(encoding)
        NAME_TO_ENCODING[name] = encoding
        encoding_item = CheckMenuItem(name)
        if descr:
            if encoding not in server_encodings:
                descr += "\n(not available on this server)"
            set_tooltip_text(encoding_item, descr)
        def encoding_changed(oitem):
            log("encoding_changed(%s)", oitem)
            item = ensure_item_selected(encodings_submenu, oitem)
            enc = NAME_TO_ENCODING.get(item.get_label())
            log("encoding_changed(%s) item=%s, enc=%s, current=%s", oitem, item, enc, encodings_submenu.get_current_encoding())
            if enc is not None and encodings_submenu.get_current_encoding()!=enc:
                encodings_submenu.set_encoding(enc)
        log("make_encodingsmenu(..) encoding=%s, current=%s, active=%s", encoding, get_current_encoding(), encoding==get_current_encoding())
        encoding_item.set_active(encoding==get_current_encoding())
        encoding_item.set_sensitive(encoding in server_encodings)
        encoding_item.set_draw_as_radio(True)
        encoding_item.connect("toggled", encoding_changed)
        encodings_submenu.append(encoding_item)
        encodings_submenu.index_to_encoding[i] = encoding
        encodings_submenu.encoding_to_index[encoding] = i
        i += 1
    encodings_submenu.show_all()

 def speaker_state(*args):
     if not self.client.server_sound_send:
         speaker.set_sensitive(False)
         set_tooltip_text(speaker, "Server does not support speaker forwarding")
         return
     speaker.set_sensitive(True)
     speaker.set_submenu(self.make_soundsubmenu(is_speaker_on, self.spk_on, self.spk_off, "speaker-changed"))

 def set_encodingsmenuitem(*args):
     encodings.set_sensitive(not self.client.mmap_enabled)
     if self.client.mmap_enabled:
         #mmap disables encoding and uses raw rgb24
         encodings.set_label("Encoding")
         set_tooltip_text(encodings, "memory mapped transfers are in use so picture encoding is disabled")
     else:
         encodings.set_submenu(self.make_encodingssubmenu())

 def set_clipboard_menuitem(*args):
     self.clipboard_menuitem.set_active(self.client.clipboard_enabled)
     c = self.client
     can_clipboard = c.server_supports_clipboard and c.client_supports_clipboard
     self.clipboard_menuitem.set_sensitive(can_clipboard)
     if can_clipboard:
         set_tooltip_text(self.clipboard_menuitem, "Enable clipboard synchronization")
     else:
         set_tooltip_text(self.clipboard_menuitem, "Clipboard synchronization cannot be enabled: disabled by server")

 def set_notifications_menuitem(*args):
     self.notifications_menuitem.set_active(self.client.notifications_enabled)
     c = self.client
     can_notify = c.toggle_cursors_bell_notify and c.server_supports_notifications and c.client_supports_notifications
     self.notifications_menuitem.set_sensitive(can_notify)
     if can_notify:
         set_tooltip_text(self.notifications_menuitem, "Forward system notifications")
     else:
         set_tooltip_text(self.notifications_menuitem, "Cannot forward system notifications: the feature has been disabled")

 def set_cursors_menuitem(*args):
     self.cursors_menuitem.set_active(self.client.cursors_enabled)
     c = self.client
     can_toggle_cursors = c.toggle_cursors_bell_notify and c.server_supports_cursors and c.client_supports_cursors
     self.cursors_menuitem.set_sensitive(can_toggle_cursors)
     if can_toggle_cursors:
         set_tooltip_text(self.cursors_menuitem, "Forward custom mouse cursors")
     else:
         set_tooltip_text(self.cursors_menuitem, "Cannot forward mouse cursors: the feature has been disabled")

 def set_bell_menuitem(*args):
     self.bell_menuitem.set_active(self.client.bell_enabled)
     c = self.client
     can_toggle_bell = c.toggle_cursors_bell_notify and c.server_supports_bell and c.client_supports_bell
     self.bell_menuitem.set_sensitive(can_toggle_bell)
     if can_toggle_bell:
         set_tooltip_text(self.bell_menuitem, "Forward system bell")
     else:
         set_tooltip_text(self.bell_menuitem, "Cannot forward the system bell: the feature has been disabled")

 def gl_set(*args):
     debug("gl_set(%s) opengl_enabled=%s, window_unmap=%s", args, self.client.opengl_enabled, self.client.window_unmap)
     gl.set_active(self.client.opengl_enabled)
     gl.set_sensitive(self.client.window_unmap)
     if not self.client.window_unmap:
         set_tooltip_text(gl, "no server support for runtime switching")
         return
     def opengl_toggled(*args):
         self.client.toggle_opengl()
     gl.connect("toggled", opengl_toggled)

 def __init__(self, *args):
     TrayBase.__init__(self, *args)
     self.tray_widget = gtk.StatusIcon()
     set_tooltip_text(self.tray_widget, self.tooltip or "Xpra")
     self.tray_widget.connect('activate', self.activate_menu)
     self.tray_widget.connect('popup-menu', self.popup_menu)
     if self.size_changed_cb:
         self.tray_widget.connect('size-changed', self.size_changed_cb)
     filename = self.get_tray_icon_filename(self.default_icon_filename)
     if filename:
         self.set_icon_from_file(filename)

 def add_graph_button(self, tooltip, click_cb):
     button = gtk.EventBox()
     def set_cursor(widget):
         widget.window.set_cursor(gdk.Cursor(gdk.BASED_ARROW_DOWN))
     button.connect("realize", set_cursor)
     graph = gtk.Image()
     graph.set_size_request(0, 0)
     button.connect("button_press_event", click_cb)
     button.add(graph)
     set_tooltip_text(graph, tooltip)
     self.graph_box.add(button)
     return graph

 def set_qualitymenu(self, *args):
     if self.quality:
         can_use = not self.client.mmap_enabled and self.client.encoding in self.client.server_encodings_with_quality
         self.quality.set_sensitive(can_use)
         if not can_use:
             set_tooltip_text(self.quality, "Not supported with %s encoding" % self.client.encoding)
             return
         set_tooltip_text(self.quality, "Minimum picture quality")
         #now check if lossless is supported:
         if self.quality.get_submenu():
             can_lossless = self.client.encoding in self.client.server_encodings_with_lossless_mode
             for q,item in self.quality.get_submenu().menu_items.items():
                 item.set_sensitive(q<100 or can_lossless)

 def mode_changed(self, *args):
     ssh = self.mode_combo.get_active_text()=="SSH"
     self.port_entry.set_text("")
     if ssh:
         self.ssh_port_entry.show()
         set_tooltip_text(self.port_entry, "Display number (optional)")
         set_tooltip_text(self.password_entry, "SSH Password")
         self.username_entry.show()
         self.username_label.show()
     else:
         self.ssh_port_entry.hide()
         set_tooltip_text(self.port_entry, "port number")
         set_tooltip_text(self.password_entry, "Session Password")
         self.username_entry.hide()
         self.username_label.hide()
         if self.config.port>0:
             self.port_entry.set_text("%s" % self.config.port)
     if not ssh or sys.platform.startswith("win") or sys.platform.startswith("darwin"):
         #password cannot be used with ssh
         #(except on win32 with plink, and on osx via the SSH_ASKPASS hack)
         self.password_label.show()
         self.password_entry.show()
     else:
         self.password_label.hide()
         self.password_entry.hide()
     self.validate()

 def set_keyboard_sync_tooltip():
     if not self.client.keyboard_helper:
         set_tooltip_text(self.keyboard_sync_menuitem, "Keyboard support is not loaded")
     elif not self.client.toggle_keyboard_sync:
         set_tooltip_text(self.keyboard_sync_menuitem, "This server does not support changes to keyboard synchronization")
     elif self.client.keyboard_helper.keyboard_sync:
         set_tooltip_text(self.keyboard_sync_menuitem, "Disable keyboard synchronization (prevents spurious key repeats on high latency connections)")
     else:
         set_tooltip_text(self.keyboard_sync_menuitem, "Enable keyboard state synchronization")

 def populate_menu(options, value, set_fn):
     found_match = False
     items = {}
     if value and value>0 and value not in options:
         options[value] = "%s%%" % value
     for s in sorted(options.keys()):
         t = options.get(s)
         qi = CheckMenuItem(t)
         qi.set_draw_as_radio(True)
         candidate_match = s>=max(0, value)
         qi.set_active(not found_match and candidate_match)
         found_match |= candidate_match
         qi.connect('activate', set_fn, submenu)
         if s>0:
             set_tooltip_text(qi, "%s%%" % s)
         submenu.append(qi)
         items[s] = qi
     return items