def __init__(self):
component.Component.__init__(self, "ToolBar")
self.window = component.get("MainWindow")
self.glade = self.window.get_glade()
self.toolbar = self.glade.get_widget("ToolBar")
self.glade.signal_autoconnect(self)
self.sources_button = self.glade.get_widget("SourcesToolbutton")
self.accounts_button = self.glade.get_widget("AccountsToolbutton")
self.connections_button = self.glade.get_widget("ConnectionsToolbutton")
spacer = self.glade.get_widget('spacer')
spacer.set_expand(True)
sources_image = gtk.Image()
sources_image.set_from_pixbuf(gdk.pixbuf_new_from_file_at_size(
common.get_pixmap('manage-sources.png'), 32, 32)
)
sources_image.show()
self.sources_button.set_icon_widget(sources_image)
accounts_image = gtk.Image()
accounts_image.set_from_pixbuf(gdk.pixbuf_new_from_file_at_size(
common.get_pixmap('manage-accounts.png'), 32, 32)
)
accounts_image.show()
self.accounts_button.set_icon_widget(accounts_image)
connections_image = gtk.Image()
connections_image.set_from_pixbuf(gdk.pixbuf_new_from_file_at_size(
common.get_pixmap('manage-connections.png'), 32, 32)
)
connections_image.show()
self.connections_button.set_icon_widget(connections_image)
def __init__(self, ajuste):
gtk.HScale.__init__(self)
self.modify_bg(0, get_colors("barradeprogreso"))
self.ajuste = ajuste
self.set_digits(0)
self.set_draw_value(False)
# FIXME: Verificar
self.presed = False
self.ancho, self.borde = (10, 10)
icono = os.path.join(BASE_PATH,
"Iconos", "iconplay.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono,
24, 24)
self.pixbuf = pixbuf.rotate_simple(
gdk.PIXBUF_ROTATE_CLOCKWISE)
self.connect("button-press-event", self.__button_press_event)
self.connect("button-release-event", self.__button_release_event)
self.connect("motion-notify-event", self.__motion_notify_event)
self.connect("expose_event", self.__expose)
self.show_all()
def __init__(self, parent, backend):
self.backend = backend
self.dialog = GtkAboutDialog()
self.dialog.set_transient_for(parent)
self.dialog.set_modal(True)
self.dialog.set_name(_("Subscription Manager"))
self.dialog.set_license(LICENSE)
self.dialog.set_wrap_license(True)
self.dialog.set_website("https://fedorahosted.org/subscription-manager/")
self.dialog.set_copyright(_("Copyright (c) 2012 Red Hat, Inc."))
self.dialog.set_logo(gdk.pixbuf_new_from_file_at_size(LOGO_PATH, 100, 100))
rhsm_version_label = Label()
backend_version_label = Label()
context_box = self.dialog.vbox.get_children()[0]
context_box.pack_end(rhsm_version_label)
context_box.pack_end(backend_version_label)
# Set the component versions.
versions = get_version_dict(self.backend.uep)
self.dialog.set_version(versions['subscription manager'])
rhsm_version_label.set_markup(_("<b>python-rhsm version:</b> %s" % \
versions['python-rhsm']))
backend_version_label.set_markup(_("<b>remote entitlement server version:</b> %s" % \
versions['candlepin']))
self.dialog.connect("response", self._handle_response)
self.dialog.show_all()
def _create_logo(self):
pb = gdk.pixbuf_new_from_file_at_size(
os.path.join(
pida.__path__[0],
'resources/pixmaps/pida-icon.svg'),
128, 128)
return pb
def get_pixbuf_at_size(filename, size):
try:
return pixbuf_new_from_file_at_size(get_pixmap(filename), size, size)
except GError as ex:
# Failed to load the pixbuf (Bad image file), so return a blank pixbuf.
log.warning(ex)
return create_blank_pixbuf(size)
def __init__(self, ajuste):
gtk.HScale.__init__(self)
self.modify_bg(0, get_colors("toolbars"))
self.ajuste = ajuste
self.set_digits(0)
self.set_draw_value(False)
# FIXME: Verificar
self.presed = False
self.ancho, self.borde = (10, 10)
icono = os.path.join(BASE_PATH,
"Iconos", "controlslicer.svg")
self.pixbuf = gdk.pixbuf_new_from_file_at_size(icono,
24, 24)
self.connect("button-press-event", self.__button_press_event)
self.connect("button-release-event", self.__button_release_event)
self.connect("motion-notify-event", self.__motion_notify_event)
self.connect("expose_event", self.__expose)
self.show_all()
def get_pixbuf_at_size(filename, size):
try:
return pixbuf_new_from_file_at_size(get_pixmap(filename), size, size)
except GError as ex:
# Failed to load the pixbuf (Bad image file), so return a blank pixbuf.
log.warning(ex)
return create_blank_pixbuf(size)
def __init__(self, parent, backend):
self.backend = backend
self.dialog = GtkAboutDialog()
self.dialog.set_transient_for(parent)
self.dialog.set_modal(True)
self.dialog.set_name(_("Subscription Manager"))
self.dialog.set_license(LICENSE)
self.dialog.set_wrap_license(True)
self.dialog.set_website("https://fedorahosted.org/subscription-manager/")
self.dialog.set_copyright(_("Copyright (c) 2012 Red Hat, Inc."))
self.dialog.set_logo(gdk.pixbuf_new_from_file_at_size(LOGO_PATH, 100, 100))
rhsm_version_label = Label()
backend_version_label = Label()
context_box = self.dialog.vbox.get_children()[0]
context_box.pack_end(rhsm_version_label)
context_box.pack_end(backend_version_label)
# Set the component versions.
server_versions = get_server_versions(self.backend.uep)
client_versions = get_client_versions()
self.dialog.set_version(client_versions['subscription-manager'])
rhsm_version_label.set_markup(_("<b>python-rhsm version:</b> %s" % \
client_versions['python-rhsm']))
backend_version_label.set_markup(_("<b>subscription management service version:</b> %s" % \
server_versions['candlepin']))
self.dialog.connect("response", self._handle_response)
self.dialog.show_all()
def __init__(self):
gtk.Toolbar.__init__(self)
self.modify_bg(0, get_colors("window"))
self.insert(get_separador(draw=False,
ancho=3, expand=False), -1)
imagen = gtk.Image()
icono = os.path.join(BASE_PATH,
"Iconos", "yt_videos_black.png")
pixbuf = gdk.pixbuf_new_from_file_at_size(
icono, -1, 24)
imagen.set_from_pixbuf(pixbuf)
imagen.show()
item = gtk.ToolItem()
item.add(imagen)
self.insert(item, -1)
self.insert(get_separador(draw=False,
ancho=3, expand=False), -1)
item = gtk.ToolItem()
item.set_expand(True)
self.label = gtk.Label("")
self.label.set_justify(gtk.JUSTIFY_LEFT)
#self.label.set_line_wrap(True)
self.label.show()
item.add(self.label)
self.insert(item, -1)
self.show_all()
def __ejecutar_agregar_elemento(self, elementos):
"""
Agrega los items a la lista, uno a uno, actualizando.
"""
if not elementos:
self.permitir_select = True
self.seleccionar_primero()
self.get_toplevel().set_sensitive(True)
return False
texto, path = elementos[0]
icono = os.path.join(BASE_PATH,
"Iconos", "video.svg")
try:
pixbuf = gdk.pixbuf_new_from_file_at_size(icono,
24, -1)
self.modelo.append([pixbuf, texto, path])
except:
pass
elementos.remove(elementos[0])
gobject.idle_add(self.__ejecutar_agregar_elemento, elementos)
return False
def get_boton(archivo, flip=False, rotacion=None,
pixels=16, tooltip_text=None):
"""
Devuelve un toolbutton generico.
"""
import gtk
from gtk import gdk
boton = gtk.ToolButton()
imagen = gtk.Image()
pixbuf = gdk.pixbuf_new_from_file_at_size(
archivo, pixels, pixels)
if flip:
pixbuf = pixbuf.flip(True)
if rotacion:
pixbuf = pixbuf.rotate_simple(rotacion)
imagen.set_from_pixbuf(pixbuf)
boton.set_icon_widget(imagen)
imagen.show()
boton.show()
if tooltip_text:
boton.set_tooltip_text(tooltip_text)
boton.TOOLTIP = tooltip_text
return boton
def __init__(self):
# imports from glade
gladetree = gtk.glade.XML(
os.path.join(pathfix.path, "tools/akmc-gui.glade"))
gui = gladetree.get_widget("akmcgui")
atomview.atomview.__init__(self, gui)
self.stateScale = gladetree.get_widget("stateScale")
self.processesSB = gladetree.get_widget("processesSB")
self.interpolationCB = gladetree.get_widget("interpulationCB")
self.interpolationSB = gladetree.get_widget("interpolationSB")
self.stateEnergy = gladetree.get_widget("stateEnergy")
self.statePlayTB = gladetree.get_widget("statePlayTB")
self.plotWindow = gladetree.get_widget("plotWindow")
self.energy_plotButton = gladetree.get_widget("energy_plotButton")
self.hbox = gladetree.get_widget("hbox5")
self.tempLabel = gladetree.get_widget("simtemp")
self.fileButton = gladetree.get_widget("fileButton")
self.fileEntry = gladetree.get_widget("locationEntry")
self.stateSB = gladetree.get_widget("stateSB")
# defaults
button_size = (20, 20)
self.open = gtk.Image()
self.open.set_from_stock(gtk.STOCK_FILE, gtk.ICON_SIZE_BUTTON)
self.fileButton.set_image(self.open)
self.stateScale.set_size_request(400, -1)
self.interpolationSB.set_sensitive(False)
self.playImage = gtk.Image()
self.playImage.set_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_BUTTON)
self.pauseImage = gtk.Image()
self.pauseImage.set_from_stock(gtk.STOCK_MEDIA_PAUSE,
gtk.ICON_SIZE_BUTTON)
self.statePlayTB.set_image(self.playImage)
self.plotImage = gtk.Image()
image = gdk.pixbuf_new_from_file_at_size(
os.path.join(pathfix.path, "tools/plot_icon.png"), 15, 15)
self.plotImage.set_from_pixbuf(image)
self.energy_plotButton.set_image(self.plotImage)
self.directory = "./config.ini"
self.fileEntry.set_text(self.directory)
self.fileButton.set_sensitive(False)
self.fileEntry.set_sensitive(False)
self.startup()
# event handeling
self.interpolationCB.connect("toggled", self.changeImage)
self.interpolationSB.connect("value-changed", self.changeImage)
self.stateScale.connect("value-changed", self.changeImage)
self.processesSB.connect("value-changed", self.changeImage)
self.stateSB.connect("value-changed", self.stateSB_changed)
self.interpolationCB.connect("clicked", self.interpolationCB_changed)
self.stateScale.connect("value-changed", self.energy_changed)
self.stateScale.connect("value-changed", self.state_play)
self.statePlayTB.connect("toggled", self.state_play)
self.stateScale.connect("value-changed", self.processtable)
self.energy_plotButton.connect("clicked", self.energy_plot)
self.stateScale.connect("value-changed", self.state_changed)
self.fileButton.connect("clicked", self.filechanged)
self.playbutton.connect("clicked", self.movieplaying)
self.pausebutton.connect("clicked", self.movieplaying)
def construct_icon(self, icon, width=None, height=None):
"""
Construct gtk.gdk.Pixbuf Icon
"""
if path.exists(icon):
if width and height:
return pixbuf_new_from_file_at_size(icon, width, height)
else:
return pixbuf_new_from_file(icon)
def setup_icon(self):
"""Load the images that are going to be used as the applet's icon. """
self.icon_states = []
sz = self.applet.get_size()
for i in range(0,14):
path = os.path.join(images_path, "cpufreq-%s.svg" % i)
pixbuf = gdk.pixbuf_new_from_file(path)
pixbuf = gdk.pixbuf_new_from_file_at_size(path, pixbuf.get_width() * sz / pixbuf.get_height(), sz)
self.icon_states.append(pixbuf)
def construct_icon(self, icon, width=None, height=None):
"""
Construct gtk.gdk.Pixbuf Icon
"""
if path.exists(icon):
if width and height:
return pixbuf_new_from_file_at_size(icon, width, height)
else:
return pixbuf_new_from_file(icon)
def __ejecutar_agregar_elemento(self, elementos):
"""
Agrega los items a la lista, uno a uno, actualizando.
"""
if not elementos:
self.permitir_select = True
self.seleccionar_primero()
self.get_toplevel().set_sensitive(True)
return False
texto, path = elementos[0]
descripcion = describe_uri(path)
icono = os.path.join(BASE_PATH, "Iconos", "sonido.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 24, -1)
if descripcion:
if descripcion[2]:
# Es un Archivo
tipo = describe_archivo(path)
if 'video' in tipo or 'application/ogg' in tipo:
icono = os.path.join(BASE_PATH, "Iconos", "video.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 24, -1)
elif 'audio' in tipo or 'application/octet-stream' in tipo:
pass
else:
if "image" in tipo:
icono = path
try:
pixbuf = gdk.pixbuf_new_from_file_at_size(
icono, 50, -1)
except:
icono = os.path.join(BASE_PATH,
"Iconos", "sonido.svg")
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
icono, 24, -1)
self.get_model().append([pixbuf, texto, path])
elementos.remove(elementos[0])
gobject.idle_add(self.__ejecutar_agregar_elemento, elementos)
return False
def __ejecutar_agregar_elemento(self, elementos):
"""
Agrega los items a la lista, uno a uno, actualizando.
"""
if not elementos:
self.permitir_select = True
self.seleccionar_primero()
self.get_toplevel().set_sensitive(True)
return False
texto, path = elementos[0]
descripcion = describe_uri(path)
icono = os.path.join(BASE_PATH, "Iconos", "sonido.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 24, -1)
if descripcion:
if descripcion[2]:
# Es un Archivo
tipo = describe_archivo(path)
if 'video' in tipo or 'application/ogg' in tipo:
icono = os.path.join(BASE_PATH, "Iconos", "video.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 24, -1)
elif 'audio' in tipo or 'application/octet-stream' in tipo:
pass
else:
if "image" in tipo:
icono = path
try:
pixbuf = gdk.pixbuf_new_from_file_at_size(
icono, 50, -1)
except:
icono = os.path.join(BASE_PATH, "Iconos",
"sonido.svg")
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(
icono, 24, -1)
self.get_model().append([pixbuf, texto, path])
elementos.remove(elementos[0])
gobject.idle_add(self.__ejecutar_agregar_elemento, elementos)
return False
def get_pixbuf(self, icon, size) :
if size < 16 :
size = 16
imgfile = os.path.join(self.path, 'graphics', icon)
if imgfile is not None :
try :
return gdk.pixbuf_new_from_file_at_size(imgfile, size, size)
except gdk.PixbufError as err :
print(err)
return None
def __init__(self):
# imports from glade
gladetree = gtk.glade.XML(os.path.join(pathfix.path, "tools/akmcgui.glade"))
gui = gladetree.get_widget("akmcgui")
atomview.atomview.__init__(self, gui)
self.stateScale = gladetree.get_widget("stateScale")
self.processesSB = gladetree.get_widget("processesSB")
self.interpolationCB = gladetree.get_widget("interpulationCB")
self.interpolationSB = gladetree.get_widget("interpolationSB")
self.stateEnergy = gladetree.get_widget("stateEnergy")
self.statePlayTB = gladetree.get_widget("statePlayTB")
self.plotWindow = gladetree.get_widget("plotWindow")
self.energy_plotButton = gladetree.get_widget("energy_plotButton")
self.hbox = gladetree.get_widget("hbox5")
self.tempLabel = gladetree.get_widget("simtemp")
self.fileButton = gladetree.get_widget("fileButton")
self.fileEntry = gladetree.get_widget("locationEntry")
self.stateSB = gladetree.get_widget("stateSB")
# defaults
button_size = (20, 20)
self.open = gtk.Image()
self.open.set_from_stock(gtk.STOCK_FILE, gtk.ICON_SIZE_BUTTON)
self.fileButton.set_image(self.open)
self.stateScale.set_size_request(400,-1)
self.interpolationSB.set_sensitive(False)
self.playImage = gtk.Image()
self.playImage.set_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON)
self.pauseImage = gtk.Image()
self.pauseImage.set_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON)
self.statePlayTB.set_image(self.playImage)
self.plotImage = gtk.Image()
image = gdk.pixbuf_new_from_file_at_size(os.path.join(pathfix.path, "tools/plot_icon.png"), 15, 15)
self.plotImage.set_from_pixbuf(image)
self.energy_plotButton.set_image(self.plotImage)
self.directory = "./config.ini"
self.fileEntry.set_text(self.directory)
self.fileButton.set_sensitive(False)
self.fileEntry.set_sensitive(False)
self.startup()
# event handeling
self.interpolationCB.connect("toggled", self.changeImage)
self.interpolationSB.connect("value-changed", self.changeImage)
self.stateScale.connect("value-changed", self.changeImage)
self.processesSB.connect("value-changed", self.changeImage)
self.stateSB.connect("value-changed", self.stateSB_changed)
self.interpolationCB.connect("clicked", self.interpolationCB_changed)
self.stateScale.connect("value-changed", self.energy_changed)
self.stateScale.connect("value-changed", self.state_play)
self.statePlayTB.connect("toggled", self.state_play)
self.stateScale.connect("value-changed", self.processtable)
self.energy_plotButton.connect("clicked", self.energy_plot)
self.stateScale.connect("value-changed", self.state_changed)
self.fileButton.connect("clicked", self.filechanged)
self.playbutton.connect("clicked", self.movieplaying)
self.pausebutton.connect("clicked", self.movieplaying)
def get_icon_from_file(icon_file, icon_size): # try to load from cache for icon in get_icon(icon_file, icon_size): return icon try: icon = pixbuf_new_from_file_at_size(icon_file, icon_size, icon_size) store_icon(icon_file, icon_size, icon) return icon except GError, e: print "get_icon_from_file, error:", e return None
def _image_size_allocated(self, widget, allocation):
if not self._image_path:
return False
if self._last_width == allocation.width and self._last_height == allocation.height:
return False
width = allocation.width
self._last_width = width
height = allocation.height
self._last_height = height
pixbuf = gdk.pixbuf_new_from_file_at_size(self._image_path, width,
height)
self._image.set_from_pixbuf(pixbuf)
def __init__(self):
super(FullscreenButton, self).__init__()
path = os.path.join(constants.GFX_PATH, 'max-reduce.svg')
self._enlarge_pixbuf = gdk.pixbuf_new_from_file(path)
self.width = self._enlarge_pixbuf.get_width()
self.height = self._enlarge_pixbuf.get_height()
path = os.path.join(constants.GFX_PATH, 'max-enlarge.svg')
self._reduce_pixbuf = gdk.pixbuf_new_from_file_at_size(path, self.width, self.height)
self._image = gtk.Image()
self.set_enlarge()
self._image.show()
self.add(self._image)
def __init__(self):
super(FullscreenButton, self).__init__()
path = os.path.join(constants.GFX_PATH, 'max-reduce.svg')
self._enlarge_pixbuf = gdk.pixbuf_new_from_file(path)
self.width = self._enlarge_pixbuf.get_width()
self.height = self._enlarge_pixbuf.get_height()
path = os.path.join(constants.GFX_PATH, 'max-enlarge.svg')
self._reduce_pixbuf = gdk.pixbuf_new_from_file_at_size(
path, self.width, self.height)
self._image = gtk.Image()
self.set_enlarge()
self._image.show()
self.add(self._image)
def pixbuf_from_file(self,filename, width=None, height=None):
pixbuf = None
if filename is not None or filename == '':
if os.path.isfile(filename):
try:
if not width and not height:
pixbuf = gdk.pixbuf_new_from_file(filename)
else:
width, height = int(width), int(height)
pixbuf = gdk.pixbuf_new_from_file_at_size(filename, width, height)
except:
logINFO("is an image ? => %s" % filename)
pixbuf = None
else:
logINFO("is a image ? => %s" % filename)
return pixbuf
def __init__(self):
super(Main, self).__init__()
self.connect('delete-event', self.on_delete_event)
self.set_title("Quick Capture")
self.set_position(gtk.WIN_POS_CENTER)
self.set_default_size(400,10)
self.set_geometry_hints(min_width=320, min_height=100)
icon = os.path.join(Defaults.prog_root_dir,"Img/logo-tray.xpm")
self.set_icon_from_file(icon)
box1 = gtk.VBox(gtk.FALSE, 0)
self.add(box1)
box1.show()
box2 = gtk.VBox(gtk.FALSE, 10)
box2.set_border_width(10)
box1.pack_start(box2, gtk.TRUE, gtk.TRUE, 0)
box2.show()
table = gtk.Table(2, 3, gtk.FALSE)
table.set_row_spacing(0, 2)
table.set_col_spacing(0, 2)
box2.pack_start(table, gtk.TRUE, gtk.TRUE, 0)
table.show()
# Create the GtkText widget
self._text_window = gtk.Entry(50)
self._text_window.set_editable(gtk.TRUE)
self._text_window.connect("activate", self.on_ok_event)
#frame = gtk.Frame()
#frame.add(self._text_window)
table.attach(self._text_window, 0, 1, 0, 1,
gtk.EXPAND | gtk.SHRINK | gtk.FILL,
gtk.EXPAND | gtk.SHRINK | gtk.FILL, 0, 0)
self._text_window.show()
button_box = gtk.HButtonBox()
okbutton = gtk.Button("OK")
okbutton.connect("clicked", self.on_ok_event)
cancelbutton = gtk.Button("Cancel")
cancelbutton.connect("clicked", self.on_cancel_event)
button_box.add(okbutton)
button_box.add(cancelbutton)
box2.pack_end(button_box, gtk.FALSE, gtk.FALSE)
okbutton.show()
pixbuf = gdk.pixbuf_new_from_file_at_size(icon,25,25)
statusicon = gtk.StatusIcon()
statusicon = gtk.status_icon_new_from_pixbuf(pixbuf)
statusicon.connect("activate",self.tray_activate)
self.show_all()
self.hide()
def __init__(self, ajuste):
gtk.HScale.__init__(self)
self.modify_bg(0, gdk.color_parse("#ffffff"))
self.ajuste = ajuste
self.set_digits(0)
self.set_draw_value(False)
self.ancho, self.borde = (7, 10)
icono = os.path.join(BASE_PATH, "Iconos", "controlslicer.svg")
self.pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 16, 16)
self.connect("expose_event", self.__expose)
self.show_all()
def __init__(self, ajuste):
gtk.HScale.__init__(self)
self.modify_bg(0, gdk.color_parse("#ffffff"))
self.ajuste = ajuste
self.set_digits(0)
self.set_draw_value(False)
self.ancho, self.borde = (7, 10)
icono = os.path.join(BASE_PATH, "Iconos", "controlslicer.svg")
self.pixbuf = gdk.pixbuf_new_from_file_at_size(icono, 16, 16)
self.connect("expose_event", self.__expose)
self.show_all()
def get_pixbuf_from_file(thumb_path, width=-1, height=-1):
"""
Return a Pixbuf thumbnail for the file at @thumb_path
sized @width x @height
For non-icon pixbufs:
We might cache these, but on different terms than the icon cache
if @thumb_path is None, return None
"""
if not thumb_path:
return None
try:
icon = pixbuf_new_from_file_at_size(thumb_path, width, height)
return icon
except GError, e:
# this error is not important, the program continues on fine,
# so we put it in debug output.
pretty.print_debug(__name__, "get_pixbuf_from_file file:", thumb_path, "error:", e)
def get_pixbuf_from_file(thumb_path, width=-1, height=-1):
"""
Return a Pixbuf thumbnail for the file at @thumb_path
sized @width x @height
For non-icon pixbufs:
We might cache these, but on different terms than the icon cache
if @thumb_path is None, return None
"""
if not thumb_path:
return None
try:
icon = pixbuf_new_from_file_at_size(thumb_path, width, height)
return icon
except GError, e:
# this error is not important, the program continues on fine,
# so we put it in debug output.
pretty.print_debug(__name__, "get_pixbuf_from_file file:", thumb_path,
"error:", e)
def setup_icon(self):
"""Load the images that are going to be used as the applet's icon. """
self.__temp_overlay = OverlayText()
self.__temp_overlay.props.active = 1
self.__temp_overlay.props.font_sizing = 16
self.__temp_overlay.props.y_override = 6
self.applet.add_overlay(self.__temp_overlay)
self.icon_states = []
sz = self.applet.get_size()
for i in range(0, 14):
path = os.path.join(images_path, "cpufreq-%s.svg" % i)
pixbuf = gdk.pixbuf_new_from_file(path)
pixbuf = gdk.pixbuf_new_from_file_at_size(
path,
pixbuf.get_width() * sz / pixbuf.get_height(), sz)
self.icon_states.append(pixbuf)
def load_kupfer_icons(scheduler):
"""Load in kupfer icons from installed files"""
ilist = "art/icon-list"
ilist_file_path = config.get_data_file(ilist)
# parse icon list file
ifile = open(ilist_file_path, "r")
for line in ifile:
# ignore '#'-comments
if line.startswith("#"):
continue
icon_name, basename, size = (i.strip() for i in line.split("\t", 2))
size = int(size)
icon_path = config.get_data_file(os.path.join("art", basename))
if not icon_path:
pretty.print_info(__name__, "Icon", basename, icon_path, "not found")
continue
pixbuf = pixbuf_new_from_file_at_size(icon_path, size, size)
gtk.icon_theme_add_builtin_icon(icon_name, size, pixbuf)
pretty.print_debug(__name__, "Loading icon", icon_name, "at", size, "from", icon_path)
def on_about_activate(self, *args):
"""Displays the Help > About dialog."""
bo_keep_logo_path = get_bo_keep_logo()
ab = AboutDialog()
ab.set_transient_for(self.mainwindow)
ab.set_modal(True)
ab.set_name("Bo-Keep")
ab.set_version("1.2.1")
ab.set_copyright("ParIT Worker Co-operative, Ltd. 2006-2012")
ab.set_comments(
"""Bo-Keep helps you keep your books so you don't get lost.
Developed with grant funding from:
- Assiniboine Credit Union <http://assiniboine.mb.ca>
- Legal Aid Manitoba <http://www.legalaid.mb.ca>
""")
ab.set_license(
"""Bo-Keep 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 3 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, see <http://www.gnu.org/licenses/>.
""")
ab.set_authors(("Mark Jenkins <*****@*****.**>",
"Jamie Campbell <*****@*****.**>",
"Samuel Pauls <*****@*****.**>",
"Andrew Orr <*****@*****.**>",
"Sara Arenson <*****@*****.**>",))
ab.set_artists(("David Henry <*****@*****.**>",))
ab.set_program_name("Bo-Keep")
ab.set_logo( pixbuf_new_from_file_at_size(
bo_keep_logo_path, 300, 266) )
ab.run()
ab.destroy()
def __init__(self, ajuste):
gtk.HScale.__init__(self)
self.modify_bg(0, gdk.color_parse("#ffffff"))
self.ajuste = ajuste
self.set_digits(0)
self.set_draw_value(False)
self.ancho, self.borde = (7, 10)
icono = os.path.join(os.path.dirname(BASE_PATH),
"Iconos", "iconplay.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono,
16, 16)
self.pixbuf = pixbuf.rotate_simple(
gdk.PIXBUF_ROTATE_CLOCKWISE)
self.connect("expose_event", self.__expose)
self.show_all()
def __init__(self):
# Glade imports
gladetree = gtk.glade.XML(
os.path.join(pathfix.path, "tools/bh-gui.glade"))
gui = gladetree.get_widget("BHgui")
atomview.atomview.__init__(self, gui)
self.stateSB = gladetree.get_widget("stateSB")
self.stateScale = gladetree.get_widget("stateScale")
self.scrollwindow = gladetree.get_widget("scrollwindow")
self.energyplotButton = gladetree.get_widget("energyplotButton")
self.repeatplotButton = gladetree.get_widget("repeatplotButton")
self.eplotWindow = gladetree.get_widget("eplotWindow")
self.rplotWindow = gladetree.get_widget("rplotWindow")
self.acceptanceratio = gladetree.get_widget("acceptanceratio")
# Image setting
self.eplotImage = gtk.Image()
image = gdk.pixbuf_new_from_file_at_size(
os.path.join(pathfix.path, "tools/plot_icon.png"), 15, 15)
self.eplotImage.set_from_pixbuf(image)
self.energyplotButton.set_image(self.eplotImage)
self.rplotImage = gtk.Image()
self.rplotImage.set_from_pixbuf(image)
self.repeatplotButton.set_image(self.rplotImage)
# Config.ini imports
self.directory = "./config.ini"
reload(config)
config.init(self.directory)
config.path_root = os.path.dirname(self.directory)
config.path_states = "%s/states/" % config.path_root
# Signal connectors
self.stateScale.connect("value-changed", self.changeImage)
self.stateSB.connect("value-changed", self.stateSB_changed)
self.stateScale.connect("value-changed", self.state_changed)
self.energyplotButton.connect("clicked", self.energyplot)
self.repeatplotButton.connect("clicked", self.repeatplot)
self.startup()
def setup_init(self):
"""
Se crea la interfaz grafica,
se setea y se empaqueta todo.
"""
self.get_toplevel().set_sensitive(False)
from Widgets import Visor
from Widgets import BarraProgreso
from Widgets import ControlVolumen
from PlayerList import Lista
from PlayerControls import PlayerControl
#from GstreamerWidgets.Widgets import WidgetsGstreamerEfectos
from Toolbars import ToolbarSalir
from Toolbars import Toolbar
from Toolbars import ToolbarAccion
from Toolbars import ToolbarConfig
from Toolbars import ToolbarGrabar
from Toolbars import ToolbarInfo
from Toolbars import ToolbarAddStream
self.pantalla = Visor()
self.barradeprogreso = BarraProgreso()
self.volumen = ControlVolumen()
self.lista_de_reproduccion = Lista()
self.controlesrepro = PlayerControl()
self.toolbar = Toolbar()
self.toolbar_config = ToolbarConfig()
#self.widget_efectos = WidgetsGstreamerEfectos()
self.toolbar_accion = ToolbarAccion()
self.toolbar_grabar = ToolbarGrabar()
self.toolbar_info = ToolbarInfo()
self.toolbaraddstream = ToolbarAddStream()
self.toolbar_salir = ToolbarSalir()
basebox = gtk.VBox()
hpanel = gtk.HPaned()
hpanel.modify_bg(0, get_colors("window"))
eventbox = gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar)
basebox.pack_start(eventbox, False, False, 3)
basebox.pack_start(self.toolbar_salir, False, False, 0)
basebox.pack_start(self.toolbar_accion, False, False, 0)
basebox.pack_start(self.toolbaraddstream, False, False, 0)
basebox.pack_start(hpanel, True, True, 0)
# Area Izquierda del Panel
# Efectos que se están aplicando.
#eventbox = gtk.EventBox() # FIXME: Para poder pintar el fondo
#eventbox.modify_bg(0, get_colors("drawingplayer"))
#self.hbox_efectos_en_pipe = gtk.HBox()
#self.hbox_efectos_en_pipe.set_size_request(-1, 24)
#eventbox.add(self.hbox_efectos_en_pipe)
#scroll = gtk.ScrolledWindow()
#scroll.set_policy(
# gtk.POLICY_AUTOMATIC,
# gtk.POLICY_NEVER)
#scroll.add_with_viewport(eventbox)
# Barra de Progreso + Volúmen
ev_box = gtk.EventBox() # FIXME: Para poder pintar el fondo
ev_box.modify_bg(0, get_colors("barradeprogreso"))
hbox_barra_progreso = gtk.HBox()
hbox_barra_progreso.pack_start(
self.barradeprogreso, True, True, 0)
hbox_barra_progreso.pack_start(
self.volumen, False, False, 0)
ev_box.add(hbox_barra_progreso)
# Todo
vbox = gtk.VBox()
vbox.pack_start(self.toolbar_grabar, False, False, 0)
vbox.pack_start(self.pantalla, True, True, 0)
#vbox.pack_start(scroll, False, False, 0)
eventbox = gtk.EventBox() # FIXME: Para poder pintar el fondo
eventbox.modify_bg(0, get_colors("barradeprogreso"))
eventbox.add(self.toolbar_info)
vbox.pack_start(eventbox, False, False, 3)
vbox.pack_start(ev_box, False, True, 0)
hpanel.pack1(vbox, resize=True, shrink=True)
# Area Derecha del Panel
self.derecha_vbox = gtk.VBox()
# Configuración de balanace y efectos
self.vbox_config = gtk.VBox()
self.scroll_config = gtk.ScrolledWindow()
self.scroll_config.set_policy(
gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.scroll_config.add_with_viewport(self.vbox_config)
self.scroll_config.get_child().modify_bg(0, get_colors("window"))
self.vbox_config.pack_start(
self.toolbar_config, False, False, 0)
#self.vbox_config.pack_start(self.widget_efectos, False, False, 0)
# Lista de Reproducción
# FIXME: Para poder pintar el fondo
self.evnt_box_lista_reproduccion = gtk.EventBox()
self.evnt_box_lista_reproduccion.modify_bg(
0, get_colors("barradeprogreso"))
self.vbox_lista_reproduccion = gtk.VBox()
self.scroll_list = gtk.ScrolledWindow()
self.scroll_list.set_policy(
gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scroll_list.add(self.lista_de_reproduccion)
# Lista + Controles de Reproducción
self.__pack_vbox_lista_reproduccion()
self.evnt_box_lista_reproduccion.add(
self.vbox_lista_reproduccion)
# Configuración + Lista de Reproducción.
self.derecha_vbox.pack_start(
self.scroll_config, True, True, 0)
self.derecha_vbox.pack_start(
self.evnt_box_lista_reproduccion, True, True, 0)
hpanel.pack2(self.derecha_vbox, resize=False, shrink=True)
self.controles_dinamicos = [
hbox_barra_progreso,
self.derecha_vbox,
self.toolbar,
self.toolbar_info,
#self.hbox_efectos_en_pipe.get_parent().get_parent(
# ).get_parent(),
]
basebox.show_all()
map(self.__ocultar,
[self.toolbar_salir,
self.scroll_config,
self.toolbar_accion,
self.toolbar_grabar,
self.toolbaraddstream,
self.toolbar_info.descarga])
self.add(basebox)
self.lista_de_reproduccion.connect(
"nueva-seleccion",
self.__cargar_reproducir)
self.lista_de_reproduccion.connect(
"button-press-event",
self.__click_derecho_en_lista)
self.controlesrepro.connect(
"activar", self.__activar)
self.barradeprogreso.connect(
"user-set-value", self.__user_set_value)
self.pantalla.connect(
"ocultar_controles", self.__ocultar_controles)
self.pantalla.connect(
"button_press_event", self.__clicks_en_pantalla)
self.toolbar.connect('salir', self.confirmar_salir)
self.toolbar.connect('config', self.__mostrar_config)
self.toolbar_salir.connect(
'salir', self.__emit_salir)
self.toolbar_config.connect(
'valor', self.__set_balance)
self.toolbar_info.connect(
'rotar', self.__set_rotacion)
self.toolbar_info.connect(
'actualizar_streamings',
self.__actualizar_streamings)
self.toolbar_accion.connect(
"Grabar", self.__grabar_streaming)
self.toolbar_accion.connect(
"accion-stream", self.__accion_stream)
self.toolbar_grabar.connect(
"stop", self.__detener_grabacion)
self.volumen.connect(
"volumen", self.__set_volumen)
self.toolbaraddstream.connect(
"add-stream", self.__ejecutar_add_stream)
#self.widget_efectos.connect(
# "click_efecto", self.__click_efecto)
#self.widget_efectos.connect(
# 'configurar_efecto', self.__configurar_efecto)
# Controlador del mouse.
# http://www.pygtk.org/pygtk2reference/class-gdkdisplay.html
# #function-gdk--display-get-default
icono = os.path.join(BASE_PATH,
"Iconos", "jamedia_cursor.svg")
pixbuf = gdk.pixbuf_new_from_file_at_size(icono,
-1, 24)
self.jamedia_cursor = gdk.Cursor(
gdk.display_get_default(), pixbuf, 0, 0)
self.cursor_root = self.get_parent_window().get_cursor()
self.get_parent_window().set_cursor(self.jamedia_cursor)
from Widgets import MouseSpeedDetector
self.mouse_listener = MouseSpeedDetector(self)
self.mouse_listener.connect(
"estado", self.__set_mouse)
self.mouse_listener.new_handler(True)
self.get_parent().connect(
"hide", self.__hide_show_parent)
self.get_parent().connect(
"show", self.__hide_show_parent)
#self.hbox_efectos_en_pipe.get_parent().get_parent(
# ).get_parent().hide()
self.get_toplevel().set_sensitive(True)
self.derecha_vbox.set_size_request(169, -1)
def new_from_file_at_size(cls, path, height, width):
"Return a gtk.gdk.Pixbuf (note, not a ga.gtk.GdkPixbuf)"
return pixbuf_new_from_file_at_size(path, height, width)
def __init__(self, videodict):
gtk.EventBox.__init__(self)
self.modify_bg(0, get_colors("widgetvideoitem"))
self.set_border_width(2)
self.videodict = videodict
hbox = gtk.HBox()
vbox = gtk.VBox()
keys = self.videodict.keys()
if "previews" in keys:
imagen = gtk.Image()
hbox.pack_start(imagen, False, False, 3)
if type(self.videodict["previews"]) == list:
# siempre hay 4 previews.
url = self.videodict["previews"][0][0]
import time
archivo = "/dev/shm/preview%d" % time.time()
try:
# FIXME: Porque Falla si no hay Conexión.
import urllib
fileimage, headers = urllib.urlretrieve(url, archivo)
pixbuf = gdk.pixbuf_new_from_file_at_size(
fileimage, 200, 150)
imagen.set_from_pixbuf(pixbuf)
# Convertir imagen a string por si se quiere guardar.
import base64
pixbuf_file = open(fileimage, 'rb')
image_string = base64.b64encode(pixbuf_file.read())
pixbuf_file.close()
self.videodict["previews"] = image_string
except:
print "No hay Conexión a Internet."
if os.path.exists(archivo):
os.remove(archivo)
else:
import base64
loader = gdk.PixbufLoader()
loader.set_size(200, 150)
image_string = base64.b64decode(self.videodict["previews"])
loader.write(image_string)
loader.close()
pixbuf = loader.get_pixbuf()
imagen.set_from_pixbuf(pixbuf)
vbox.pack_start(gtk.Label("%s: %s" % ("id",
self.videodict["id"])), True, True, 0)
vbox.pack_start(gtk.Label("%s: %s" % ("Título",
self.videodict["titulo"])), True, True, 0)
vbox.pack_start(gtk.Label("%s: %s" % ("Categoría",
self.videodict["categoria"])), True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Etiquetas",
# self.videodict["etiquetas"])), True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Descripción",
# self.videodict["descripcion"])), True, True, 0)
vbox.pack_start(gtk.Label("%s: %s %s" % ("Duración",
int(float(self.videodict["duracion"]) / 60.0), "Minutos")),
True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Reproducción en la Web",
# self.videodict["flash player"])), True, True, 0)
vbox.pack_start(gtk.Label("%s: %s" % ("url",
self.videodict["url"])), True, True, 0)
for label in vbox.get_children():
label.set_alignment(0.0, 0.5)
hbox.pack_start(vbox, False, False, 5)
self.add(hbox)
self.show_all()
self.connect("button_press_event", self.__button_press)
def new_from_file_at_size(cls, path, height, width):
"Return a gtk.gdk.Pixbuf (note, not a ga.gtk.GdkPixbuf)"
return pixbuf_new_from_file_at_size(path, height, width)
