def build_calendar_dialog(self):
self.cal = gtk.Calendar()
self.cal.connect("day-selected", self.update_tree_view)
self.dialog = awn.Dialog(self)
self.dialog.props.hide_on_unfocus = True
self.dialog.set_title(_("Calendar"))
self.vbox = gtk.VBox()
self.hbox = gtk.HBox()
self.vbox.pack_start(self.cal)
hbox2 = gtk.HBox()
if self.integration is not None:
self.opencal = gtk.Button(_("Open in ") + self.integ_text)
self.opencal.connect("button-press-event",
self.open_integrated_calendar)
hbox2.pack_start(self.opencal)
self.goto_today = gtk.Button(_("Today"))
self.goto_today.connect("button-press-event", self.goto_today_callback)
self.cal.connect("month-changed", self.month_changed_callback)
hbox2.pack_start(self.goto_today)
self.vbox.pack_start(hbox2)
self.hbox.pack_start(self.vbox, False)
if self.integration is not None:
self.dialog.set_size_request(600, 300)
self.scrolled_win = gtk.ScrolledWindow()
self.scrolled_win.set_border_width(10)
self.scrolled_win.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_ALWAYS)
self.list = gtk.ListStore(str, str)
self.treeview = gtk.TreeView(self.list)
self.tvcolumn = gtk.TreeViewColumn()
self.treeview.append_column(self.tvcolumn)
self.cell = gtk.CellRendererText()
self.tvcolumn.pack_start(self.cell, True)
self.tvcolumn.add_attribute(self.cell, 'text', 0)
self.treeview.set_headers_visible(False)
self.treeview.set_rules_hint(True)
self.scrolled_win.add_with_viewport(self.treeview)
self.hbox.pack_start(self.scrolled_win, True, True, 5)
self.update_tree_view(self.window)
self.dialog.add(self.hbox)
self.dialog.show_all()
localtime = time.localtime()
self.cal.clear_marks()
if self.thread.check_cache(localtime[:3]):
busy = self.thread.get_days(localtime.tm_year, localtime.tm_mon)
for day in busy:
self.cal.mark_day(day)
def __init__(self, uid, panel_id, feeds):
super(awn.AppletSimple, self).__init__(APPLET_NAME, uid, panel_id)
self.feeds = feeds
self.configuration = awn.config_get_default_for_applet(self)
self.set_icon_name('comics-icon')
# Initialise notifications
notify_init(applet_display_name)
self.dialog = awn.Dialog(self)
self.dialog.connect('button-release-event',
self.on_dialog_button_press)
hbox = gtk.HBox(False)
self.message_icon = gtk.Image()
self.message_label = gtk.Label()
hbox.pack_start(self.message_icon, expand=False, fill=False)
hbox.pack_end(self.message_label)
hbox.show_all()
self.dialog.add(hbox)
self.connect('destroy', self.on_destroy)
self.connect('button-press-event', self.on_button_press)
self.connect('scroll-event', self.on_scroll)
self.visible = False
self.windows = []
self.window_iterator = BidirectionalIterator(self.windows)
self.current_window = None
self.manager = None
self.adder = None
self.about = None
try:
for filename in (f for f in os.listdir(STRIPS_DIR)
if f.endswith('.strip')):
strip = self.create_window(os.path.join(STRIPS_DIR, filename))
except OSError:
return
self.feeds.update()
def docklet_icon_middle_clicked(self, icon, uri):
if not os.path.isdir(uri.replace('file:///', '/')):
return False
self.icon_dialog = awn.Dialog(icon, self)
self.icon_dialog.connect('focus-out-event', self.icon_dialog_focusout)
self.icon_entry = gtk.Entry()
self.icon_entry.connect('key-release-event', self.detect_enter)
self.icon_entry.set_text(uri.replace('file:///', '/') + ['/', ''][uri[-1] == '/'])
self.icon_enter = gtk.Button(stock=gtk.STOCK_OPEN)
self.icon_enter.connect('clicked', self.launch_fb, self.icon_entry)
hbox = gtk.HBox()
hbox.pack_start(self.icon_entry)
hbox.pack_start(self.icon_enter, False)
self.icon_dialog.add(hbox)
self.icon_dialog.show_all()
self.icon_entry.grab_focus()
self.icon_entry.set_position(-1)
def dialog_show_new(self, page=0):
assert page >= 0
self.current_page = page
# create new dialog if it does not exists yet
if not self.dialog:
self.dialog = awn.Dialog(self.applet)
self.dialog.add_events(gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.LEAVE_NOTIFY | gtk.gdk.DRAG_MOTION
| gtk.gdk.DRAG_ENTER | gtk.gdk.DRAG_LEAVE
| gtk.gdk.DRAG_STATUS | gtk.gdk.DROP_START
| gtk.gdk.DROP_FINISHED)
self.dialog.set_focus_on_map(True)
self.dialog.set_keep_above(True)
self.dialog.props.hide_on_unfocus = True
#self.dialog.connect("focus-out-event", self.dialog_focus_out)
self.dialog.connect("drag-leave", self.dialog_drag_leave_event)
self.dialog.connect("drag-motion", self.stack_drag_motion_event)
self.dialog.set_title(self.applet.backend.get_title())
self.hbox = gtk.HBox(False, 0)
self.dialog.add(self.hbox)
# create dialog's internals
rows = self.config['rows']
cols = self.config['cols']
self.store = self.applet.backend.get_store()
iter = self.store.iter_nth_child(None, page * rows * cols)
if self.table:
for item in self.table.get_children():
self.table.remove(item)
self.table.destroy()
if page > 0:
self.table = gtk.Table(rows, cols, True)
else:
self.table = gtk.Table(1, 1, True)
self.table.set_resize_mode(gtk.RESIZE_PARENT)
self.table.set_row_spacings(0)
self.table.set_col_spacings(0)
x = y = 0
theres_more = False
while iter:
button = self.store.get_value(iter, COL_BUTTON)
if not button:
button = self._item_created_cb(None, None, iter)
t = button.get_parent()
if t:
t.remove(button)
self.table.attach(button, x, x + 1, y, y + 1)
iter = self.store.iter_next(iter)
x += 1
if x == cols:
x = 0
y += 1
if y == rows:
theres_more = (iter is not None)
break
self.hbox.add(self.table)
# if we have more than 1 page and browsing is enabled
if self.config['browsing'] and (theres_more or page > 0):
if self.navbuttons is None:
self.navbuttons = gtk.HButtonBox()
self.navbuttons.set_layout(gtk.BUTTONBOX_EDGE)
self.dialog.add(self.navbuttons)
self.bt_left = gtk.Button(stock=gtk.STOCK_GO_BACK)
self.bt_left.set_use_stock(True)
self.bt_left.set_relief(gtk.RELIEF_NONE)
self.bt_left.connect("clicked", self.dialog_show_prev_page)
self.navbuttons.add(self.bt_left)
self.bt_right = gtk.Button(stock=gtk.STOCK_GO_FORWARD)
self.bt_right.set_use_stock(True)
self.bt_right.set_relief(gtk.RELIEF_NONE)
self.bt_right.connect("clicked", self.dialog_show_next_page)
self.navbuttons.add(self.bt_right)
# enable appropriate navigation buttons
if page > 0:
self.bt_left.set_sensitive(True)
else:
self.bt_left.set_sensitive(False)
if theres_more:
self.bt_right.set_sensitive(True)
else:
self.bt_right.set_sensitive(False)
# show everything on the dialog
self.dialog.present()
self.dialog.show_all()
def __init__(self, uid, panel_id):
self.network_handler = self.NetworkHandler()
self.tokens = classes.Tokens()
self.favicons = classes.Tokens(cache_index)
#AWN Applet Configuration
awn.AppletSimple.__init__(self, 'feeds', uid, panel_id)
self.set_tooltip_text(_("Loading feeds..."))
self.dialog = awn.Dialog(self)
self.main_vbox = gtk.VBox(False, False)
self.dialog.add(self.main_vbox)
self.main_vbox.show()
#Need icon theme
self.icon_theme = gtk.icon_theme_get_default()
self.icon_theme.connect('changed', self.icon_theme_changed)
#Get a 16x16 icon representing the Internet/web
self.web_image = self.icon_theme.load_icon('applications-internet', 16, 0)
#Force a size of 16x16
if self.web_image.get_width() != 16 or self.web_image.get_height() != 16:
self.web_image = self.web_image.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR)
#Throbber overlay
self.throbber = awn.OverlayThrobber()
self.throbber.props.gravity = gtk.gdk.GRAVITY_SOUTH_WEST
#Error icon overlay
self.error_icon = awn.OverlayThemedIcon("gtk-dialog-error")
self.error_icon.props.gravity = gtk.gdk.GRAVITY_SOUTH_WEST
#First updated feed favicon (bottom right)
self.favicon1 = awn.OverlayPixbuf(self.web_image)
self.favicon1.props.gravity = gtk.gdk.GRAVITY_SOUTH_EAST
#Second updated feed favicon (bottom)
self.favicon2 = awn.OverlayPixbuf(self.web_image)
self.favicon2.props.gravity = gtk.gdk.GRAVITY_SOUTH
#Third updated feed favicon (right)
self.favicon3 = awn.OverlayPixbuf(self.web_image)
self.favicon3.props.gravity = gtk.gdk.GRAVITY_EAST
for overlay in (self.throbber, self.error_icon, self.favicon1, self.favicon2, self.favicon3):
if self.get_size() > 48:
overlay.props.scale = 16.0 / self.get_size()
else:
overlay.props.scale = 0.33
overlay.props.apply_effects = True
overlay.props.active = False
self.add_overlay(overlay)
#Magic at work. Position the 2nd and 3rd favicons adjacent to the icon
if self.get_size() > 48:
self.favicon2.props.x_adj = 0.5 - 24.0 / self.get_size()
self.favicon3.props.y_adj = 0.5 - 24.0 / self.get_size()
else:
self.favicon2.props.x_adj = 0.0
self.favicon3.props.y_adj = 0.0
#"Loading feeds..." label
self.loading_feeds = gtk.Label(_("Loading feeds..."))
self.loading_feeds.modify_font(pango.FontDescription('bold'))
self.main_vbox.pack_start(self.loading_feeds, False, False, 3)
self.loading_feeds.show()
self.loading_feeds.set_no_show_all(True)
#No feeds label
self.no_feeds = gtk.Label(_("You don't have any feeds."))
self.main_vbox.pack_start(self.no_feeds)
self.no_feeds.set_no_show_all(True)
#AwnConfigClient instance
self.client = awn.config_get_default_for_applet(self)
#Connect to signals
self.connect('button-press-event', self.button_press)
self.dialog.props.hide_on_unfocus = True
self.get_urls()
#TODO: put this and the similar code in add_feed() into a single, better place
for url in self.urls:
_base_url = '-'.join(url.split('-')[:-1])
username = url.split('-')[-1]
if _base_url == 'google-reader':
self.feeds[url] = classes.GoogleReader(self, username)
elif _base_url == 'google-wave':
self.feeds[url] = classes.GoogleWave(self, username)
elif _base_url == 'reddit':
self.feeds[url] = classes.Reddit(self, username)
elif _base_url in ('twitter-timeline', 'twitter-both', 'twitter-replies'):
self.feeds[url] = classes.Twitter(self, username, None, base_url=_base_url)
else:
self.feeds[url] = classes.WebFeed(self, url)
#Set the icon
only_greader = bool(len(self.urls))
for feed in self.feeds.values():
if not isinstance(feed, classes.GoogleReader):
only_greader = False
break
self.set_icon_name(['awn-feeds', 'awn-feeds-greader'][only_greader])
self.setup_dialog()
#Allow user to drag and drop feed URLs onto the applet icon
#E.g. In a browser, user drags and drops a link to an Atom feed onto the applet
self.get_icon().drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \
[("STRING", 0, 0), ("text/plain", 0, 0), ("text/uri-list", 0, 0)], \
gtk.gdk.ACTION_COPY)
self.get_icon().connect('drag_data_received', self.applet_drag_data_received)
self.get_icon().connect('drag-motion', self.applet_drag_motion)
self.get_icon().connect('drag-leave', self.applet_drag_leave)
self.dialog.connect('scroll-event', self.scroll)
self.connect('size-changed', self.size_changed)
#Set up the D-Bus service
self.service = classes.DBusService(self)
self.update_feeds()
def __init__(self, uid, panel_id):
"""Creating the applets core"""
awn.AppletSimple.__init__(self, "media-control", uid, panel_id)
self.set_tooltip_text(MediaControlApplet.APPLET_NAME)
self.set_icon_info(['main-icon', 'play', 'pause', 'prev', 'next'], [
'media-control', 'media-playback-start', 'media-playback-pause',
'media-skip-backward', 'media-skip-forward'
])
self.set_icon_state('main-icon')
self.ui_path = os.path.join(os.path.dirname(__file__),
"media-control.ui")
# get the missing album art pixbuf
try:
file_name = __file__[0:__file__.rfind('/')]
file_name += "/icons/missing-artwork.svg"
self.no_album_art_pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
file_name, 128, 128)
except:
self.no_album_art_pixbuf = None
self.album_art_pixbuf = None
self.timer_running = False
self.playing_changed_id = 0
self.dbus_names = {}
self.MediaPlayer = None
self.is_playing = False
# Player selection frame
self.players_frame = gtk.Frame()
self.controls = gtk.VBox()
self.controls.set_spacing(5)
self.label = gtk.Label()
self.label.set_ellipsize(pango.ELLIPSIZE_END)
self.label.set_max_width_chars(30)
self.label.set_padding(4, 0)
self.label.set_markup(MediaControlApplet.APPLET_NAME_MARKUP)
# album overlay
self.album_overlay = awn.OverlayPixbuf()
self.album_overlay.props.gravity = gtk.gdk.GRAVITY_SOUTH_EAST
self.album_overlay.props.alpha = 0.85
self.album_overlay.props.active = False
self.add_overlay(self.album_overlay)
# Dialog
self.dialog = awn.Dialog(self)
# Docklet related stuff
self.docklet = None
self.docklet_visible = False
self.docklet_image = None
self.docklet_label = None
self.docklet_play_pause = None
#Popup menu
self.about = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
self.about.connect("activate", self.show_about)
self.prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
self.prefs.connect("activate", self.show_prefs)
self.popup_menu = self.create_default_menu()
self.popup_menu.append(self.prefs)
self.popup_menu.append(gtk.SeparatorMenuItem())
self.popup_menu.append(self.about)
self.popup_menu.show_all()
self.ensure_player()
# Defining Widgets
vbox = gtk.VBox()
self.players_frame.add(vbox)
for player in self.get_supported_player_names():
button = gtk.Button(player)
button.connect("clicked", self.start_player_pressed, player)
vbox.add(button)
# dialog widgets
button_previous = gtk.ToolButton("gtk-media-previous")
button_play = gtk.ToolButton("gtk-media-play")
button_pause = gtk.ToolButton("gtk-media-pause")
button_next = gtk.ToolButton("gtk-media-next")
self.image = gtk.Image()
# Packing Widgets
hbox = gtk.HBox()
hbox.pack_start(button_previous)
hbox.add(button_play)
hbox.add(button_next)
self.controls.pack_start(self.image)
self.controls.add(hbox)
vbox = gtk.VBox()
vbox.set_spacing(5)
vbox.pack_start(self.label)
vbox.add(self.players_frame)
vbox.add(self.controls)
self.dialog.add(vbox)
hbox.show_all()
vbox.show_all()
# Button Connects
button_previous.connect("clicked", self.button_previous_press)
button_play.connect("clicked", self.button_pp_press)
button_next.connect("clicked", self.button_next_press)
# Standard AWN Connects
self.connect("scroll-event", self.wheel_turn)
self.connect("clicked", self.icon_clicked)
self.connect("middle-clicked", self.button_pp_press)
self.connect("context-menu-popup", self.menu_popup)
self.connect("enter-notify-event", self.enter_notify)
self.dialog.props.hide_on_unfocus = True
# Drag&drop support
self.get_icon().connect("drag-data-received", self.applet_drop_cb)
self.get_icon().connect("drag-motion", self.applet_drag_motion_cb)
self.get_icon().connect("drag-leave", self.applet_drag_leave_cb)
self.get_icon().drag_dest_set(
gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION,
[("text/uri-list", 0, 0),
("text/plain", 0, 1)], gtk.gdk.ACTION_COPY)
self.client = awn.config_get_default_for_applet(self)
self.client.bind(GROUP_DEFAULT, "use_docklet", self, "use-docklet",
True, BIND_METHOD_FALLBACK)
self.client.bind(GROUP_DEFAULT, "docklet_mouseout_close", self,
"docklet-close", True, BIND_METHOD_FALLBACK)
self.client.bind(GROUP_DEFAULT, "show_album_art", self,
"album-art-enabled", True, BIND_METHOD_FALLBACK)
self.client.bind(GROUP_DEFAULT, "album_art_size", self,
"album-art-size", True, BIND_METHOD_FALLBACK)
self.client.bind(GROUP_DEFAULT, "tooltip_format", self,
"tooltip-order", True, BIND_METHOD_FALLBACK)
try:
if self.MediaPlayer: self.update_song_info()
except:
pass
proxy = dbus.SessionBus().get_object('org.freedesktop.DBus',
'/org/freedesktop/DBus')
proxy.connect_to_signal('NameOwnerChanged', self.name_owner_changed_cb)
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
import awn
import gtk
def change_orient(widget, dialog):
i = dialog.props.position
i = (i + 1) % 4
dialog.props.position = i
def change_attach(widget, dialog):
dialog.props.anchored = not dialog.props.anchored
d = awn.Dialog()
d.set_title("Hello")
d.show_all()
win = gtk.Window()
win.connect('delete-event', lambda w, e: gtk.main_quit())
button = gtk.Label("One of the dialogs points to this window")
win.add(button)
win.show_all()
d2 = awn.Dialog(win)
d2.set_title("Another title")
d2.set_size_request(-1, 200)
button = gtk.Button("Change orient")
button.connect("clicked", change_orient, d2)
d2.add(button)
def __init__(self, uid, panel_id):
#AWN Applet Configuration
awn.Applet.__init__(self, 'file-browser-launcher', uid, panel_id)
self.icon_box = awn.IconBox(self)
self.add(self.icon_box)
self.icon = awn.ThemedIcon()
self.icon.set_tooltip_text(_("File Browser Launcher"))
self.icon.set_size(self.get_size())
self.dialog = awn.Dialog(self.icon, self)
#AwnConfigClient instance
self.client = awn.config_get_default_for_applet(self)
#Get the default icon theme
self.theme = gtk.icon_theme_get_default()
self.icons[24] = {}
try:
self.icons[24]['folder'] = self.theme.load_icon('folder', 24, 0)
except:
self.icons[24]['folder'] = None
#Docklet...
self.mode = self.client.get_int(group, 'mode')
self.client.notify_add(group, 'mode', self.update_mode)
if self.mode == 2:
self.docklet_visible = True
self.update_docklet(False)
else:
self.icon_box.add(self.icon)
#Set the icon
self.icon.set_info_simple('file-browser-launcher', uid, 'folder')
if gio:
#This part (and other progress overlay code) adapted from
#mhr3's 'Dropper' applet
#Set the progress overlay
self.timer_overlay = awn.OverlayProgressCircle()
self.timer_overlay.props.active = False
self.timer_overlay.props.apply_effects = False
self.icon.add_overlay(self.timer_overlay)
else:
#Read fstab for mounting info
#(It it assumed that fstab won't change after the applet is started)
self.fstab2 = open('/etc/fstab', 'r')
self.fstab = self.fstab2.read().split('\n')
self.fstab2.close()
#Check if nautilus-connect-server is installed
if os.path.exists('/usr/bin/nautilus-connect-server') or os.path.exists \
('/usr/local/bin/nautilus-connect-server'):
self.nautilus_connect_server = True
else:
self.nautilus_connect_server = False
if os.path.exists('/usr/share/applications/nautilus-computer.desktop') or \
os.path.exists('/usr/local/share/applications/nautilus-computer.desktop'):
self.nautilus_computer = True
else:
self.nautilus_computer = False
def trash_count_cb(*args):
if self.show_trash:
if gio:
self.do_gio_places()
else:
self.add_places()
self.trash = vfs.Trash.get_default()
self.trash.connect('file-count-changed', trash_count_cb)
#Make the dialog, will only be shown when approiate
#Make all the things needed for a treeview for the homefolder, root dir, bookmarks, and mounted drives
self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, gtk.gdk.Pixbuf, str, int)
#Renderers
renderer0 = gtk.CellRendererPixbuf()
renderer1 = gtk.CellRendererText()
self.eject_render = gtk.CellRendererPixbuf()
self.eject_render.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE)
#Add renderers to column
column = gtk.TreeViewColumn('0')
column.pack_start(renderer0, False)
column.add_attribute(renderer0, 'pixbuf', 0)
column.pack_start(renderer1, True)
column.add_attribute(renderer1, 'markup', 1)
column.pack_start(self.eject_render, False)
column.add_attribute(self.eject_render, 'pixbuf', 2)
#TreeView
self.treeview = gtk.TreeView(self.liststore)
self.treeview.set_hover_selection(True)
self.treeview.set_headers_visible(False)
self.treeview.append_column(column)
self.treeview.set_no_show_all(True)
self.treeview.connect('button-press-event', self.treeview_clicked)
self.vbox = gtk.VBox()
self.vbox.pack_start(self.treeview)
if gio:
self.monitor = gio.volume_monitor_get()
for signal in ('volume-added', 'volume-changed', 'volume-removed', 'mount-added',
'mount-changed', 'mount-removed'):
self.monitor.connect(signal, self.do_gio_places)
for key in ('show_computer', 'show_home', 'show_filesystem', 'show_local', 'show_network',
'show_connect', 'show_trash', 'show_bookmarks'):
self.client.notify_add(group, key, self.do_gio_places)
self.do_gio_places()
#(From YAMA by Onox)
#Monitor bookmarks file for changes
bookmarks_file = os.path.expanduser("~/.gtk-bookmarks")
#keep a reference to avoid getting it garbage collected
self.__bookmarks_monitor = gio.File(bookmarks_file).monitor_file()
def bookmarks_changed_cb(monitor, file, other_file, event):
if event in (gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT, gio.FILE_MONITOR_EVENT_CREATED,
gio.FILE_MONITOR_EVENT_DELETED):
#Refresh menu to re-initialize the widget
self.do_gio_places()
self.__bookmarks_monitor.connect("changed", bookmarks_changed_cb)
#Entry widget for displaying the path to open
self.entry = gtk.Entry()
self.entry.set_text(os.environ['HOME'])
self.entry.connect('key-release-event', self.detect_enter)
self.entry.show()
#Open button to run the file browser
self.enter = gtk.Button(stock=gtk.STOCK_OPEN)
self.enter.connect('clicked', self.launch_fb)
self.enter.show()
#HBox to put the two together
entry_hbox = gtk.HBox()
entry_hbox.pack_start(self.entry)
entry_hbox.pack_start(self.enter, False)
#And add the HBox to the vbox and add the vbox to the dialog
self.vbox.pack_end(entry_hbox)
self.dialog.add(self.vbox)
#Connect to signals
self.icon.connect('clicked', self.icon_clicked)
self.icon.connect('middle-clicked', self.icon_clicked)
self.icon.connect('context-menu-popup', self.show_context_menu)
self.connect('size-changed', self.size_changed)
self.dialog.connect('focus-out-event', self.dialog_focus_out)
self.theme.connect('changed', self.icon_theme_changed)
if gio:
#Allow the user to drag&drop a file/folder onto the applet. After
#a short delay, show the dialog, and allow the file/folder to be dropped
#on any place in the TreeView (other than root, Connect to Server..., and
#maybe unmounted places). The move the file/folder and (if successful)
#open the place in the file browser
#The Applet icon - just open the dialog after a short delay
self.icon.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \
[("text/uri-list", 0, 0)], \
gtk.gdk.ACTION_COPY)
self.icon.connect('drag-data-received', self.applet_drag_data_received)
self.icon.connect('drag-motion', self.applet_drag_motion)
self.icon.connect('drag-leave', self.applet_drag_leave)
#The TreeView - drop the file to move it to the folder
self.treeview.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \
[("text/uri-list", 0, 0)], \
gtk.gdk.ACTION_MOVE)
self.treeview.connect('drag-data-received', self.treeview_drag_data_received)
self.treeview.connect('drag-motion', self.treeview_drag_motion)
self.treeview.connect('drag-leave', self.treeview_drag_leave)
elif self.mode == 2:
self.add_places()
def __init__(self, uid, panel_id):
"""Creating the applets core"""
awn.AppletSimple.__init__(self, "media-player", uid, panel_id)
self.set_tooltip_text(MediaPlayerApplet.APPLET_NAME)
self.set_icon_name('media-player')
self.bind_keys()
# some initialization stuff
self.isVideo = False
self.size = self.get_size()
self.full_window = None
self.dialog = awn.Dialog(self)
self.play_icon = awn.OverlayThemedIcon("media-playback-start")
self.play_icon.props.scale = 0.4
self.play_icon.props.active = False
self.play_icon.props.gravity = gtk.gdk.GRAVITY_SOUTH_EAST
self.add_overlay(self.play_icon)
# Recent items menu
self.recent_items_menu = gtk.Menu()
for item in self.recentItems:
menu_item = gtk.MenuItem(item)
menu_item.connect("activate", self.playItem)
self.recent_items_menu.append(menu_item)
self.recent_items_menu.show_all()
# Popup menu
self.recent = gtk.MenuItem(_("Recent items"))
self.recent.set_submenu(self.recent_items_menu)
self.prefs = gtk.ImageMenuItem(gtk.STOCK_PREFERENCES)
self.prefs.connect("activate", self.show_prefs)
self.about = gtk.ImageMenuItem(gtk.STOCK_ABOUT)
self.about.connect("activate", self.show_about)
self.popup_menu = self.create_default_menu()
self.popup_menu.append(self.recent)
self.popup_menu.append(self.prefs)
item = gtk.SeparatorMenuItem()
item.show()
self.popup_menu.append(item)
self.popup_menu.append(self.about)
self.popup_menu.show_all()
# gstreamer stuff
self.viSink = gst.element_factory_make(self.video_sink, "viSink")
self.auSink = gst.element_factory_make(self.audio_sink, "auSink")
# Set up our playbin
self.playbin = gst.element_factory_make("playbin", "pbin")
self.playbin.set_property("video-sink", self.viSink)
self.playbin.set_property("audio-sink", self.auSink)
bus = self.playbin.get_bus()
bus.enable_sync_message_emission()
bus.add_watch(self.OnGstMessage)
bus.connect("sync-message::element", self.OnGstSyncMessage)
# Defining Widgets
self.vbox = gtk.VBox(spacing=6)
self.da = gtk.DrawingArea()
self.da.set_size_request(self.video_width, self.video_height)
self.da.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#000"))
self.da.set_events(gtk.gdk.ALL_EVENTS_MASK)
self.mouse_handler_id = self.da.connect("button-press-event",
self.video_clicked)
self.vbox.pack_start(self.da)
# Buttons
self.button_play = gtk.Button(stock='gtk-media-play')
self.button_stop = gtk.Button(stock='gtk-media-stop')
self.button_play.connect("clicked", self.button_play_pause_cb)
self.button_stop.connect("clicked", self.button_stop_cb)
# Packing Widgets
self.hbbox = gtk.HButtonBox()
self.hbbox.set_spacing(2)
self.hbbox.pack_start(self.button_play)
self.hbbox.pack_start(self.button_stop)
self.vbox.add(self.hbbox)
self.dialog.add(self.vbox)
# Video can't be played into RGBA widget
rgbColormap = self.vbox.get_screen().get_rgb_colormap()
self.da.set_colormap(rgbColormap)
self.da.realize()
# Standard AWN Connects
self.connect("clicked", self.icon_clicked)
self.connect("context-menu-popup", self.menu_popup)
self.connect("button-press-event", self.button_press)
self.dialog.props.hide_on_unfocus = True
# Drag&drop support
self.get_icon().drag_dest_set(
gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION,
[("text/uri-list", 0, 0),
("text/plain", 0, 1)], gtk.gdk.ACTION_COPY)
self.get_icon().connect("drag-data-received", self.applet_drop_cb)
self.get_icon().connect("drag-motion", self.applet_drag_motion_cb)
self.get_icon().connect("drag-leave", self.applet_drag_leave_cb)
def __init__(self, uid, panel_id):
#Awn Applet configuration
awn.AppletSimple.__init__(self, 'slickswitcher', uid, panel_id)
self.dialog = awn.Dialog(self)
self.dialog.set_skip_pager_hint(True)
self.set_tooltip_text(_("SlickSwitcher"))
self.size = self.get_size()
#Set up Switch - does wnck stuff
self.switch = switch.Switch()
#Set up Settings - does awn.Config stuff
self.settings = settings.Settings(self)
for key in ['use_custom', 'custom_back', 'custom_border']:
self.settings.config.notify_add(GROUP_DEFAULT, key, self.update_custom)
#Set up the dialog colors
self.dialog_style = self.dialog.get_style()
self.unmodified_style = self.dialog_style.copy()
self.dialog.connect('style-set', self.style_set)
#Set up Drawing - does the shiny drawing stuff
self.widget = drawing.Drawing(self.switch, self.settings, self)
self.dialog.add(self.widget)
#Set up the values for the ViewportSurface
self.update_backgrounds()
self.draw_background = False
self.number = self.switch.get_current_workspace_num()
num_columns = self.switch.get_num_columns()
self.row = int((self.number) / float(num_columns)) + 1
self.column = int((self.number) % num_columns) + 1
#Set up the text overlay
self.overlay = awn.OverlayText()
self.add_overlay(self.overlay)
self.overlay.props.font_sizing = 21.0
self.overlay.props.text = str(self.number)
self.overlay.props.active = not self.settings['use_custom_text']
self.overlay.props.apply_effects = True
self.overlay.connect('notify::text-color', self.overlay_notify)
self.overlay.connect('notify::text-outline-color', self.overlay_notify)
self.overlay.connect('notify::font-mode', self.overlay_notify)
self.overlay.connect('notify::text-outline-width', self.overlay_notify)
self.settings.config.notify_add(GROUP_DEFAULT, 'use_custom_text', self.toggle_custom_text)
#Connect to signals
#Applet signals
self.connect('realize', self.realize_event)
self.connect('size-changed', self.size_changed)
self.connect('clicked', self.toggle_dialog)
self.connect('context-menu-popup', self.show_menu)
self.connect('scroll-event', self.scroll)
self.dialog.props.hide_on_unfocus = True
#Any relevant signal from Wnck
self.switch.connect(self.update_icon)
#Start updating the icon every 2 second, in 2 seconds
gobject.timeout_add_seconds(2, self.timeout_icon)
#Force the widget to get the background color from the dialog
#self.dialog.realize()
self.widget.update_color()
