def open_menu(self, menu):
# always work on a copy
menu = menu[:]
if (menu): menu.append(MenuItem("/__separator"))
menu += self.__DISPLAY_MENU
mainmenu = gtk.Menu()
tree = {}
for entry in menu:
if (not entry.label):
item = gtk.SeparatorMenuItem()
elif (entry.icon):
if (gtk.stock_lookup(entry.icon)):
item = gtk.ImageMenuItem(entry.icon)
if (entry.label):
item.get_children()[0].set_text_with_mnemonic(entry.label)
else:
item = gtk.ImageMenuItem(entry.label)
try:
img = Tiling()
data = vfs.read_entire_file(self.get_full_path(entry.icon))
img.set_from_data(data)
img.render(16, 16, 1, 1)
img.show()
item.set_image(img)
except:
import traceback; traceback.print_exc()
else:
item = gtk.MenuItem(entry.label)
if (entry.callback):
item.connect("activate",
lambda src, cb, args: cb(*args),
entry.callback, entry.args)
item.show()
if (not entry.active): item.set_sensitive(False)
menupath = "/".join(entry.path.split("/")[:-1])
if (menupath):
parentitem = tree.get(menupath)
if (not parentitem.get_submenu()):
m = gtk.Menu()
parentitem.set_submenu(m)
else:
m = parentitem.get_submenu()
else:
m = mainmenu
m.append(item)
tree["/".join(entry.path.split("/"))] = item
mainmenu.popup(None, None, None, 0, 0)
class TargetImage(DisplayTarget):
def __init__(self, name, parent):
self.__size = (0, 0)
# the original image size
self.__original_size = (0, 0)
# the current saturation value
self.__current_saturation = 0.0
# the current opacity value
self.__current_opacity = 0.0
DisplayTarget.__init__(self, name, parent)
self.__widget = Tiling()
self.__widget.show()
self._register_property("uri", TYPE_STRING,
self._setp_uri, self._getp)
self._register_property("saturation", TYPE_FLOAT,
self._setp_saturation, self._getp)
self._register_property("scale", TYPE_FLOAT,
self._setp_scale, self._getp)
self._register_property("opacity", TYPE_FLOAT,
self._setp_opacity, self._getp)
self._register_property("image-width", TYPE_UNIT,
self._setp_image_size, self._getp_image_size)
self._register_property("image-height", TYPE_UNIT,
self._setp_image_size, self._getp_image_size)
self._setp("image-width", Unit.Unit())#-1, Unit.UNIT_PX))
self._setp("image-height", Unit.Unit())#-1, Unit.UNIT_PX))
self._setp("opacity", 1.0)
self._setp("saturation", 1.0)
self._setp("scale", 1.0)
# watch the parent for geometry changes
self.add_observer(self.__on_observe_size)
def get_widget(self):
return self.__widget
def delete(self):
DisplayTarget.delete(self)
#
# Observer for size.
#
def __on_observe_size(self, src, cmd, *args):
x, y, w, h = src.get_geometry()
if (cmd == src.OBS_GEOMETRY and
(w.as_px(), h.as_px()) != self.__size):
self.__compute_size()
utils.request_call(self.__render_image)
self.__size = (w.as_px(), h.as_px())
#
# Loads the image from the given URI.
#
def __load_image(self, uri):
if (not uri): return
try:
data = vfs.read_entire_file(uri)
except:
log("Couldn't read file %s.\n" % uri)
return
try:
self.__widget.set_from_data(data)
except RuntimeError, exc:
log(`exc`)
try:
self.__original_size = self.__widget.get_size()
except:
log("Couldn't get width and/or height of the image.")
return
class TargetGroup(ContainerTarget):
def __init__(self, name, parent):
# flag for ensuring that only one collapse action takes place
self.__block = 0
# the maximum size values of all the children
self.__max_size = (0, 0)
ContainerTarget.__init__(self, name, parent)
self.__layout = gtk.Layout()
self.__layout.show()
self.__image = Tiling()
self.__image.show()
self.__layout.put(self.__image, 0, 0)
self._register_property("bg-uri", TYPE_STRING,
self._setp_bg_uri, self._getp)
self._register_property("bg-color", TYPE_STRING,
self._setp_bg_color, self._getp)
self.add_observer(self.__on_observe_size)
def delete(self):
self.__layout.remove(self.__image)
del self.__image
del self.__layout
del self.__block
del self.__max_size
ContainerTarget.delete(self)
def get_widget(self): return self.__layout
def __on_observe_size(self, src, cmd):
if (cmd == src.OBS_GEOMETRY):
x, y, w, h = self.get_geometry()
if (self._getp("bg-uri") or self._getp("bg-color")):
ow, oh = self.__image.size_request()
if ((w.as_px(), h.as_px()) != (ow, oh)):
self.__image.tile(w.as_px(), h.as_px())
def new_child(self, childtype, settings, children):
child = ContainerTarget.new_child(self, childtype, settings, children)
if (not child.is_standalone()):
x, y, w, h = child.get_geometry()
self.__layout.put(child.get_widget(), x.as_px(), y.as_px())
return child
def child_observer(self, src, cmd):
if (cmd == src.OBS_GEOMETRY):
x, y, w, h = src.get_geometry()
if (src.get_widget() in self.__layout.get_children()):
self.__layout.move(src.get_widget(), x.as_px(), y.as_px())
#
# Sets the background color.
#
def __set_color(self, color):
r, g, b, a = utils.parse_color(color)
w, h = self.__layout.size_request()
self.__image.set_from_color(r, g, b, a)
self.__image.tile(w, h)
#
# Sets the background image.
#
def __set_background(self, uri):
if (not uri):
self.__set_color("#00000000")
return
from utils import vfs
if (vfs.exists(uri)):
try:
data = vfs.read_entire_file(uri)
except:
return
w, h = self.__layout.size_request()
self.__image.set_from_data(data)
self.__image.tile(w, h)
#
# "bg-uri" property.
#
def _setp_bg_uri(self, key, value):
path = self._get_display().get_full_path(value)
self.__set_background(path)
self._setp(key, value)
#
# "bg-color" property.
#
def _setp_bg_color(self, key, value):
self.__set_color(value)
self._setp(key, value)
