~kripkenstein/topshelf/main

#!/usr/bin/env python

#------------------------------------------------------------------------------------

#

# TopShelf - A 'Currently Important Files' Applet

#

# Copyright (C) 2007  Alon Zakai ('Kripken')

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

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

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

#

#-------------------------------------------------------------------------------------

import sys

import pickle

import os.path

import subprocess

import mimetypes

import urllib

import gobject

import gtk, gtk.gdk

import pygtk

pygtk.require('2.0')

import gnomeapplet

## Global constants

OPEN_APP = "gnome-open"

HELP_APP = "yelp"

HELP_FILE = "/usr/share/doc/topshelf/topshelf.docbook"

## Global utilities

def popup_warning(window, message):

	dlg = gtk.MessageDialog(parent         = window,

	                        flags          = gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,

	                        buttons        = gtk.BUTTONS_OK,

	                        message_format = message,

	                        type           = gtk.MESSAGE_WARNING)

	window.present() # Ensure we are on top, for our losing keep_above to not hide us

	window.set_keep_above(False)

	result = dlg.run()

	dlg.destroy()

	window.set_keep_above(True)

def popup_question(window, message):

	dlg = gtk.MessageDialog(parent         = window,

	                        flags          = gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,

	                        buttons        = gtk.BUTTONS_YES_NO,

	                        message_format = message,

	                        type           = gtk.MESSAGE_QUESTION)

	window.present() # Ensure we are on top, for our losing keep_above to not hide us

	window.set_keep_above(False)

	result = dlg.run()

	dlg.destroy()

	window.set_keep_above(True)

	if result == gtk.RESPONSE_YES:

		return True

	elif result == gtk.RESPONSE_NO:

		return False

	elif result == gtk.RESPONSE_DELETE_EVENT:

		return False

	else:

		return False

def try_load_icon(icon_theme, icon_name, icon_size):

	try:

		return icon_theme.load_icon(icon_name, icon_size, 0)

	except gobject.GError:

		return None

def guess_mime_icon(filename):

	ICON_SIZE = 24

	icon_theme = gtk.icon_theme_get_default()

	if os.path.isdir(to_filename(filename)):

		ret = try_load_icon(icon_theme, "gnome-fs-directory", ICON_SIZE)

		if ret is None:

			ret = try_load_icon(icon_theme, "gtk-directory", ICON_SIZE)

		return ret

	filename = mimetypes.guess_type(os.path.basename(filename))[0]

	if filename is None:

		return try_load_icon(icon_theme, "unknown", ICON_SIZE)

	ret = try_load_icon(icon_theme, filename, ICON_SIZE)

	filename = filename.replace("/", "-")

	if ret is None:

		ret = try_load_icon(icon_theme, filename, ICON_SIZE)

	if ret is None:

		ret = try_load_icon(icon_theme, "gnome-mime-" + filename, ICON_SIZE)

	if ret is None:

		ret = try_load_icon(icon_theme, "gnome-mime-" + filename[0:filename.index("-")], ICON_SIZE)

	if ret is None:

		ret = try_load_icon(icon_theme, "unknown", ICON_SIZE)

	return ret

def to_filename(uri_or_something):

	return uri_or_something.replace("file://", "")

### Persistent data

PERSISTENT_FILE = os.path.join(os.path.expanduser("~"), ".topshelf.conf")

# Tests whether persistent data is 0.1, and hence needs migration

def test_point1(data):

	try:

		temp = data.data

		return False

	except AttributeError:

		print "Migration needed to 0.2"

		return True

# Migrates persistent data from 0.1 to 0.2

def migrate_point1_to_point2(old):

	print "Migrating to 0.2;", len(old.current_files), "files transferred"

	new = ModernPersistentData()

	new.set(current_files, old.current_files)

	new.set('w',           old.w)

	new.set('h',           old.h)

	return new

class PersistentData: ## Legacy!

	def __init__(self):

		self.current_files = []

		self.w = -1

		self.h = -1

current_files = "current_files" # A constant, really...

DEFAULT_VALUES = { current_files: [],

                   'x': 400,   # For standalone app

                   'y': 300,   # For standalone app

                   'w': 600,

                   'h': 350  }

class ModernPersistentData:

	def __init__(self):

		self.data = { }

	def get(self, key):

		try:

			return self.data[key]

		except KeyError:

			try:

				self.data[key] = DEFAULT_VALUES[key]

				return self.data[key]

			except KeyError:

				print "Fatal error: Key with no default value in ModernPersistentData"

	def set(self, key, value):

		self.data[key] = value

### Data for a single file

NORMAL_BG_COLOR  = "black"

DISABLE_BG_COLOR = "#FF0000"

class FileData:

	def __init__(self, filename, position, short_filename=None, mime_icon=None, color=None):

		self.filename  = filename

		self.position  = position

	def listify(self):

		return (self.filename, self.position, os.path.basename(self.filename), guess_mime_icon(self.filename), NORMAL_BG_COLOR)

### Main class

# full-path, position, short-filename, mime-type-icon, color

FILE_STORE_FULLPATH  = 0

FILE_STORE_POSITION  = 1

FILE_STORE_SHORTNAME = 2

FILE_STORE_MIME_ICON = 3

FILE_STORE_COLOR     = 4

class TopShelf:

	def __init__(self, applet, standalone_window=None):

		self.applet = applet

		self.applet.ts = self # Needed for standalone

		self.standalone_window = standalone_window

		self.window = None

		self.pressed  = False

		self.resizing = False

		self.panel_pb     = gtk.gdk.pixbuf_new_from_file("/usr/share/pixmaps/topshelf-24.png")

		self.panel_off_pb = gtk.gdk.pixbuf_new_from_file("/usr/share/pixmaps/topshelf-24-off.png")

		self.panel_image = gtk.Image()

		self.panel_image.set_from_pixbuf(self.panel_pb)

		self.panel_image.set_tooltip_text("TopShelf")

		self.eventbox = gtk.EventBox()

		self.eventbox.connect("button-press-event", self.do_button_press)

		self.eventbox.drag_dest_set(gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 81)], gtk.gdk.ACTION_LINK)

		self.eventbox.connect("drag-data-received", self.do_drag_data_received)

		self.eventbox.connect("key-press-event", self.do_key_press)

		self.eventbox.add(self.panel_image)

		self.applet.add(self.eventbox)

		self.applet.show_all()

		# full-path, position, short-filename, mime-type-icon, color

		self.files_store = gtk.ListStore(str, int, str, gtk.gdk.Pixbuf, str)

		try:

			self.unpickle()

		except IOError:

			self.persistent_data = ModernPersistentData()

		if self.standalone_window is not None:

			self.standalone_window.move(self.persistent_data.get('x'), self.persistent_data.get('y'))

			self.standalone_window.connect("configure-event", self.standalone_window_configure_event)

			self.standalone_window.set_keep_above(True)

	# Events

	def do_button_toggle(self, param1=None):

		if not self.pressed:

			self.show_window()

		else:

			self.hide_window()

	def do_button_press(self, btn, event):

		if event.type == gtk.gdk.BUTTON_PRESS and event.button == 1:

			if not self.resizing:

				self.do_button_toggle()

			else:

				self.do_stop_resizing()

		elif event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:

			btn.emit_stop_by_name("button_press_event")

			propxml="""

				<popup name="button3">

				<menuitem name="Item 3" verb="Help"  label="_Help" pixtype="stock" pixname="gtk-help"/>

				<menuitem name="Item 4" verb="About" label="_About" pixtype="stock" pixname="gtk-about"/>

				</popup>"""

			verbs = [("About", self.do_about),

			         ("Help",  self.do_help)  ]

			self.applet.setup_menu(propxml, verbs, None)

	def standalone_window_configure_event(self, param1=None, param2=None):

		x, y = self.standalone_window.get_position()

		if x != self.persistent_data.get('x') or y != self.persistent_data.get('y'):

			self.persistent_data.set('x', x)

			self.persistent_data.set('y', y)

			self.pickle() # This might thrash, if we get many many events at once. TODO.

	# Actions

	def do_about(self, applet, menu_action):

		self.hide_window() # So we are not concealed!

		logo_pb = gtk.gdk.pixbuf_new_from_file("/usr/share/pixmaps/topshelf-64.png")

		dlg = gtk.AboutDialog()

		dlg.set_icon(logo_pb)

		dlg.set_name("TopShelf")

		dlg.set_program_name("TopShelf")

		dlg.set_version("0.2 - Development")

		dlg.set_comments("Currently Important Files Applet")

		dlg.set_authors(["Alon Zakai (Kripken)"])

		dlg.set_license("TopShelf is free software; you can redistribute it and/or\nmodify it under the terms of the GNU General Public License\nas published by the Free Software Foundation; either version\n2 of the License, or (at your option) any later version.")

		dlg.set_copyright("(c) 2007 Alon Zakai ('Kripken')")

		dlg.set_website("http://launchpad.net/topshelf")

		dlg.set_logo(logo_pb)

		dlg.run()

		dlg.destroy()

		return False

	def do_open(self, param1=None, param2=None, param3=None):

		model, iter = self.get_selected()

		if iter is not None:

			filename = model.get_value(iter, 0)

			ret = subprocess.call(OPEN_APP + " '" + filename + "'", shell=True)

			self.hide_window() # After opening, we hide... for convenience

			if ret != 0:

				popup_warning(self.window, "The file '" + filename + "' could not be opened due to an error.")

		return False

	def do_open_folder(self, param1=None, param2=None, param3=None):

		model, iter = self.get_selected()

		if iter is not None:

			dirname = os.path.dirname(model.get_value(iter, 0))

			ret = subprocess.call(OPEN_APP + " '" + dirname + "'", shell=True)

			self.hide_window() # After opening, we hide... for convenience

			if ret != 0:

				popup_warning(self.window, "The directory '" + dirname + "' could not be opened due to an error.")

		return False

	def do_move_up(self, param1=None):

		model, iter = self.get_selected()

		if iter is not None:

			old_val = model.get(iter, 1)[0]

			new_val = old_val - 1

			self.swap_file_position(model, iter, old_val, new_val)

		return False

	def do_move_down(self, param1=None):

		model, iter = self.get_selected()

		if iter is not None:

			old_val = model.get(iter, 1)[0]

			new_val = old_val + 1

			self.swap_file_position(model, iter, old_val, new_val)

		return False

	def do_add(self, wgt):

		self.hide_window() # So we are not concealed

		chooser = gtk.FileChooserDialog("Select a file to add to TopShelf:",

		                                self.window,

		                                gtk.FILE_CHOOSER_ACTION_OPEN,

		                                buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_OPEN,gtk.RESPONSE_OK))

# 	    chooser.set_current_folder(...)

# 	    chooser.set_select_multiple(True)

		response = chooser.run()

		filename = chooser.get_filenames() if response == gtk.RESPONSE_OK else None

		chooser.destroy()

		self.show_window()

		if filename is not None:

			self.add_file(filename[0])

		return False

	def do_remove(self, wgt):

		model, iter = self.get_selected()

		if iter is not None:

			if popup_question(self.window,

			                  "Are you sure you want to remove the file '" + model.get(iter, 2)[0] +

			                  "' from the list? (The actual file will not be touched)"):

				old_position = model.get(iter, 1)[0]

				self.files_store.remove(iter)

				self.remove_file_position(model, old_position)

				self.pickle()

		return False

	def do_drag_data_received(self, widget, drag_context, x, y, selection_data, info, timestamp):

		uris = selection_data.data.strip().split()

		for uri in uris:

			filename = urllib.url2pathname(uri)

			self.add_file(filename)

	def do_package(self, param1=None):

		if self.get_n_files() == 0:

			return

		chooser = gtk.FileChooserDialog("Select a filename to save the zipped files as:",

		                                self.window,

		                                gtk.FILE_CHOOSER_ACTION_SAVE,

		                                buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE,gtk.RESPONSE_OK))

		response = chooser.run()

		package_name = chooser.get_filenames()[0] if response == gtk.RESPONSE_OK else None

		chooser.destroy()

		if package_name is None:

			return

		file_names = ""

		iter = self.files_store.get_iter_first()

		while iter is not None:

			file_names = file_names + " '" + urllib.url2pathname(self.files_store.get(iter, 0)[0]) + "' "

			iter = self.files_store.iter_next(iter)

		file_names = to_filename(file_names)

		command = "zip '" + package_name + "' " + file_names

		subprocess.call(command, shell=True)

		return False

	def do_help(self, param1=None, param2=None, param3=None):

		self.hide_window()

		ret = subprocess.call(HELP_APP + " '" + HELP_FILE + "'", shell=True)

		if ret != 0:

			popup_warning(self.window, "The help file could not be opened due to an error.")

		return False

	def do_key_press(self, widget, event):

		if event.keyval == 65307:

			self.hide_window()

		elif event.keyval == 65535:

			self.do_remove(None)

	# Persistency

	def unpickle(self):

		pickle_file = open(PERSISTENT_FILE, 'rb')

		self.persistent_data = pickle.load(pickle_file)

		pickle_file.close()

		# Migrate, if needed

		if test_point1(self.persistent_data):

			self.persistent_data = migrate_point1_to_point2(self.persistent_data)

		for file_data in self.persistent_data.get(current_files):

			self.files_store.insert(0, file_data.listify())

	def pickle(self):

		self.persistent_data.set(current_files, [])

		iter = self.files_store.get_iter_first()

		while iter is not None:

			self.persistent_data.get(current_files).append(FileData(*self.files_store.get(iter, *range(self.files_store.get_n_columns()))))

			iter = self.files_store.iter_next(iter)

		pickle_file = open(PERSISTENT_FILE, 'wb')

		pickle.dump(self.persistent_data, pickle_file)

		pickle_file.close()

	# File management

	def add_file(self, filename):

		self.files_store.insert(0, FileData(filename, self.get_n_files()).listify())

		self.pickle()

	def get_file_iter_by_filename(self, filename):

		class Ret:

			def __init__(self):

				self.val = None

			def search(self, m, p, i, filename):

				if m.get(i, 0)[0] == filename:

					self.val = i

		ret = Ret()

		self.files_store.foreach(ret.search, (filename))

		return ret.val

	# Window functions

	def show_window(self):

		if self.window is None:

			self.create_window()

		if not self.resizing:

			self.panel_image.set_from_pixbuf(self.panel_off_pb)

		self.pressed = True

		# These four commands - present, keep-above, present, position - are very odd. But they work, in THIS order.

		self.window.present()

		self.window.set_keep_above(True) # Force it!

		self.window.present()

		self.position_window() # Needed here because of odd behavior otherwise (after adding, hide, show, it moved)

		self.check_files_thread() # One manual operation, then later as a background thread

#		gobject.timeout_add(2000, self.check_files_thread) No thread for now, since it wastes CPU. Later, add an option to do this.

	def hide_window(self, param1=False, param2=False):

		if self.window is None:

			return True

		self.window.hide()

		self.panel_image.set_from_pixbuf(self.panel_pb)

		self.pressed = False

		return True # Stop delete events

	def create_window(self):

		self.window = gtk.Window()

		self.window.set_title("TopShelf")

		self.window.connect("delete-event",       self.hide_window)

		self.window.connect("window-state-event", self.window_state_event)

		self.window.connect("configure-event",    self.configure_event)

		self.window.connect("key-press-event",    self.do_key_press)

		self.window.set_keep_above(True)

		self.window.resize(self.persistent_data.get('w'), self.persistent_data.get('h'))

		self.window.drag_dest_set(gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 81)], gtk.gdk.ACTION_LINK)

		self.window.connect("drag-data-received", self.do_drag_data_received)

		# Main view

		self.treeview = gtk.TreeView()

		self.treeview.set_model(self.files_store)

		col = self.append_column(self.treeview, gtk.TreeViewColumn("#",    gtk.CellRendererText(),   text  =1), 1)

		tmp = self.append_column(self.treeview, gtk.TreeViewColumn("",     gtk.CellRendererPixbuf(), pixbuf=3))

		tmp = self.append_column(self.treeview, gtk.TreeViewColumn("File", gtk.CellRendererText(),   text  =2), 2,

		                         foreground_id=FILE_STORE_COLOR)

		col.clicked() # Set default sort

		self.treeview.connect("row-activated", self.do_open)

		scrolled_window = gtk.ScrolledWindow()

		scrolled_window.add(self.treeview)

		scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)

		# Toolbar & buttons on bottom

		toolbar = gtk.Toolbar()

		self.add_stock_button    (toolbar, gtk.STOCK_OPEN,                            self.do_open       , "Open file")

		self.add_altstock_button (toolbar, gtk.STOCK_DIRECTORY,      "Open Folder",   self.do_open_folder, "Open folder containing file")

		self.add_stock_button    (toolbar, gtk.STOCK_GO_UP,                           self.do_move_up    , "Move file up in order")

		self.add_stock_button    (toolbar, gtk.STOCK_GO_DOWN,                         self.do_move_down  , "Move file down in order")

		self.add_stock_button    (toolbar, gtk.STOCK_ADD,                             self.do_add        , "Add a file to the list")

		self.add_stock_button    (toolbar, gtk.STOCK_REMOVE,                          self.do_remove     , "Remove file from the list")

#		self.add_pixbuf_button   (toolbar, guess_mime_icon("a.zip"), "Package Files", self.do_package)

#		self.add_stock_button    (toolbar, gtk.STOCK_HELP,                            self.do_help       , "Help")

		# Main vbox

		vbox = gtk.VBox()

#		label = gtk.Label("<b>TopShelf: Currently Important Files</b>")

#		label.set_use_markup(True)

#		vbox.add(label)

#		vbox.child_set_property(label, "expand", False)

#		vbox.child_set_property(label, "border", 2)

		vbox.add(scrolled_window)

		vbox.add(toolbar)

		vbox.child_set_property(toolbar, "expand", False)

		# Frames

		inner_frame = gtk.Frame()

		inner_frame.set_shadow_type(gtk.SHADOW_IN)

		inner_frame.set_border_width(self.panel_image.get_allocation().height/8)

		outer_frame = gtk.Frame()

		outer_frame.set_shadow_type(gtk.SHADOW_OUT)

		inner_frame.add(vbox)

		outer_frame.add(inner_frame)

		# Finalize main window

		self.window.add(outer_frame)

		self.position_window()

		self.window.show_all()

	def window_state_event(self, widget, event):

		if event.changed_mask & gtk.gdk.WINDOW_STATE_ICONIFIED:

			self.hide_window()

			self.window.deiconify()

	def configure_event(self, widget, event):

		w, h = self.window.get_size()

		if w != self.persistent_data.get('w') or h != self.persistent_data.get('h'):

			self.persistent_data.set('w', w)

			self.persistent_data.set('h', h)

			self.pickle()

	def add_button(self, toolbar, image, text, callback, tooltip):

		btn = gtk.ToolButton()

		btn.set_icon_widget(image)

		btn.set_label(text)

		btn.connect("clicked", callback)

		btn.set_tooltip_text(tooltip)

		toolbar.insert(btn, -1)

	def add_altstock_button(self, toolbar, icon_id, text, callback, tooltip):

		icon = gtk.Image()

		icon.set_from_stock(icon_id, gtk.ICON_SIZE_LARGE_TOOLBAR)

		self.add_button(toolbar, icon, text, callback, tooltip)

#	def add_pixbuf_button(self, toolbar, pixbuf, text, callback, ):

#		icon = gtk.Image()

#		icon.set_from_pixbuf(pixbuf)

#		self.add_button(toolbar, icon, text, callback)

	def add_stock_button(self, toolbar, stock_id, callback, tooltip):

		btn = gtk.ToolButton(stock_id)