112 lines
4.2 KiB
Python
112 lines
4.2 KiB
Python
import pygtk
|
|
import gtk
|
|
import pango
|
|
import clutter
|
|
import os
|
|
from ui_elements.ReflectionTexture import Texture_Reflection
|
|
|
|
class ImageFrame(clutter.Group):
|
|
QUALITY_FAST, QUALITY_NORMAL, QUALITY_SLOW = range(3)
|
|
quality = QUALITY_NORMAL
|
|
orig_pixbuf = None
|
|
|
|
def __init__(self, pixbuf, img_size, use_reflection = False, quality = QUALITY_NORMAL, anchor = None):
|
|
clutter.Group.__init__(self)
|
|
self.width = img_size
|
|
self.height = img_size
|
|
self.img_size = img_size
|
|
self.use_reflection = use_reflection
|
|
self.quality = quality
|
|
self.orig_pixbuf = pixbuf
|
|
|
|
|
|
self.main_pic = clutter.Texture()
|
|
self.reflection = None
|
|
#self.reflection = Texture_Reflection(self.main_pic)
|
|
|
|
self.set_pixbuf(pixbuf)
|
|
self.add(self.main_pic)
|
|
|
|
def resize_pixbuf(self, pixbuf):
|
|
#New method of resizing changes size of pixbuf rather than texture.... MUCH better performance :)
|
|
(self.x, self.y) = (0, 0)
|
|
if pixbuf.get_height() > pixbuf.get_width():
|
|
xy_ratio = float(pixbuf.get_width()) / pixbuf.get_height()
|
|
height = self.img_size
|
|
width = int(self.img_size * xy_ratio)
|
|
self.x = (self.img_size - width)/2
|
|
#x = int(cover_size / 2)
|
|
#x = x + (cover_size - width)
|
|
else:
|
|
xy_ratio = float(pixbuf.get_height()) / float(pixbuf.get_width())
|
|
width = self.img_size
|
|
height = int(self.img_size * xy_ratio)
|
|
self.y = (self.img_size - height)/2
|
|
#y = y + (cover_size - height)
|
|
|
|
#Set the conversion mode / quality
|
|
if self.quality == self.QUALITY_FAST: conversion_mode = gtk.gdk.INTERP_NEAREST #gtk.gdk.INTERP_TILES
|
|
elif self.quality == self.QUALITY_NORMAL: conversion_mode = gtk.gdk.INTERP_BILINEAR
|
|
elif self.quality == self.QUALITY_SLOW: conversion_mode = gtk.gdk.INTERP_HYPER
|
|
|
|
#Check to see whether the dimensions are already within 10% of the new ones
|
|
"""
|
|
height_max = int(pixbuf.get_height() * 1.1)
|
|
height_min = int(pixbuf.get_height() * 0.9)
|
|
width_max = int(pixbuf.get_width() * 1.1)
|
|
width_min = int(pixbuf.get_width() * 0.9)
|
|
#If not, perform the resize
|
|
if ((height < height_max) and (height > height_min)) or ((width < width_max) and (width > width_min)):
|
|
#Changed my mind, it has to be the exact right size
|
|
"""
|
|
if (height == pixbuf.get_height()) or (width == pixbuf.get_width()):
|
|
return pixbuf
|
|
else:
|
|
pixbuf = pixbuf.scale_simple(width, height, conversion_mode)
|
|
|
|
return pixbuf
|
|
|
|
def set_pixbuf(self, pixbuf):
|
|
self.orig_pixbuf = pixbuf
|
|
if pixbuf is None:
|
|
self.main_pic.hide()
|
|
if not self.reflection is None: self.reflection.hide()
|
|
return
|
|
else:
|
|
self.pixbuf = self.resize_pixbuf(pixbuf)
|
|
self.main_pic.set_pixbuf(self.pixbuf)
|
|
self.main_pic.set_position(self.x, self.y)
|
|
self.main_pic.show()
|
|
|
|
#For the most part the Reflection texture automatically takes car of pixbuf changes
|
|
#So we only need to set the flection the first time arouns (ie self.reflection is None)
|
|
if self.use_reflection:
|
|
self.set_reflection(True)
|
|
else:
|
|
self.reflection = None
|
|
|
|
#Turns reflections on and off
|
|
def set_reflection(self, toggle):
|
|
#If the current state is the requested state, do nothing
|
|
if self.reflection == toggle:
|
|
return
|
|
|
|
self.use_reflection = toggle
|
|
if self.use_reflection:
|
|
if not self.reflection is None:
|
|
self.remove(self.reflection)
|
|
self.reflection = None
|
|
self.reflection = Texture_Reflection(self.main_pic)
|
|
self.add(self.reflection)
|
|
self.reflection.show()
|
|
else:
|
|
self.remove(self.reflection)
|
|
self.reflection = None
|
|
|
|
def get_texture(self):
|
|
return self.main_pic
|
|
|
|
def get_width(self):
|
|
return self.img_size
|
|
def get_height(self):
|
|
return self.img_size |