280 lines
11 KiB
Python
Executable File
280 lines
11 KiB
Python
Executable File
#!/usr/bin/env python2.6
|
|
# -*- coding: utf-8 -*-
|
|
# Setea el parámetro "forward / ..." en /etc/privoxy/config
|
|
# Uso: si se llama con privoxy_fw <nombre de host> <puerto>, escribe una línea
|
|
# forward / <nom_host>:<puerto> en /etc/priv../config;
|
|
# si se llama sin parámetros suficientes (esto es, privoxy_fw [<algo>]) entonces
|
|
# comenta cualquier línea forward /
|
|
|
|
|
|
import sys
|
|
import re
|
|
import pygtk
|
|
pygtk.require('2.0')
|
|
|
|
import gtk
|
|
import commands
|
|
|
|
# Check for new pygtk: this is new class in PyGtk 2.4
|
|
if gtk.pygtk_version < (2,3,90):
|
|
print "PyGtk 2.3.90 or later required for this example"
|
|
raise SystemExit
|
|
|
|
class HelloWorld:
|
|
pixbuf = None
|
|
imagen = gtk.Image()
|
|
ruta = "/home/mauro/Imágenes/art/4995443800_e68125ac35_o.jpg"
|
|
layout = "zoom" #wallpaper, centered, scaled, stretched, zoom
|
|
def dibujar_imagen(self):
|
|
imagen_cargada = gtk.gdk.pixbuf_new_from_file(self.ruta)
|
|
ancho_img = imagen_cargada.get_width()
|
|
alto_img = imagen_cargada.get_height()
|
|
|
|
ratio_disp = float(self.wscreen)/float(self.hscreen)
|
|
ratio_imag = float(ancho_img)/float(alto_img)
|
|
|
|
ancho_img_scaled = None
|
|
alto_img_scaled = None
|
|
|
|
self.pixbuf.fill(0x88888888)
|
|
self.pixbuf.saturate_and_pixelate(self.pixbuf, 0.0, True)
|
|
|
|
if self.layout == "zoom":
|
|
if ratio_disp > ratio_imag:
|
|
ancho_img_scaled = self.wscreen/4.0
|
|
alto_img_scaled = alto_img*((self.wscreen/4.0)/ancho_img)
|
|
else:
|
|
alto_img_scaled = self.hscreen/4.0
|
|
ancho_img_scaled = ancho_img*((self.hscreen/4.0)/alto_img)
|
|
|
|
imagen_cargada = imagen_cargada.scale_simple(int(ancho_img_scaled),
|
|
int(alto_img_scaled),
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
imagen_cargada.copy_area( int((ancho_img_scaled-self.wscreen/4.0)/2),
|
|
int((alto_img_scaled-self.hscreen/4.0)/2),
|
|
int(self.wscreen/4), int(self.hscreen/4),
|
|
self.pixbuf, 0, 0)
|
|
elif self.layout == "scaled":
|
|
scale_x = (self.wscreen/4.0)/ancho_img
|
|
scale_y = (self.hscreen/4.0)/alto_img
|
|
|
|
ancho_img_scaled = ancho_img*min(scale_x, scale_y)
|
|
alto_img_scaled = alto_img*min(scale_x, scale_y)
|
|
|
|
imagen_cargada = imagen_cargada.scale_simple(int(ancho_img_scaled),
|
|
int(alto_img_scaled),
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
imagen_cargada.copy_area( 0, 0, ancho_img_scaled, alto_img_scaled,
|
|
self.pixbuf,
|
|
int((self.wscreen/4-ancho_img_scaled)/2),
|
|
int((self.hscreen/4-alto_img_scaled)/2))
|
|
elif self.layout == "centered":
|
|
imagen_cargada = imagen_cargada.scale_simple(int(ancho_img/4),
|
|
int(alto_img/4),
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
|
|
x0 = (self.wscreen-ancho_img)/8
|
|
y0 = (self.hscreen-alto_img)/8
|
|
|
|
imagen_cargada.copy_area( max(-x0,0), max(-y0,0),
|
|
min(self.wscreen/4,ancho_img/4-x0),
|
|
min(self.hscreen/4,alto_img/4-y0),
|
|
self.pixbuf, max(x0,0), max(y0,0))
|
|
elif self.layout == "stretched":
|
|
imagen_cargada = imagen_cargada.scale_simple(self.wscreen/4,
|
|
self.hscreen/4,
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
imagen_cargada.copy_area( 0, 0,self.wscreen/4, self.hscreen/4,
|
|
self.pixbuf, 0, 0)
|
|
|
|
elif self.layout == "wallpaper":
|
|
imagen_cargada = imagen_cargada.scale_simple(int(ancho_img/4),
|
|
int(alto_img/4),
|
|
gtk.gdk.INTERP_BILINEAR)
|
|
x0=0
|
|
while( x0 < self.wscreen ):
|
|
y0=0
|
|
while( y0 < self.hscreen):
|
|
imagen_cargada.copy_area( 0, 0,
|
|
min(self.wscreen/4-x0,ancho_img/4),
|
|
min(self.hscreen/4-y0,alto_img/4),
|
|
self.pixbuf, x0, y0)
|
|
y0 += alto_img/4
|
|
x0 += ancho_img/4
|
|
|
|
self.imagen.set_from_pixbuf(self.pixbuf)
|
|
|
|
|
|
def get_screen_size(self):
|
|
(status,output)=commands.getstatusoutput('xwininfo -root|grep "geometry"')
|
|
m1 = re.match(r".*geometry\s([0-9]+)x([0-9]+)\+.*", output)
|
|
if m1:
|
|
return (int(m1.group(1)), int(m1.group(2)))
|
|
return (-1, -1)
|
|
|
|
# This is a callback function. The data arguments are ignored
|
|
# in this example. More on callbacks below.
|
|
def hello(self, widget, data=None):
|
|
print "Hello World"
|
|
|
|
def delete_event(self, widget, event, data=None):
|
|
# If you return FALSE in the "delete_event" signal handler,
|
|
# GTK will emit the "destroy" signal. Returning TRUE means
|
|
# you don't want the window to be destroyed.
|
|
# This is useful for popping up 'are you sure you want to quit?'
|
|
# type dialogs.
|
|
print "delete event occurred"
|
|
|
|
# Change FALSE to TRUE and the main window will not be destroyed
|
|
# with a "delete_event".
|
|
return False
|
|
|
|
def destroy(self, widget, data=None):
|
|
print "destroy signal occurred"
|
|
gtk.main_quit()
|
|
|
|
def imagen_seleccionada( self, widget, response):
|
|
if response == gtk.RESPONSE_ACCEPT:
|
|
self.ruta = widget.get_filename()
|
|
self.dibujar_imagen()
|
|
|
|
def layout_cambiado( self, widget):
|
|
self.layout = widget.get_active_text()
|
|
self.dibujar_imagen()
|
|
|
|
def __init__(self):
|
|
(self.wscreen, self.hscreen) = self.get_screen_size()
|
|
self.pixbuf = gtk.gdk.Pixbuf( gtk.gdk.COLORSPACE_RGB, True, 8,
|
|
int(self.wscreen/4.0),
|
|
int(self.hscreen/4.0) )
|
|
# create a new window
|
|
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
|
|
# self.window.set_size_request(400,600)
|
|
|
|
# The data passed to the callback
|
|
# function is NULL and is ignored in the callback function.
|
|
self.window.connect("delete_event", self.delete_event)
|
|
|
|
# Here we connect the "destroy" event to a signal handler.
|
|
# This event occurs when we call gtk_widget_destroy() on the window,
|
|
# or if we return FALSE in the "delete_event" callback.
|
|
self.window.connect("destroy", self.destroy)
|
|
|
|
# Sets the border width of the window.
|
|
self.window.set_border_width(10)
|
|
|
|
self.label = gtk.Label("<big><b>Elija la imagen nueva a mostrar</b></big>\n\
|
|
La imagen actualmente configurada es /home/mauro.")
|
|
self.label.set_use_markup(True)
|
|
|
|
# Creates a new button with the label "Hello World".
|
|
self.button = gtk.Button("Hello World")
|
|
|
|
# When the button receives the "clicked" signal, it will call the
|
|
# function hello() passing it None as its argument. The hello()
|
|
# function is defined above.
|
|
self.button.connect("clicked", self.hello, None)
|
|
|
|
# This will cause the window to be destroyed by calling
|
|
# gtk_widget_destroy(window) when "clicked". Again, the destroy
|
|
# signal could come from here, or the window manager.
|
|
self.button.connect_object("clicked", gtk.Widget.destroy, self.window)
|
|
|
|
self.vbox = gtk.VBox();
|
|
self.hbox = gtk.HBox();
|
|
|
|
self.dibujar_imagen()
|
|
|
|
self.filechooserdialog = gtk.FileChooserDialog("Elija un archivo",
|
|
self.window,
|
|
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
|
|
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
|
|
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
|
|
self.filechooserbutton = gtk.FileChooserButton(self.filechooserdialog)
|
|
self.filechooserdialog.connect("response", self.imagen_seleccionada)
|
|
|
|
self.combo = gtk.combo_box_new_text()
|
|
self.combo.append_text("zoom")
|
|
self.combo.append_text("centered")
|
|
self.combo.append_text("stretched")
|
|
self.combo.append_text("scaled")
|
|
self.combo.append_text("wallpaper")
|
|
self.combo.connect("changed", self.layout_cambiado)
|
|
|
|
self.vbox.pack_start(self.label)
|
|
self.vbox.pack_start(self.imagen)
|
|
self.vbox.pack_start(self.filechooserbutton)
|
|
self.vbox.pack_start(self.hbox)
|
|
self.hbox.pack_start(self.combo)
|
|
self.hbox.pack_start(self.button)
|
|
|
|
self.vbox.show()
|
|
self.filechooserbutton.show()
|
|
self.hbox.show()
|
|
self.label.show()
|
|
self.imagen.show()
|
|
self.combo.show()
|
|
|
|
self.window.add(self.vbox)
|
|
|
|
# The final step is to display this newly created widget.
|
|
self.button.show()
|
|
|
|
# and the window
|
|
self.window.show()
|
|
|
|
print self.get_screen_size()
|
|
|
|
def main(self):
|
|
# All PyGTK applications must have a gtk.main(). Control ends here
|
|
# and waits for an event to occur (like a key press or mouse event).
|
|
gtk.main()
|
|
|
|
# If the program is run directly or passed as an argument to the python
|
|
# interpreter then create a HelloWorld instance and show it
|
|
if __name__ == "__main__":
|
|
hello = HelloWorld()
|
|
hello.main()
|
|
|
|
# if __name__ == "__main__":
|
|
# out = ""
|
|
# seteado = 0
|
|
|
|
# with open('/etc/privoxy/config', 'r') as conf:
|
|
# for linea in conf:
|
|
# # m matchea una línea forward / ...
|
|
# m = re.match(r"\s*#*\s*forward\s+/\s+([a-zA-z0-9._-]+):([0-9]+)(.*)", linea)
|
|
# if m:
|
|
# if len(sys.argv) < 3:
|
|
# out += "# forward / " + m.group(1) + ":" + m.group(2) + " " + m.group(3) + "\n"
|
|
# elif m.group(1) == sys.argv[1] and m.group(2) == sys.argv[2]:
|
|
# out += "forward / " + m.group(1) + ":" + m.group(2) + " " + m.group(3) + "\n"
|
|
# seteado = 1
|
|
# else:
|
|
# out += "# forward / " + m.group(1) + ":" + m.group(2) + " " + m.group(3) + "\n"
|
|
# else:
|
|
# out += linea
|
|
|
|
# if seteado == 0 and len(sys.argv) > 2:
|
|
# out = "forward / " + sys.argv[1] + ":" + sys.argv[2] + "\n" + out
|
|
# #print out
|
|
|
|
# with open('/etc/privoxy/config', 'w') as f:
|
|
# f.write(out)
|
|
# print "\nSe ha modificado la configuración de Privoxy."
|
|
|
|
# proxy_handler = urllib2.ProxyHandler({'http': 'http://localhost:8118/'})
|
|
# opener = urllib2.build_opener(proxy_handler)
|
|
# try:
|
|
# opener.open('http://www.google.com')
|
|
# except urllib2.HTTPError:
|
|
# pass
|
|
|
|
# try:
|
|
# opener.open('http://www.google.com')
|
|
# except urllib2.HTTPError:
|
|
# print 'No se puede forwardear al proxy seteado. Verificá los parámetros.'
|
|
# else:
|
|
# print 'Bien. Ahora podés navegar a través de Privoxy.'
|
|
|