def __init__(self):
gtk.Toolbar.__init__(self)
self._back = ToolButton('go-previous')
self._back.set_tooltip(_('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._back.show()
self._forward = ToolButton('go-next')
self._forward.set_tooltip(_('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
num_page_item = gtk.ToolItem()
self._num_page_entry = gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self._total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self._total_page_label.set_attributes(label_attributes)
self._total_page_label.set_text(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
downloaded_item = gtk.ToolItem()
self._downloaded_label = gtk.Label()
self._downloaded_label.set_attributes(label_attributes)
self._downloaded_label.set_text('')
downloaded_item.add(self._downloaded_label)
self._downloaded_label.show()
self.insert(downloaded_item, -1)
downloaded_item.show()
def __init__(self, CFG):
gtk.Fixed.__init__(self)
msg_titulo = _("Welcome to the Install Wizard")
msg_intro = _("With this wizard you can easily install Canaima \
GNU/Linux on your computer. We invite you to follow the instructions \
displayed on screen.")
attr = pango.AttrList()
size = pango.AttrSize(20000, 0, -1)
attr.insert(size)
self.lbltitulo = gtk.Label(msg_titulo)
self.lbltitulo.set_size_request(640, 80)
self.lbltitulo.set_alignment(0, 0)
self.lbltitulo.set_attributes(attr)
self.lbltitulo.set_line_wrap(True)
#self.lbltitulo.set_selectable(True)
self.put(self.lbltitulo, 50, 90)
self.lblintro = gtk.Label(msg_intro)
self.lblintro.set_size_request(640, 40)
self.lblintro.set_alignment(0, 0)
self.lblintro.set_line_wrap(True)
#self.lblintro.set_selectable(True)
self.put(self.lblintro, 50, 170)
self.set_flags(gtk.CAN_FOCUS)
atk_acc_vd(self, msg_titulo + " " + msg_intro)
def __init__(self):
gtk.Toolbar.__init__(self)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.prev_page)
self.prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.prev_page.connect('activate', self.go_back_cb)
self.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.next_page)
self.next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.next_page.connect('activate', self.go_forward_cb)
self.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self._num_page_entry = gtk.Entry()
self._num_page_entry.set_text('0')
self._num_page_entry.set_alignment(1)
self._num_page_entry.connect('insert-text',
self._num_page_entry_insert_text_cb)
self._num_page_entry.connect('activate',
self._num_page_entry_activate_cb)
self._num_page_entry.set_width_chars(4)
num_page_item.add(self._num_page_entry)
self._num_page_entry.show()
self.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self._total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
self._total_page_label.set_attributes(label_attributes)
self._total_page_label.set_text(' / 0')
total_page_item.add(self._total_page_label)
self._total_page_label.show()
self.insert(total_page_item, -1)
total_page_item.show()
def __init__(self,handle):
activity.Activity.__init__(self,handle)
self.set_title("Ecomundo")
print "Init activity Ecomundo"
#print os.path.abspath(__file__)
self.createToolbox()
hBox = gtk.HBox(False, 0)
self.set_canvas(hBox)
self.drawingarea1 = gtk.DrawingArea()
self.drawingarea1.set_size_request(World.SIZE_WORLD,World.SIZE_WORLD)
self.drawingarea1.show()
hBox.pack_start(self.drawingarea1, False, False, 0)
notebook = gtk.Notebook()
print hBox.get_screen().get_width()
#
notebook.set_size_request(hBox.get_screen().get_width() - World.SIZE_WORLD,-1)
hBox.pack_start(notebook, False, False, 0)
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(10000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
# En la primera pagina del notebook pongo los datos del experimento
icon_experiment = Icon(icon_name="experiment", icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
self.createExperimentControls(notebook,icon_experiment,label_attributes)
# En la segunda pagina del notebook pongo los datos de los conejos
icon_rabbit = Icon(icon_name="rabbit", icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
self.createAnimalControls(notebook,_('Rabbit features'), icon_rabbit,world.rabbit_data,label_attributes)
# En la tercera pagina del notebook pongo los datos de los zorros
icon_fox = Icon(icon_name="fox", icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
self.createAnimalControls(notebook,_('Fox features'), icon_fox,world.fox_data,label_attributes)
# En la cuarta ponemos los parametros de clima
icon_rain = Icon(icon_name="rain", icon_size=gtk.ICON_SIZE_LARGE_TOOLBAR)
self.createRainControls(notebook,icon_rain,label_attributes)
print "antes de initWorld"
initWorld()
print "antes de init Green"
initGreen()
print "antes de init Animals"
initAnimals()
hBox.resize_children()
hBox.show_all()
self.drawingarea1.connect('expose-event', self.onDrawingAreaExposed)
def _set_attributes(self, bgcolor, fgcolor, size, weight):
attr = pango.AttrList()
bg_color = pango.AttrBackground(bgcolor[0], bgcolor[1], bgcolor[2], 0, -1)
attr.insert(bg_color)
size_attr = pango.AttrSize(size[0], size[1], size[2])
attr.insert(size_attr)
weight_attr = pango.AttrWeight(weight[0], weight[1], weight[2])
attr.insert(weight_attr)
fg_color = pango.AttrForeground(fgcolor[0], fgcolor[1], fgcolor[2], 0, 13)
attr.insert(fg_color)
return attr
def __init__(self, weh):
super(GTKstrip, self).__init__()
self.label = "GTKstrip"
chars = "ESKISTLFÜNFZEHNZWANZIGDREIVIERTELTGNACHVORJMHALBQZWÖLFPZWEINSIEBENKDREIRHFÜNFELFNEUNVIERWACHTZEHNRSBSECHSFMUHR...."
#chars = chars + "------------------------------------------------------------"
#chars = chars + "------------------------------------------------------------"
self.labels = []
self.colors = []
self.brightness = 180
self.weh = weh
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.connect("delete_event", self.delete_event)
self.win.connect("destroy", self.destroy)
self.win.connect("key_press_event", self.key_press_event)
table = gtk.Table(11, 11, True)
x = 0
y = 0
for i in unicode(chars):
label = gtk.Label(i)
self.labels.append(label)
self.colors.append(Color(0, 0, 0))
table.attach(label, x, x + 1, y, y + 1, FILL, FILL)
x += 1
if x == 11:
x = 0
y += 1
attrs = pango.AttrList()
# attrs.insert(pango.AttrLanguage("de"))
attrs.insert(pango.AttrForeground(0, 0, 0))
FONTSIZE = 15
attrs.insert(pango.AttrSize(FONTSIZE * 1000))
attrs.insert(pango.AttrBackground(0, 0, 0))
label.set_attributes(attrs)
label.show()
color = gtk.gdk.color_parse('#000000')
self.win.modify_bg(gtk.STATE_NORMAL, color)
self.win.add(table)
self.win.show_all()
def Description(c, box, text):
style = pango.AttrList()
size = pango.AttrSize(8000, 0, -1)
style.insert(size)
description = gtk.Label()
description.set_markup(text)
description.set_line_wrap(True)
description.set_size_request(window_width - box.get_border_width() * 4, -1)
description.set_attributes(style)
box.pack_start(description, expand, fill, padding)
return description
def make_table_title(self, title):
""" set a Table title : play with pango"""
label = gtk.Label()
label.set_text(title)
attrs = pango.AttrList()
attrs.insert(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
attrs.insert(pango.AttrSize(18000, 0, -1))
label.set_attributes(attrs)
# positionning of label
label.set_alignment(xalign=0.5, yalign=0.5) # center
# Insert label into the upper left quadrant of the table
label.show()
return label
def set_window_size(self, setting):
"""Set window and label size."""
window_width = self.screen_width
window_height = -1
window_height = setting * self.screen_height / 100
attr = pango.AttrList()
attr.change(pango.AttrSize((50 * window_height / 100) * 1000, 0, -1))
attr.change(pango.AttrFamily(self.options['font'], 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
attr.change(pango.AttrForeground(*self.options['color']))
self.label.set_attributes(attr)
self.resize(window_width, window_height)
def set_attr(layout):
attr = pango.AttrList()
size = pango.AttrSize(int(11.5 * pango.SCALE), 0, -1)
attr.insert(size)
if customAttr and customAttr.attributes_dict:
attributes_dict = customAttr.attributes_dict
if attributes_dict.has_key("regex_include_match"):
start, end = attributes_dict["regex_include_match"]
pango_color = pango.AttrBackground(self.include_color.red, self.include_color.green,
self.include_color.blue, start, end)
attr.insert(pango_color)
if attributes_dict.has_key("regex_exclude_match"):
start, end = attributes_dict["regex_exclude_match"]
pango_color = pango.AttrForeground(self.exclude_color.red, self.exclude_color.green,
self.exclude_color.blue, start, end)
attr.insert(pango_color)
layout.set_attributes(attr)
def __init__(self, dial_group = None, window_group = None,
window_title = "", additional_text = None,
actionok = None, actioncancel = None):
gtk.Dialog.__init__(self, window_title, None,
gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK))
if window_group is not None:
window_group.add_window(self)
self.set_resizable(False)
self.connect("close", self.respond, actionok, actioncancel)
self.connect("response", self.respond, actionok, actioncancel)
self.connect("window-state-event", self.window_attn)
self.set_default_response(gtk.RESPONSE_OK)
hbox = gtk.HBox(False, 20)
hbox.set_border_width(20)
self.vbox.pack_start(hbox, True, True, 0)
hbox.show()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_DIALOG)
hbox.pack_start(image, True, True, 0)
image.show()
vbox = gtk.VBox()
vbox.set_spacing(8)
hbox.pack_start(vbox, True, True, 0)
vbox.show()
if additional_text is not None:
if type(additional_text) is str:
additional_text = additional_text.splitlines()
for each in additional_text:
label = gtk.Label()
attrlist = pango.AttrList()
attrlist.insert(pango.AttrSize(12500, 0, len(each)))
label.set_attributes(attrlist)
label.set_text(each)
vbox.add(label)
label.show()
if dial_group is not None:
dial_group.add(self)
self.dial_group = dial_group
def set_window_size(self, setting):
"""Set window and label size."""
window_width = self.screen_width
window_height = -1
if setting == SIZE_LARGE:
window_height = 24 * self.screen_height / 100
if setting == SIZE_MEDIUM:
window_height = 12 * self.screen_height / 100
if setting == SIZE_SMALL:
window_height = 8 * self.screen_height / 100
attr = pango.AttrList()
attr.change(pango.AttrSize((50 * window_height / 100) * 1000, 0, -1))
attr.change(pango.AttrFamily("Sans", 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
attr.change(pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.label.set_attributes(attr)
self.resize(window_width, window_height)
def __init__(self, parent_window, actions_label):
gtk.EventBox.__init__(self)
self.label = gtk.Label()
self.button_actions = ButtonMenu(parent_window, actions_label)
attributes = pango.AttrList()
attributes.insert(pango.AttrWeight(700, 0, -1))
attributes.insert(pango.AttrSize(16000, 0, -1))
self.label.set_attributes(attributes)
self.label.set_ellipsize(pango.ELLIPSIZE_END)
self.label.set_alignment(0.0, 0.5)
self.label.set_padding(2, 0)
hbox = gtk.HBox()
hbox.pack_start(self.label)
hbox.pack_start(self.button_actions, False, False)
self.add(hbox)
self.connect("realize", self.on_realize)
self.show_all()
def _generate_thumb_with_text(self):
""" Generate the text on the pixbuf """
# This technique is used to compose image with text
# create a pixmap with the data of the pixbuf then insert text
# cf. pygtk FAQ How do I draw a text [or something else] on a gtk.gdk.pixbuf? for mor explication
# (http://faq.pygtk.org/index.py?req=show&file=faq08.020.htp )
pixmap, mask = self._pixbuf_thumb.render_pixmap_and_mask()
# graphic context and Drawarea any created to allow generation of pixbuf composition
gc = pixmap.new_gc()
area = gtk.DrawingArea()
# create pango layout
self.pangolayout = area.create_pango_layout("")
# extract only the image name without extenstion
text_buffer, ext = os.path.splitext(self._name)
text_buffer = " " + text_buffer + " "
self.pangolayout.set_text(text_buffer)
# set text attributes
attrs = pango.AttrList()
attrs.insert(pango.AttrFamily(LCONST.THUMB_TEXT_FAMILY, 0, -1))
attrs.insert(pango.AttrStyle(pango.STYLE_ITALIC, 0, -1))
attrs.insert(
pango.AttrForeground(LCONST.THUMB_TEXT_COLOR[0],
LCONST.THUMB_TEXT_COLOR[1],
LCONST.THUMB_TEXT_COLOR[2], 0, -1))
attrs.insert(pango.AttrBackground(0, 0, 0, 0, -1))
attrs.insert(pango.AttrSize(LCONST.THUMB_TEXT_SIZE, 0, -1))
self.pangolayout.set_attributes(attrs)
# compute text layout position and set it on pixmap
(w, h) = (self._pixbuf_thumb.get_width(),
self._pixbuf_thumb.get_height())
(lw, lh) = self.pangolayout.get_pixel_size()
pixmap.draw_layout(gc, (w - lw) // 2, (h - lh - 2), self.pangolayout)
# function get_from_drawable gets the the pixbuf from the pixmap
# no need to affect resuly to a new pisbuf: self._pixbuf_thumb is changed whe get_from_drawable is used
self._pixbuf_thumb.get_from_drawable(pixmap, pixmap.get_colormap(), 0,
0, 0, 0, -1, -1)
def on_configure(self, _, event):
window_height = event.height
attr = pango.AttrList()
attr.change(pango.AttrSize(int(self.options['fontsize']) * 1000, 0, -1))
attr.change(pango.AttrFamily(self.options['font'], 0, -1))
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1))
fgcolor = gtk.gdk.color_parse(self.fg)
attr.change(pango.AttrForeground(
fgcolor.red, fgcolor.green, fgcolor.blue, 0, -1))
self.pos_x = event.x
self.pos_y = event.y
if self.timer:
self.timer.cancel()
self.timer = Timer(self.options['timeout'], self.on_timeout)
self.timer.start()
self.label.set_attributes(attr)
def IconButton(c, box, icon, text_1, text_2, width, height, margin, f_1, p_1):
hbox = gtk.HBox()
hbox.set_border_width(margin)
button = gtk.Button()
button.set_size_request(width, height)
button.connect("clicked", f_1, *p_1)
inbox = gtk.VBox()
inbox.set_border_width(5)
image = gtk.Image()
image.set_from_file(icon)
attr = pango.AttrList()
size = pango.AttrSize(20000, 0, -1)
attr.insert(size)
title = gtk.Label()
title.set_markup(text_1)
title.set_justify(gtk.JUSTIFY_CENTER)
title.set_attributes(attr)
description = gtk.Label()
description.set_markup(text_2)
description.set_line_wrap(True)
description.set_justify(gtk.JUSTIFY_CENTER)
inbox.pack_start(image, False, False, 0)
inbox.pack_start(title, False, False, 0)
inbox.pack_start(gtk.HSeparator(), False, False, 5)
inbox.pack_start(description, False, False, 0)
button.add(inbox)
hbox.pack_start(button, False, False, 0)
box.pack_start(hbox, False, False, 0)
return button
def SetHeadingStyle(self, items):
for item in items:
if item not in self.headingsToColor:
self.headingsToColor.append(item)
HeadingStyle = pango.AttrList()
attr = pango.AttrSize(12000, 0, -1)
HeadingStyle.insert(attr)
if self.usecustomcolor:
headingcolor = gtk.gdk.color_parse(self.customheadingcolor)
attr = pango.AttrForeground(headingcolor.red, headingcolor.green,
headingcolor.blue, 0, -1)
HeadingStyle.insert(attr)
# else:
# headingcolor = self.window.rc_get_style().bg[ gtk.STATE_SELECTED ]
attr = pango.AttrWeight(pango.WEIGHT_BOLD, 0, -1)
HeadingStyle.insert(attr)
for item in items:
item.set_attributes(HeadingStyle)
def __init__(self, exaile, doubanfm_plugin):
self.exaile = exaile
self.dbfm_plugin = doubanfm_plugin
self.builder = gtk.Builder()
self.builder.add_from_file(get_resource_path('doubanfm_mode.ui'))
self.builder.connect_signals({
'on_bookmark_button_clicked':
self.on_bookmark_button_clicked,
'on_skip_button_clicked':
self.on_skip_button_clicked,
'on_delete_button_clicked':
self.on_delete_button_clicked,
'on_go_home_button_clicked':
self.on_go_home_button_clicked,
'on_item_setting_clicked':
self.on_button_setting_clicked,
'on_item_album_clicked':
self.on_button_album_clicked,
'on_item_report_clicked':
self.on_button_report_clicked,
'on_menu_toggle':
self.on_menu_toggle,
'on_quit':
self.on_quit,
'on_pausebutton_clicked':
self.on_pausebutton_clicked,
'on_recommend_song':
self.on_recommend_song,
'on_share_sina':
self.on_share_sina,
'on_share_renren':
self.on_share_renren,
'on_share_kaixin001':
self.on_share_kaixin001,
'on_share_twitter':
self.on_share_twitter,
'on_share_fanfou':
self.on_share_fanfou,
'on_copy_permalink':
self.on_copy_permalink,
})
self.window = self.builder.get_object('doubanfm_mode_window')
self.window.connect('destroy', self.hide)
volume = settings.get_option('player/volume', 1)
self.volume_control = playback.VolumeControl(player.PLAYER)
self.builder.get_object('hbox2').pack_start(self.volume_control)
self.cover_box = self.builder.get_object('cover_eventbox1')
self.info_area = info.TrackInfoPane(player.PLAYER)
self.cover = cover.CoverWidget(self.cover_box, player.PLAYER)
# self.cover_box.add(self.cover)
self.track_title_label = self.builder.get_object('track_title_label')
attr = pango.AttrList()
attr.change(pango.AttrWeight(pango.WEIGHT_BOLD, 0, 800))
attr.change(pango.AttrSize(12500, 0, 600))
self.track_title_label.set_attributes(attr)
self.track_info_label = self.builder.get_object('track_info_label')
self.bookmark_button = self.builder.get_object('bookmark_button')
self.trash_button = self.builder.get_object('delete_button')
self.skip_button = self.builder.get_object('skip_button')
self.pause_button = self.builder.get_object('pause_button')
self.popup_menu = self.builder.get_object('moremenu')
self.report_menuitem = self.builder.get_object('menuitem1')
self.album_menuitem = self.builder.get_object('menuitem2')
self.recmd_menuitem = self.builder.get_object('menuitem10')
self.sensitive_widgets = [
self.bookmark_button,
self.trash_button,
self.skip_button,
self.pause_button,
self.report_menuitem,
self.album_menuitem,
self.recmd_menuitem,
]
self.progress_bar = playback.PlaybackProgressBar(player.PLAYER)
self.builder.get_object('vbox2').pack_start(self.progress_bar)
self.visible = False
self.active = False
self._build_channel_menu()
event.add_callback(self.on_playback_start, 'playback_track_start',
player.PLAYER)
event.add_callback(self.on_playback_stop, 'playback_track_end',
player.PLAYER)
event.add_callback(self.on_pausebutton_toggled,
'playback_toggle_pause', player.PLAYER)
event.add_callback(self.on_tag_update, 'track_tags_changed')
self._toggle_id = self.exaile.gui.main.connect('main-visible-toggle',
self.toggle_visible)
## added for 0.3.2
self._init_alpha()
def generate_images(opts,args):
# Set up variables for drawing space
width = 2550 # Will resize to match text; default 8.5"x11" @ 300dpi
height = 3300
MARGIN_X = 300
MARGIN_Y = 300
LINE_SPACE = 35 #TODO: Command-line opts
LANG = "ka"
TESS_LANG = "kat"
# Set up decent spacing for box files
attrs = pango.AttrList() #TODO: Command line opts or config
attrs.insert(pango.AttrLanguage(LANG,0,-1))
attrs.insert(pango.AttrLetterSpacing(10000,0,-1))
attrs.insert(pango.AttrSize(48000,0,-1))
attrs.insert(pango.AttrFallback(False,0,-1))
attrs.insert(pango.AttrStyle(pango.STYLE_NORMAL,0,-1))
attrs.insert(pango.AttrWeight(pango.WEIGHT_NORMAL,0,-1))
attrs.insert(pango.AttrUnderline(pango.UNDERLINE_NONE,0,-1))
# Instantiate Cairo surface and context
surf = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
context = pangocairo.CairoContext(cairo.Context(surf))
# Instantiate PangoCairo context
context.set_antialias(cairo.ANTIALIAS_SUBPIXEL)
#get font families:
font_map = pangocairo.cairo_font_map_get_default()
# to see family names:
if opts.list_fonts:
print [f.get_name() for f in font_map.list_families()]
return
# Set up pango layout
layout = context.create_layout()
layout.set_attributes(attrs)
layout.set_width((width+MARGIN_X)*pango.SCALE)
layout.set_spacing(LINE_SPACE*pango.SCALE)
#print layout.get_width()
# Read text from file TODO: Command line argument
# TODO: Multiple files print to multiple image documents
text = ''
with codecs.open(opts.input_file) as text_file:
for line in text_file:
text += line + '\n'
font_names = args
# (variant, reset,"desc")
#Font variants is an array of tuples consisting of: (AttrStyle, InverseAttrStyle, Name)
font_variants = [
(pango.AttrStyle(pango.STYLE_NORMAL,0,-1),pango.AttrStyle(pango.STYLE_NORMAL,0,-1),"")]
#Add other stylings based on command-line options
if opts.italic:
font_variants.append((pango.AttrStyle(pango.STYLE_ITALIC,0,-1),pango.AttrStyle(pango.STYLE_NORMAL,0,-1),"italic"))
if opts.bold:
font_variants.append((pango.AttrWeight(pango.WEIGHT_HEAVY,0,-1),pango.AttrWeight(pango.WEIGHT_NORMAL,0,-1),"bold"))
if opts.underline:
font_variants.append((pango.AttrUnderline(pango.UNDERLINE_SINGLE,0,-1),pango.AttrUnderline(pango.UNDERLINE_NONE,0,-1),"underline"))
#Generate pages for each font name and variation.
for fn in font_names:
for fvar in font_variants:
# Change to a new variant
attrs.change(fvar[0])
layout.set_attributes(attrs)
# Change to a new font
fontname = fn
font = pango.FontDescription(fontname + " 25")
layout.set_font_description(font)
layout.set_text(text)
(ink, logical) = layout.get_pixel_extents()
# If layout exceeds size of surface, change surface size
if logical[2] > (width-MARGIN_X) or logical[3] > (height-MARGIN_Y):
width = logical[2]+MARGIN_X
height = logical[3]+MARGIN_Y
surf = cairo.ImageSurface(cairo.FORMAT_ARGB32, width, height)
context = pangocairo.CairoContext(cairo.Context(surf))
context.update_layout(layout)
#draw a background rectangle:
context.rectangle(0,0,width,height)
context.set_source_rgb(1, 1, 1)
context.fill()
# Translate context so that desired text upperleft corner is at 0,0
context.translate(50,25)
context.set_source_rgb(0, 0, 0)
context.update_layout(layout)
context.show_layout(layout)
# Write to image
# TODO: Specify outfile on command line
#print fontname
#print fvar[2]
with open(TESS_LANG+"."+fontname+fvar[2]+".exp0.png", "wb") as image_file:
surf.write_to_png(image_file)
attrs.change(fvar[1])
layout.set_attributes(attrs)
def __init__(self, img, *args):
self.img = img
self.x1, self.y1, self.x2, self.y2 = 0, 0, 0, 0
self.changed = False # decides a redraw of the arrow
self.miss = True # to enconter only once a missing element
self.headSize = 60 # side of the winghead in PX
self.wingAngle = 25 # angle from arrow direction to the side in °
self.brush = 11.0 # generated brush size
self.choice_i = argmenu[2] # index of arrow rendering choice
if self.choice_i > 3: # style with circle choice
self.slider3 = 50
self.a3min = 0
self.a3max = 200
else: # style with gradient choice
self.slider3 = 0 # value of third slider
self.a3min = -25 # initial min limit for slider3
self.a3max = +25 # initial max limit for slider3
self.segment_cr = 1 # segment counter
self.arrow_cr = 1 # arrow counter
self.l_arrow = 0.1 # arrow length
self.theta = 0 # arrow orientation angle in °
self.direct = True # arrow from first point to second if True
# Make a new GIMP layer to draw on
self.layer = gimp.Layer(img, _("AC_arrow #1"), img.width, img.height,
RGBA_IMAGE, 100, NORMAL_MODE)
img.add_layer(self.layer, 0)
# Verifies that it start at 1, not the case if we close and resume later
if version[1] == start_minver:
name_layer = pdb.gimp_drawable_get_name(self.layer)
elif version[1] > start_minver:
name_layer = pdb.gimp_item_get_name(self.layer)
if name_layer != _("AC_arrow #1"):
ind_past = name_layer.find('#') + 1
self.arrow_cr = int(name_layer[ind_past:])
# Create the dialog
win = gtk.Window.__init__(self, *args)
self.set_title(_("Arrow tool for GIMP"))
self.set_keep_above(
True) # keep the window on top when it looses focus
# The window manager quit signal:
self.connect("destroy", gtk.main_quit)
# Make the UI
self.set_border_width(10)
vbox = gtk.VBox(spacing=6, homogeneous=False)
self.add(vbox)
title_line = _("Arrows creator \n")
prompt_line = _(" To start: choose colours and path tool in design mode;")\
+_("\nplace now two path anchors (nodes) by clicking at future")\
+_("\narrow tail and head on the canvas (avoid closing the path).")\
+_("\n An arrow should appear, then adjust values in this window.")\
+_("\nIf not and you have followed the above, see end of status line.")\
+_("\n You should move those anchors for the rest of the session.")\
+_("\n To change the active arrow colour(s) and/or stroke path")\
+_("\nafter it's drawn: change it in GIMP and a thing in the arrow.\n")
# about 46 car. per line in 'label'
self.label = gtk.Label(title_line + prompt_line)
# Change attributes of the label first line
attr = pango.AttrList()
fg_color = pango.AttrForeground(0, 0, 65535, 0, len(title_line))
size = pango.AttrSize(17000, 0, 20)
bold = pango.AttrWeight(pango.WEIGHT_ULTRABOLD, 0, len(title_line))
attr.insert(fg_color)
attr.insert(size)
attr.insert(bold)
self.label.set_attributes(attr)
vbox.add(self.label)
separator = gtk.HSeparator()
vbox.pack_start(separator, expand=False)
table = gtk.Table(rows=3, columns=2, homogeneous=False)
table.set_col_spacings(10)
vbox.add(table)
# Arrowhead size
label = gtk.Label(_("Arrowing size (PX)"))
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0)
adj = gtk.Adjustment(self.headSize, 0, 200, 1)
adj.connect("value_changed", self.headsize_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
scale.set_has_tooltip(True)
scale.set_tooltip_text(_("arrow head side, 0 means no head"))
table.attach(scale, 1, 2, 0, 1)
# Arrowhead angle
label = gtk.Label(_(u"Arrowing angle (°)"))
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0)
adj = gtk.Adjustment(self.wingAngle, 1, 80, 1)
adj.connect("value_changed", self.headangle_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
scale.set_has_tooltip(True)
scale.set_tooltip_text(_("angle of a head wing in relation")\
+_("\nto head direction"))
table.attach(scale, 1, 2, 1, 2)
# Arrowshaft width
label = gtk.Label(_("Brush size (radius,PX)\n for '%s'") % brush_name)
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0)
adj = gtk.Adjustment(self.brush, 1.0, 25, 2.0, 2.0)
pdb.gimp_brush_set_radius(brush_name, self.brush)
adj.connect("value_changed", self.brush_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
scale.set_has_tooltip(True)
scale.set_tooltip_text(_("for the plug-in generated brush,")\
+_("\nit controls the shaft thickness."))
table.attach(scale, 1, 2, 2, 3)
# Fourth variable to be change by combo_box
self.label3 = gtk.Label(_("Nr of gradient, shaft"))
if version[1] > start_minver:
self.label3.set_label(_("Gradient in shaft"))
if self.choice_i > 3:
self.label3.set_label(_("Tail circle (radius,PX)"))
self.label3.set_alignment(xalign=0.0, yalign=1.0)
table.attach(self.label3, 0, 1, 3, 4, xoptions=gtk.FILL, yoptions=0)
self.adj = gtk.Adjustment(self.slider3, self.a3min, self.a3max, 1)
self.adj.connect("value_changed", self.slider3_cb)
self.adj.connect("changed", self.slider3_lim)
scale = gtk.HScale(self.adj)
scale.set_digits(0)
scale.set_has_tooltip(True)
scale.set_tooltip_text(_("the adjustment purpose can change")\
+_("\naccording to the arrow type"))
table.attach(scale, 1, 2, 3, 4)
table = gtk.Table(rows=1, columns=2, homogeneous=False)
table.set_col_spacings(10)
vbox.add(table)
# Make a combo-box for options (independent choice for shaft and head?)
choices = [
_("Assegai style"), #0
_("Square cut the shaft"), #1
_("Measuring arrow"), #2
_("Notched arrow"), #3
# from here third slider control the radius of a circle
_("Labelling arrow"), #4
_("Arrow with disk joint"), #5
_("Arrow from the stroke path")
] #6
# shaft only if choice is with head=0
vbox2 = gtk.VBox(spacing=8)
vbox2.set_border_width(10)
vbox.pack_start(vbox2)
combo_box = gtk.combo_box_new_text()
combo_box.set_wrap_width(1)
for i in range(len(choices)):
combo_box.append_text("%d- %s" % (i, choices[i]))
combo_box.set_active(self.choice_i)
combo_box.set_has_tooltip(True)
combo_box.set_tooltip_text(_("choice of arrow or segment type"))
combo_box.connect("changed", self.choice_i_cb)
table.attach(combo_box, 0, 1, 0, 1)
rbtn = gtk.CheckButton(_("Invert"))
rbtn.connect("toggled", self.direction_cb, None)
rbtn.set_has_tooltip(True)
rbtn.set_tooltip_text(_("inverse arrow direction"))
table.attach(rbtn, 1, 2, 0, 1)
separator = gtk.HSeparator()
vbox.pack_start(separator, expand=False)
# Show the actual arrow info
self.states = [
_("waiting for anchors "), #0
_("edit"), #1
_("open the path (try Back-Space)"), #2
_("needs two anchors "), #3
_("new localization"), #4
_("anchor outside canvas!"), #5
_("don't control that brush"), #6
_("block by identical anchors"), #7
_("completing the previous op."), #8
_("won't work for that image!")
] #9
#"placer votre sélection"
arrow_label = stub % (self.segment_cr, self.arrow_cr) + self.states[0]
l_label = len(arrow_label)
attr1 = pango.AttrList()
fg_color1 = pango.AttrForeground(30000, 20000, 0, 0, len(stub) - 2)
fg_color2 = pango.AttrForeground(0, 22000, 30000,
len(stub) - 2, l_label)
size = pango.AttrSize(11500, 0, l_label)
attr1.insert(fg_color1)
attr1.insert(fg_color2)
attr1.insert(size)
self.label2 = gtk.Label(arrow_label)
self.label2.set_alignment(0.0, 0.0)
self.label2.set_attributes(attr1)
self.label2.set_has_tooltip(True)
self.label2.set_tooltip_text(_("info and state of current op"))
vbox.add(self.label2)
# Make the dialog buttons box
separator = gtk.HSeparator()
vbox.pack_start(separator, expand=False)
hbox = gtk.HBox(spacing=20)
btn = gtk.Button(_("Next segment"))
btn.connect("pressed", self.next_seg)
btn.set_has_tooltip(True)
btn.set_tooltip_text(_("Mainly to produce a multi-segmented")\
+_("\nor many arrows on the previous layer"))
hbox.add(btn)
btn = gtk.Button(_("Next arrow"))
btn.connect("pressed", self.next_arrow)
btn.set_has_tooltip(True)
btn.set_tooltip_text(_("Create a new arrow layer"))
hbox.add(btn)
self.btnc = gtk.Button(_("Close"))
self.btnc.connect("pressed", self.press_close)
hbox.add(self.btnc)
vbox.add(hbox)
self.show_all()
self.update(*args)
def __init__(self, title, q_button_a, q_button_b, q_view, q_label, q_win,
event):
window = gtk.Window()
window.set_border_width(0)
window.set_title(title)
window.set_position(gtk.WIN_POS_CENTER_ALWAYS)
window.set_size_request(700, 470)
window.set_resizable(False)
window.set_icon_from_file(BAR_ICON)
window.connect("destroy", self.disable_close)
window.connect("delete-event", self.disable_close)
box = gtk.Fixed()
window.add(box)
attr = pango.AttrList()
size = pango.AttrSize(20000, 0, -1)
attr.insert(size)
str_message = _('Canaima installation has been completed')
message = gtk.Label(str_message)
message.set_size_request(640, 40)
message.set_alignment(0, 0)
message.set_line_wrap(True)
message.set_attributes(attr)
box.put(message, 50, 200)
str_intro = _('You can keep trying Canaima pressing "Restart Later" \
or enjoy your installed operating system by pressing "Restart Now".')
intro = gtk.Label(str_intro)
intro.set_size_request(640, 40)
intro.set_alignment(0, 0)
intro.set_line_wrap(True)
box.put(intro, 50, 250)
view = webkit.WebView()
view.set_size_request(700, 430)
box.put(view, 0, 0)
linea = gtk.HSeparator()
linea.set_size_request(700, 5)
box.put(linea, 0, 435)
label = gtk.Label()
label.set_justify(gtk.JUSTIFY_CENTER)
label.set_size_request(700, 20)
box.put(label, 0, 440)
button_a = gtk.Button()
button_a.set_size_request(150, 30)
button_a.set_label(_('Restart Later'))
button_a.connect('clicked', self.close)
box.put(button_a, 390, 440)
button_b = gtk.Button()
button_b.set_size_request(150, 30)
button_b.set_label(_('Restart Now'))
button_b.connect('clicked', self.reboot)
box.put(button_b, 540, 440)
box.set_flags(gtk.CAN_FOCUS)
atk_acc_vd(box, str_message + ". " + str_intro)
window.show_all()
button_a.hide()
button_b.hide()
q_view.put(view)
q_label.put(label)
q_win.put(window)
q_button_a.put(button_a)
q_button_b.put(button_b)
event.set()
self.view = view
def __init__ (self, img, *args):
self.img = img
self.x1, self.y1, self.x2, self.y2 = 0, 0, 0, 0
self.direction = DIREC_N
self.changed = False
self.arrowsize = 30
self.arrowangle = 25
self.num_grad = 0
# Make a new GIMP layer to draw on
self.layer = gimp.Layer(img, "arrow", img.width, img.height,
RGBA_IMAGE, 100, NORMAL_MODE)
img.add_layer(self.layer, 0)
# Create the dialog
win = gtk.Window.__init__(self, *args)
self.set_title("GIMP arrow tool")
# Mac may have a problem with the window disappearing below
# the image window. But on small screens, the window is big
# enough that it can block a lot of the image window.
# Ideally, it would be nice to make sure it's initially
# on top, but then let the user hide it later.
# Or make a checkbox for it in the dialog, but that would
# make the dialog even bigger.
#self.set_keep_above(True) # keep the window on top
# Obey the window manager quit signal:
self.connect("destroy", gtk.main_quit)
# Make the UI
self.set_border_width(10)
vbox = gtk.VBox(spacing=10, homogeneous=False)
self.add(vbox)
label = gtk.Label("Arrow designer by Akkana Peck\nMake a rectangular selection. Will use active colors, brush and gradient.")
# Change color of the label first line R. B.
attr = pango.AttrList()
fg_color = pango.AttrForeground(0, 0, 65535, 0, 30)
size = pango.AttrSize(17000, 0, 14)
bold = pango.AttrWeight(pango.WEIGHT_ULTRABOLD, 0, 14)
attr.insert(fg_color)
attr.insert(size)
attr.insert(bold)
label.set_attributes(attr)
vbox.add(label)
label.show()
table = gtk.Table(rows=3, columns=2, homogeneous=False)
table.set_col_spacings(10)
vbox.add(table)
# Arrow size and sharpness
label = gtk.Label("Arrowhead size (px)")
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0)
label.show()
adj = gtk.Adjustment(self.arrowsize, 1, 400, 1)
adj.connect("value_changed", self.arrowsize_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
table.attach(scale, 1, 2, 0, 1)
scale.show()
label = gtk.Label("Arrowhead angle (°)")
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 1, 2, xoptions=gtk.FILL, yoptions=0)
label.show()
adj = gtk.Adjustment(self.arrowangle, 1, 80, 1)
adj.connect("value_changed", self.arrowangle_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
table.attach(scale, 1, 2, 1, 2)
scale.show()
label = gtk.Label("Gradient repetitions")
label.set_alignment(xalign=0.0, yalign=1.0)
table.attach(label, 0, 1, 2, 3, xoptions=gtk.FILL, yoptions=0)
label.show()
adj = gtk.Adjustment(self.num_grad, 0, 50, 1)
adj.connect("value_changed", self.num_grad_cb)
scale = gtk.HScale(adj)
scale.set_digits(0)
table.attach(scale, 1, 2, 2, 3)
scale.show()
table.show()
# Selector for arrow direction
hbox = gtk.HBox(spacing=5)
btn = gtk.RadioButton(None, "N")
btn.set_active(True)
btn.connect("toggled", self.direction_cb, DIREC_N)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "NE")
btn.connect("toggled", self.direction_cb, DIREC_NE)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "E")
btn.connect("toggled", self.direction_cb, DIREC_E)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "SE")
btn.connect("toggled", self.direction_cb, DIREC_SE)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "S")
btn.connect("toggled", self.direction_cb, DIREC_S)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "SW")
btn.connect("toggled", self.direction_cb, DIREC_SW)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "W")
btn.connect("toggled", self.direction_cb, DIREC_W)
hbox.add(btn)
btn.show()
btn = gtk.RadioButton(btn, "NW")
btn.connect("toggled", self.direction_cb, DIREC_NW)
hbox.add(btn)
btn.show()
vbox.add(hbox)
hbox.show()
# Make the dialog buttons box
hbox = gtk.HBox(spacing=20)
btn = gtk.Button("Next arrow")
btn.connect("pressed", self.next_arrow)
hbox.add(btn)
btn.show()
btn = gtk.Button("Close")
btn.connect("clicked", self.close_window)
hbox.add(btn)
btn.show()
vbox.add(hbox)
hbox.show()
vbox.show()
self.show()
timeout_add(300, self.update, self)
return win
def get_calculated_rect(self, context, rect):
angle = 2 * math.pi * self._rotation / 360.0
if self._context == None:
label = gtk.Label()
self._context = label.create_pango_context()
pango_context = self._context
attrs = pango.AttrList()
attrs.insert(pango.AttrWeight(self._weight, 0, len(self._text)))
attrs.insert(pango.AttrStyle(self._slant, 0, len(self._text)))
attrs.insert(pango.AttrUnderline(self._underline, 0,
len(self._text)))
if self._size != None:
attrs.insert(pango.AttrSize(1000 * self._size, 0,
len(self._text)))
if self._layout == None:
self._layout = pango.Layout(pango_context)
layout = self._layout
if self._markup:
layout.set_markup(self._text)
else:
layout.set_text(self._text)
layout.set_attributes(attrs)
#find out where to draw the layout and calculate the maximum width
width = rect.width * math.cos(angle) + rect.height * math.sin(angle)
if self._anchor in [ANCHOR_BOTTOM_LEFT, ANCHOR_TOP_LEFT,
ANCHOR_LEFT_CENTER]:
width = rect.width - self._position[0]
elif self._anchor in [ANCHOR_BOTTOM_RIGHT, ANCHOR_TOP_RIGHT,
ANCHOR_RIGHT_CENTER]:
width = self._position[0]
text_width, text_height = layout.get_pixel_size()
width = min(width, self._max_width)
if self._wrap:
layout.set_wrap(pango.WRAP_WORD_CHAR)
layout.set_width(int(1000 * width))
#======================================================================
text_width, text_height = layout.get_pixel_size()
anchor = self._anchor
x, y = self._position
#anchor translation
tx, ty = 0, 0
ttx, tty = 0, 0
if anchor == ANCHOR_BOTTOM_LEFT:
tx = text_height * math.sin(angle)
ty = text_height * math.cos(angle)
ttx = 0
tty = text_height
elif anchor == ANCHOR_TOP_LEFT:
tx = 0
ty = 0
elif anchor == ANCHOR_TOP_RIGHT:
tx = text_width * math.cos(angle)
ty = -text_width * math.sin(angle)
ttx = text_width
tty = 0
elif anchor == ANCHOR_BOTTOM_RIGHT:
tx = text_width * math.cos(angle) + text_height * math.sin(angle)
ty = -text_width * math.sin(angle) + text_height * math.cos(angle)
ttx = text_width
tty = text_height
elif anchor == ANCHOR_CENTER:
tx = (text_width * math.cos(angle) + text_height * math.sin(angle)) / 2
ty = (-text_width * math.sin(angle) + text_height * math.cos(angle)) / 2
ttx = text_width / 2
tty = text_height / 2
elif anchor == ANCHOR_TOP_CENTER:
tx = text_width * math.cos(angle) / 2
ty = -text_width * math.sin(angle) / 2
ttx = text_width / 2
tty = 0
elif anchor == ANCHOR_BOTTOM_CENTER:
tx = text_width * math.cos(angle) / 2 + text_height * math.sin(angle)
ty = -text_width * math.sin(angle) / 2 + text_height * math.cos(angle)
ttx = text_width / 2
tty = text_height
elif anchor == ANCHOR_LEFT_CENTER:
tx = text_height * math.sin(angle) / 2
ty = text_height * math.cos(angle) / 2
ttx = 0
tty = text_height / 2
elif anchor == ANCHOR_RIGHT_CENTER:
tx = text_width * math.cos(angle) + text_height * math.sin(angle) / 2
ty = -text_width * math.sin(angle) + text_height * math.cos(angle) / 2
ttx = text_width
tty = text_height / 2
#calculate the bounding rect
real_x = x - ttx
real_y = y - tty
top_left = real_x, real_y
bottom_left = real_x , real_y + text_height
bottom_right = real_x + text_width, real_y + text_height
top_right = real_x + text_width, real_y
offset = x, y
n_top_left = rotate_vector(offset, top_left, angle)
n_bottom_left = rotate_vector(offset, bottom_left, angle)
n_bottom_right = rotate_vector(offset, bottom_right, angle)
n_top_right = rotate_vector(offset, top_right, angle)
alloc_x_min = int(min(n_top_left[0], n_bottom_left[0], n_bottom_right[0],
n_top_right[0]))
alloc_x_max = int(max(n_top_left[0], n_bottom_left[0], n_bottom_right[0],
n_top_right[0]))
alloc_y_min = int(min(n_top_left[1], n_bottom_left[1], n_bottom_right[1],
n_top_right[1]))
alloc_y_max = int(max(n_top_left[1], n_bottom_left[1], n_bottom_right[1],
n_top_right[1]))
rect = gtk.gdk.Rectangle(alloc_x_min, alloc_y_min,
alloc_x_max - alloc_x_min,
alloc_y_max - alloc_y_min)
return rect
def get_calculated_dimensions(self, context, rect):
angle = 2 * math.pi * self._rotation / 360.0
if self._context == None:
label = gtk.Label()
self._context = label.create_pango_context()
pango_context = self._context
attrs = pango.AttrList()
attrs.insert(pango.AttrWeight(self._weight, 0, len(self._text)))
attrs.insert(pango.AttrStyle(self._slant, 0, len(self._text)))
attrs.insert(pango.AttrUnderline(self._underline, 0, len(self._text)))
if self._size != None:
attrs.insert(pango.AttrSize(1000 * self._size, 0, len(self._text)))
if self._layout == None:
self._layout = pango.Layout(pango_context)
layout = self._layout
layout.set_text(self._text)
layout.set_attributes(attrs)
#find out where to draw the layout and calculate the maximum width
width = rect.width
if self._anchor in [
ANCHOR_BOTTOM_LEFT, ANCHOR_TOP_LEFT, ANCHOR_LEFT_CENTER
]:
width = rect.width - self._position[0]
elif self._anchor in [
ANCHOR_BOTTOM_RIGHT, ANCHOR_TOP_RIGHT, ANCHOR_RIGHT_CENTER
]:
width = self._position[0]
text_width, text_height = layout.get_pixel_size()
width = width * math.cos(angle)
width = min(width, self._max_width)
if self._wrap:
layout.set_wrap(pango.WRAP_WORD_CHAR)
layout.set_width(int(1000 * width))
x, y = get_text_pos(layout, self._position, self._anchor, angle)
if not self._fixed:
#Find already drawn labels that would intersect with the current one
#and adjust position to avoid intersection.
text_width, text_height = layout.get_pixel_size()
real_width = abs(text_width * math.cos(angle)) + abs(
text_height * math.sin(angle))
real_height = abs(text_height * math.cos(angle)) + abs(
text_width * math.sin(angle))
other_labels = get_registered_labels()
this_rect = gtk.gdk.Rectangle(int(x), int(y), int(real_width),
int(real_height))
for label in other_labels:
label_rect = label.get_allocation()
intersection = this_rect.intersect(label_rect)
if intersection.width == 0 and intersection.height == 0:
continue
y_diff = 0
if label_rect.y <= y and label_rect.y + label_rect.height >= y:
y_diff = y - label_rect.y + label_rect.height
elif label_rect.y > y and label_rect.y < y + real_height:
y_diff = label_rect.y - real_height - y
y += y_diff
#calculate the dimensions
text_width, text_height = layout.get_pixel_size()
real_width = abs(text_width * math.cos(angle)) + abs(
text_height * math.sin(angle))
real_height = abs(text_height * math.cos(angle)) + abs(
text_width * math.sin(angle))
return real_width, real_height
def create_new_toolbar(self):
toolbar_box = ToolbarBox()
activity_button = MyActivityToolbarButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
self.connect('go-fullscreen', \
self.__view_toolbar_go_fullscreen_cb)
self.back = ToolButton('go-previous')
self.back.set_tooltip(_('Back'))
self.back.props.sensitive = False
palette = self.back.get_palette()
self.menu_prev_page = MenuItem(text_label=_("Previous page"))
palette.menu.append(self.menu_prev_page)
self.menu_prev_page.show_all()
self.back.connect('clicked', self.go_back_cb)
self.menu_prev_page.connect('activate', self.go_back_cb)
toolbar_box.toolbar.insert(self.back, -1)
self.back.show()
self.forward = ToolButton('go-next')
self.forward.set_tooltip(_('Forward'))
self.forward.props.sensitive = False
palette = self.forward.get_palette()
self.menu_next_page = MenuItem(text_label=_("Next page"))
palette.menu.append(self.menu_next_page)
self.menu_next_page.show_all()
self.forward.connect('clicked', self.go_forward_cb)
self.menu_next_page.connect('activate', self.go_forward_cb)
toolbar_box.toolbar.insert(self.forward, -1)
self.forward.show()
num_page_item = gtk.ToolItem()
self.num_page_entry = gtk.Entry()
self.num_page_entry.set_text('0')
self.num_page_entry.set_alignment(1)
self.num_page_entry.connect('insert-text',
self.__new_num_page_entry_insert_text_cb)
self.num_page_entry.connect('activate',
self.__new_num_page_entry_activate_cb)
self.num_page_entry.set_width_chars(4)
num_page_item.add(self.num_page_entry)
self.num_page_entry.show()
toolbar_box.toolbar.insert(num_page_item, -1)
num_page_item.show()
total_page_item = gtk.ToolItem()
self.total_page_label = gtk.Label()
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
self.total_page_label.set_attributes(label_attributes)
self.total_page_label.set_text(' / 0')
total_page_item.add(self.total_page_label)
self.total_page_label.show()
toolbar_box.toolbar.insert(total_page_item, -1)
total_page_item.show()
spacer = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(spacer, -1)
spacer.show()
self._zoom_out = ToolButton('zoom-out')
self._zoom_out.set_tooltip(_('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
toolbar_box.toolbar.insert(self._zoom_out, -1)
self._zoom_out.props.sensitive = False
self._zoom_out.show()
self._zoom_in = ToolButton('zoom-in')
self._zoom_in.set_tooltip(_('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
toolbar_box.toolbar.insert(self._zoom_in, -1)
self._zoom_in.props.sensitive = True
self._zoom_in.show()
self._fullscreen = ToolButton('view-fullscreen')
self._fullscreen.set_tooltip(_('Fullscreen'))
self._fullscreen.connect('clicked', self._fullscreen_cb)
toolbar_box.toolbar.insert(self._fullscreen, -1)
self._fullscreen.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
stop_button.props.accelerator = '<Ctrl><Shift>Q'
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
def __init__(self, self_ventana_principal, self_seccion_stock):
if self_seccion_stock.tipo_producto == "merceria":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
0]
elif self_seccion_stock.tipo_producto == "lana":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
1]
elif self_seccion_stock.tipo_producto == "ropa":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
2]
elif self_seccion_stock.tipo_producto == "regaleria":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
3]
elif self_seccion_stock.tipo_producto == "jugueteria":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
4]
elif self_seccion_stock.tipo_producto == "santeria":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
5]
elif self_seccion_stock.tipo_producto == "bijouterie":
self.liststore_elejido = self_seccion_stock.total_liststore_productos[
6]
icono = "../Imagenes/fusa_icon.png"
self_ventana_principal.window.set_sensitive(False)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event,
self_ventana_principal)
self.window.set_title("Actualizar Producto")
self.window.set_resizable(False)
self.window.set_position(gtk.WIN_POS_CENTER)
#self.window.set_icon(gtk.gdk.pixbuf_new_from_file(icono) )
self.window.set_size_request(700, 400)
image_fondo = gtk.Image()
#image_fondo.set_from_file("../Imagenes/background2.svg")
self.fixed_generales = gtk.Fixed()
self.fixed_generales.add(image_fondo)
self.window.add(self.fixed_generales)
atributos = pango.AttrList()
atributos.insert(pango.AttrSize(14000, 0, -1))
atributos.insert(pango.AttrWeight(700, 0, -1))
fuente_entrys = "Sans 13"
font_entry = pango.FontDescription(fuente_entrys)
self.tipo_producto = gtk.Label("Tipo de Producto : ")
self.tipo_producto.set_attributes(atributos)
self.fixed_generales.put(self.tipo_producto, 20, 30)
self.entry_tipo_producto = gtk.Entry()
self.entry_tipo_producto.modify_font(font_entry)
self.fixed_generales.put(self.entry_tipo_producto, 190, 28)
self.entry_tipo_producto.set_property("editable", 0)
self.entry_tipo_producto.set_text(self_seccion_stock.tipo_producto)
self.codigo_producto = gtk.Label("Codigo : ")
self.codigo_producto.set_attributes(atributos)
self.fixed_generales.put(self.codigo_producto, 385, 30)
self.entry_codigo_producto = gtk.Entry()
self.entry_codigo_producto.modify_font(font_entry)
self.entry_codigo_producto.set_size_request(210, 30)
self.entry_codigo_producto.set_property("editable", 0)
self.fixed_generales.put(self.entry_codigo_producto, 470, 28)
self.entry_codigo_producto.set_text(
self_seccion_stock.datos_seleccionados_productos[2])
titulo_labels_generales = ("Ganancia : ", "Stock Inicial : ",
"Stock Disponible : ",
"Punto Reposicion : ")
#labels_cordenadaY_generales=(102,172,242,312)
labels_cordenadaY_generales = (102, 152, 202, 252)
self.labels_generales = []
for x in range(4):
self.labels_generales.append(gtk.Label(titulo_labels_generales[x]))
self.labels_generales[x].set_attributes(atributos)
self.fixed_generales.put(self.labels_generales[x], 180,
labels_cordenadaY_generales[x])
self.pin_generales = []
adj_generales = []
#coordenadasY=(100,170,240,310)
coordenadasY = (100, 150, 200, 250)
if self_seccion_stock.tipo_producto == "merceria" or self_seccion_stock.tipo_producto == "lana":
for x in range(4):
adj_generales.append(
gtk.Adjustment(value=0,
lower=0,
upper=999,
step_incr=0.1,
page_incr=0.1,
page_size=0))
self.pin_generales.append(
gtk.SpinButton(adjustment=adj_generales[x],
climb_rate=1.0,
digits=2))
self.pin_generales[x].set_numeric(True)
self.pin_generales[x].set_size_request(120, 28)
#self.pin_generales[x].set_max_length(3)
font_spin_generales = pango.FontDescription(fuente_entrys)
self.pin_generales[x].modify_font(font_spin_generales)
self.fixed_generales.put(self.pin_generales[x], 390,
coordenadasY[x])
else:
for x in range(4):
adj_generales.append(
gtk.Adjustment(value=0,
lower=0,
upper=999,
step_incr=1,
page_incr=1,
page_size=0))
self.pin_generales.append(
gtk.SpinButton(adjustment=adj_generales[x],
climb_rate=1.0,
digits=0))
self.pin_generales[x].set_numeric(True)
self.pin_generales[x].set_size_request(120, 28)
#self.pin_generales[x].set_max_length(3)
font_spin_generales = pango.FontDescription(fuente_entrys)
self.pin_generales[x].modify_font(font_spin_generales)
self.fixed_generales.put(self.pin_generales[x], 390,
coordenadasY[x])
b = len(self_seccion_stock.datos_seleccionados_productos)
self.fila_seleccionada = self_seccion_stock.datos_seleccionados_productos[
b - 1]
if self_seccion_stock.tipo_producto != "ropa":
self.pin_generales[0].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada,
6)) #ganancia
self.pin_generales[1].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada,
7)) #stk ini
self.pin_generales[2].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada,
8)) #stk dis
self.pin_generales[3].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada,
9)) #pnt rep
else:
self.pin_generales[0].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada, 7))
self.pin_generales[1].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada, 8))
self.pin_generales[2].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada, 9))
self.pin_generales[3].set_value(
self.liststore_elejido.get_value(self.fila_seleccionada, 10))
#botones
self.botones_totales = []
imagenes = []
ruta_imagenes = ("../Images/boton_aceptar.png",
"../Images/boton_cerrar.png")
for x in range(2):
imagenes.append(gtk.Image())
self.botones_totales.append(gtk.Button())
self.botones_totales[x].set_property("relief", 2)
#self.botones_totales[x].set_property("can-focus",0)
self.botones_totales[x].set_size_request(120, 40)
imagenes[x].set_from_file(ruta_imagenes[x])
self.botones_totales[x].add(imagenes[x])
self.botones_totales[0].connect("clicked", self.actualizar,
self_seccion_stock,
self_ventana_principal)
self.botones_totales[1].connect("clicked", self.destroy,
self_ventana_principal)
self.vbox1 = gtk.VBox(False, 0)
self.vbox1.set_size_request(700, 40)
botonera = gtk.HButtonBox()
botonera.set_property("layout-style", 1)
self.vbox1.pack_start(botonera, False, False, 2)
botonera.pack_start(self.botones_totales[0], False, True, 0)
botonera.pack_start(self.botones_totales[1], False, True, 0)
self.fixed_generales.put(self.vbox1, 0, 350)
self.window.show_all()
def __init__(self, widget, self_seccion_stock, self_ventana_principal):
self.codigo = []
self.codigos_repetidos = ["l", "L", "r", "R"]
object = self_ventana_principal.window
object.set_sensitive(False)
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(1131, 600)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title("Busqueda de productos")
self.window.set_resizable(False)
self.window.connect("delete-event", self.delete_event, object)
self.fixed = gtk.Fixed()
img = gtk.Image()
self.fixed.add(img)
self.window.add(self.fixed)
atributos = pango.AttrList()
atributos.insert(pango.AttrSize(12400, 0, -1))
atributos.insert(pango.AttrWeight(1200, 0, -1))
label_codigo = gtk.Label("Codigo : ")
label_descripcion = gtk.Label("Descripcion : ")
label_cantidad = gtk.Label("Cantidad : ")
label_codigo.set_attributes(atributos)
label_descripcion.set_attributes(atributos)
label_cantidad.set_attributes(atributos)
fuente_entrys = "Sans 13"
font_entry = pango.FontDescription(fuente_entrys)
self.entry = gtk.Entry()
self.entry_descripcion = gtk.Entry()
self.entry_cantidad = gtk.Entry()
self.entry.modify_font(font_entry)
self.entry_descripcion.modify_font(font_entry)
self.entry_cantidad.modify_font(font_entry)
self.fixed.put(self.entry, 150, 20)
self.fixed.put(self.entry_descripcion, 480, 20)
self.fixed.put(self.entry_cantidad, 750, 20)
self.fixed.put(label_codigo, 80, 25)
self.fixed.put(label_descripcion, 370, 25)
self.fixed.put(label_cantidad, 660, 25)
self.button_ma = gtk.Button()
self.button_ma.set_property("relief", 2)
imagen_boton_cerrar = gtk.Image()
imagen_boton_cerrar.set_from_file("../Images/boton_cerrar.png")
self.button_ma.add(imagen_boton_cerrar)
self.fixed.put(self.button_ma, 990, 550)
#agrego a una lista informacion de la bd
self.button_ma.connect("clicked", self.salir, object)
self.entry.connect("changed", self.mostrar, 'codigo')
self.entry.connect("activate", self.verificar_codigo, 'codigo')
self.entry_cantidad.connect("activate", self.cargar,
self_seccion_stock)
#--------------------------------------------------------------------------------------------------------------
self.scroll_win = gtk.ScrolledWindow()
self.scroll_win.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scroll_win.set_size_request(1111, 470)
self.fixed.put(self.scroll_win, 10, 70)
self.liststore = gtk.ListStore(str, int, str, str, float, float, str,
str, str, str, str, 'gboolean')
self.treeview = gtk.TreeView(self.liststore)
rules_hint = self.treeview.get_rules_hint()
self.treeview.set_rules_hint(True)
self.scroll_win.add(self.treeview)
self.columnpb = gtk.TreeViewColumn("")
self.column1 = gtk.TreeViewColumn("Codigo")
self.column2 = gtk.TreeViewColumn("Descripcion")
self.column3 = gtk.TreeViewColumn("Costo")
self.column4 = gtk.TreeViewColumn("Precio")
self.column5 = gtk.TreeViewColumn("Stock inicial")
self.column6 = gtk.TreeViewColumn("Stock disponible")
self.column7 = gtk.TreeViewColumn("punto de reposicion")
self.column8 = gtk.TreeViewColumn("Reponer")
self.treeview.append_column(self.columnpb)
self.treeview.append_column(self.column1)
self.treeview.append_column(self.column2)
self.treeview.append_column(self.column3)
self.treeview.append_column(self.column4)
self.treeview.append_column(self.column5)
self.treeview.append_column(self.column6)
self.treeview.append_column(self.column7)
self.cell = gtk.CellRendererText()
self.cellpb = gtk.CellRendererPixbuf()
self.cell.set_property("cell background", "#71ACE2")
self.cell.set_property('size',
14000) #solo le da el tamaño a las celdas xd
self.cell.set_property('weight',
700) #seria el "grosor" de la fuente :P
self.cellpb.set_property("cell background", "#71ACE2")
self.columnpb.pack_start(self.cellpb, True)
self.column1.pack_start(self.cell, True)
self.column2.pack_start(self.cell, True)
self.column3.pack_start(self.cell, True)
self.column4.pack_start(self.cell, True)
self.column5.pack_start(self.cell, True)
self.column6.pack_start(self.cell, True)
self.column7.pack_start(self.cell, True)
self.treeview.set_search_column(1)
self.treeview.set_search_column(2)
self.treeview.set_search_column(3)
self.treeview.set_search_column(4)
self.treeview.set_search_column(5)
self.treeview.set_search_column(6)
self.treeview.set_search_column(7)
self.column1.set_sort_column_id(2)
self.column2.set_sort_column_id(3)
self.column3.set_sort_column_id(4)
self.column4.set_sort_column_id(5)
self.column5.set_sort_column_id(6)
self.column6.set_sort_column_id(7)
self.column7.set_sort_column_id(8)
self.columnpb.set_expand(True)
self.column1.set_expand(True)
self.column2.set_expand(True)
self.column3.set_expand(True)
self.column4.set_expand(True)
self.column5.set_expand(True)
self.column6.set_expand(True)
self.column7.set_expand(True)
self.column1.set_resizable(True)
self.column2.set_resizable(True)
self.column3.set_resizable(True)
self.column4.set_resizable(True)
self.column5.set_resizable(True)
self.column6.set_resizable(True)
self.column7.set_resizable(True)
self.lista_columnas = []
self.lista_columnas.append(self.columnpb)
self.lista_columnas.append(self.column1)
self.lista_columnas.append(self.column2)
self.lista_columnas.append(self.column3)
self.lista_columnas.append(self.column4)
self.lista_columnas.append(self.column5)
self.lista_columnas.append(self.column6)
self.lista_columnas.append(self.column7)
self.lista_columnas.append(self.cell)
self.lista_columnas.append(self.cellpb)
self.setear_filas()
self.window.show_all()
def __init__(self, handle, create_jobject=True):
"The entry point to the Activity"
activity.Activity.__init__(self, handle)
self.selected_journal_entry = None
self.selected_path = None
self.update_log_entries = ''
self.close_requested = False
canvas = gtk.Notebook()
canvas.props.show_border = True
canvas.props.show_tabs = True
canvas.show()
self.ls_journal = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_UINT64,
gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.tv_journal = gtk.TreeView(self.ls_journal)
self.tv_journal.set_rules_hint(True)
self.tv_journal.set_search_column(COLUMN_TITLE)
self.selection_journal = self.tv_journal.get_selection()
self.selection_journal.set_mode(gtk.SELECTION_SINGLE)
self.selection_journal.connect("changed", self.selection_journal_cb)
renderer = gtk.CellRendererText()
renderer.set_property('wrap-mode', gtk.WRAP_WORD)
renderer.set_property('wrap-width', 500)
renderer.set_property('width', 500)
self.col_journal = gtk.TreeViewColumn(_('Title'), renderer,
text=COLUMN_TITLE)
self.col_journal.set_sort_column_id(COLUMN_TITLE)
self.tv_journal.append_column(self.col_journal)
size_renderer = gtk.CellRendererText()
size_renderer.set_property('width', 100)
size_renderer.set_property('alignment', pango.ALIGN_RIGHT)
size_renderer.set_property('xalign', 0.8)
self.col_size = gtk.TreeViewColumn(_('Size (KB)'), size_renderer,
text=COLUMN_SIZE)
self.col_size.set_sort_column_id(COLUMN_SIZE)
self.tv_journal.append_column(self.col_size)
mime_renderer = gtk.CellRendererText()
mime_renderer.set_property('width', 200)
self.col_mime = gtk.TreeViewColumn(_('MIME Type'), mime_renderer,
text=COLUMN_MIME)
self.col_mime.set_sort_column_id(COLUMN_MIME)
self.tv_journal.append_column(self.col_mime)
self.list_scroller_journal = gtk.ScrolledWindow(
hadjustment=None, vadjustment=None)
self.list_scroller_journal.set_policy(
gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.list_scroller_journal.add(self.tv_journal)
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(pango.AttrForeground(65535, 65535, 65535, 0, -1))
tab1_label = gtk.Label(_("Journal"))
tab1_label.set_attributes(label_attributes)
tab1_label.show()
self.tv_journal.show()
self.list_scroller_journal.show()
column_table = gtk.Table(rows=1, columns=2, homogeneous = False)
image_table = gtk.Table(rows=2, columns=2, homogeneous=False)
self.image = gtk.Image()
image_table.attach(self.image, 0, 2, 0, 1, xoptions=gtk.FILL|gtk.SHRINK,
yoptions=gtk.FILL|gtk.SHRINK, xpadding=10, ypadding=10)
self.dimension_label = gtk.Label("")
image_table.attach(self.dimension_label, 0, 2, 1, 2, xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.btn_resize = gtk.Button(_("Resize To Width"))
self.btn_resize.connect('button_press_event',
self.resize_button_press_event_cb)
image_table.attach(self.btn_resize, 0, 1, 2, 3, xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.resize_width_entry = gtk.Entry(max=4)
image_table.attach(self.resize_width_entry, 1, 2, 2, 3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.resize_width_entry.set_text('600')
self.resize_width_entry.connect('key_press_event',
self.resize_key_press_event_cb)
self.btn_save = gtk.Button(_("Save"))
self.btn_save.connect('button_press_event',
self.save_button_press_event_cb)
image_table.attach(self.btn_save, 0, 1, 3, 4, xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.btn_save.props.sensitive = False
self.btn_save.show()
self.btn_delete = gtk.Button(_("Delete"))
self.btn_delete.connect('button_press_event',
self.delete_button_press_event_cb)
image_table.attach(self.btn_delete, 1, 2, 3, 4, xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.btn_delete.props.sensitive = False
self.btn_delete.show()
entry_table = gtk.Table(rows=3, columns=2,
homogeneous=False)
title_label = gtk.Label(_("Title"))
entry_table.attach(title_label, 0, 1, 0, 1,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK,
xpadding=10, ypadding=10)
title_label.show()
self.title_entry = gtk.Entry(max=0)
entry_table.attach(self.title_entry, 1, 2, 0, 1,
xoptions=gtk.FILL|gtk.SHRINK,
yoptions=gtk.SHRINK, xpadding=10, ypadding=10)
self.title_entry.connect('key_press_event',
self.key_press_event_cb)
self.title_entry.show()
description_label = gtk.Label(_("Description"))
entry_table.attach(description_label, 0, 1, 1, 2,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK,
xpadding=10, ypadding=10)
description_label.show()
self.description_textview = gtk.TextView()
self.description_textview.set_wrap_mode(gtk.WRAP_WORD)
entry_table.attach(self.description_textview, 1, 2, 1, 2,
xoptions=gtk.EXPAND|gtk.FILL|gtk.SHRINK,
yoptions=gtk.EXPAND|gtk.FILL|gtk.SHRINK,
xpadding=10, ypadding=10)
self.description_textview.props.accepts_tab = False
self.description_textview.connect('key_press_event',
self.key_press_event_cb)
self.description_textview.show()
tags_label = gtk.Label(_("Tags"))
entry_table.attach(tags_label, 0, 1, 2, 3,
xoptions=gtk.SHRINK,
yoptions=gtk.SHRINK,
xpadding=10, ypadding=10)
tags_label.show()
self.tags_textview = gtk.TextView()
self.tags_textview.set_wrap_mode(gtk.WRAP_WORD)
entry_table.attach(self.tags_textview, 1, 2, 2, 3,
xoptions=gtk.FILL,
yoptions=gtk.EXPAND|gtk.FILL,
xpadding=10, ypadding=10)
self.tags_textview.props.accepts_tab = False
self.tags_textview.connect('key_press_event',
self.key_press_event_cb)
self.tags_textview.show()
entry_table.show()
scroller_image = gtk.ScrolledWindow(
hadjustment=None, vadjustment=None)
scroller_image.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroller_image.add_with_viewport(image_table)
scroller_image.show()
self.scroller_entry = gtk.ScrolledWindow(
hadjustment=None, vadjustment=None)
self.scroller_entry.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scroller_entry.add_with_viewport(entry_table)
self.scroller_entry.show()
column_table.attach(scroller_image, 0, 1, 0, 1,
xoptions=gtk.FILL|gtk.EXPAND|gtk.SHRINK,
yoptions=gtk.FILL|gtk.EXPAND|gtk.SHRINK,
xpadding=10, ypadding=10)
column_table.attach(self.scroller_entry, 1, 2, 0, 1,
xoptions=gtk.FILL|gtk.EXPAND|gtk.SHRINK,
yoptions=gtk.FILL|gtk.EXPAND|gtk.SHRINK,
xpadding=10, ypadding=10)
image_table.show()
column_table.show()
self.btn_resize.hide()
self.resize_width_entry.hide()
vbox = gtk.VBox(homogeneous=True, spacing=5)
vbox.pack_start(column_table)
vbox.pack_end(self.list_scroller_journal)
canvas.append_page(vbox, tab1_label)
self._filechooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_OPEN, backend=None)
self._filechooser.set_current_folder("/media")
self.copy_button = gtk.Button(_("Copy File To The Journal"))
self.copy_button.connect('clicked', self.create_journal_entry)
self.copy_button.show()
self._filechooser.set_extra_widget(self.copy_button)
preview = gtk.Image()
self._filechooser.set_preview_widget(preview)
self._filechooser.connect("update-preview",
self.update_preview_cb, preview)
tab2_label = gtk.Label(_("Files"))
tab2_label.set_attributes(label_attributes)
tab2_label.show()
canvas.append_page(self._filechooser, tab2_label)
self.set_canvas(canvas)
self.show_all()
self.btn_resize.hide()
self.resize_width_entry.hide()
self.dimension_label.hide()
toolbox = activity.ActivityToolbox(self)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.keep.props.visible = False
activity_toolbar.share.props.visible = False
self.set_toolbox(toolbox)
toolbox.show()
self.load_journal_table()
bus = dbus.SessionBus()
remote_object = bus.get_object(DS_DBUS_SERVICE, DS_DBUS_PATH)
_datastore = dbus.Interface(remote_object, DS_DBUS_INTERFACE)
_datastore.connect_to_signal('Created', self.datastore_created_cb)
_datastore.connect_to_signal('Updated', self.datastore_updated_cb)
_datastore.connect_to_signal('Deleted', self.datastore_deleted_cb)
self.selected_journal_entry = None
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.set_title("Ecomundo")
print "Init activity Ecomundo"
#print os.path.abspath(__file__)
toolbox = activity.ActivityToolbox(self)
self.toolbar = gtk.Toolbar()
toolbox.add_toolbar(_('Ecomundo'), self.toolbar)
self.toolbar.show()
self.set_toolbox(toolbox)
toolbox.show()
self.btnNew = ToolButton('reload')
self.btnNew.connect('clicked', self.onBtNewClicked)
self.toolbar.insert(self.btnNew, -1)
self.btnNew.show()
self.btPlay = ToolButton('next')
self.btPlay.connect('clicked', self.onBtPlayClicked)
self.toolbar.insert(self.btPlay, -1)
self.btPlay.show()
self.btStop = ToolButton('process-stop')
self.btStop.connect('clicked', self.onBtStopClicked)
self.toolbar.insert(self.btStop, -1)
self.btStop.show()
self.btStop.props.sensitive = False
self.btPlay.props.sensitive = True
toolbox.set_current_toolbar(1)
hBox = gtk.HBox(False, 0)
self.set_canvas(hBox)
self.drawingarea1 = gtk.DrawingArea()
self.drawingarea1.set_size_request(
World.SIZE_WORLD + (2 * World.MARGEN),
World.SIZE_WORLD + (2 * World.MARGEN))
self.drawingarea1.show()
hBox.pack_start(self.drawingarea1, False, True, 5)
table = gtk.Table(rows=4, columns=2, homogeneous=False)
hBox.pack_start(table, False, False, 5)
label_attributes = pango.AttrList()
label_attributes.insert(pango.AttrSize(14000, 0, -1))
label_attributes.insert(
pango.AttrForeground(65535, 65535, 65535, 0, -1))
lbTitle = gtk.Label()
lbTitle.set_attributes(label_attributes)
lbTitle.set_text(_('Initial Values'))
#table.attach(lbTitle, 0, 1, 0, 1,yoptions=gtk.SHRINK,xpadding=5)
table.attach(lbTitle, 0, 2, 0, 1, yoptions=gtk.SHRINK, xpadding=10)
lbGreen = gtk.Label()
lbGreen.set_attributes(label_attributes)
lbGreen.set_text(_('Green'))
table.attach(lbGreen,
0,
1,
1,
2,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjGreen = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbGreen = gtk.SpinButton(adjustment=adjGreen,
climb_rate=1.0,
digits=2)
table.attach(self.spbGreen,
1,
2,
1,
2,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
lbRabbit = gtk.Label()
lbRabbit.set_attributes(label_attributes)
lbRabbit.set_text(_('Rabbits'))
table.attach(lbRabbit,
0,
1,
2,
3,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjRabbit = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbRabbit = gtk.SpinButton(adjustment=adjRabbit,
climb_rate=1.0,
digits=2)
table.attach(self.spbRabbit,
1,
2,
2,
3,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
lbFox = gtk.Label()
lbFox.set_attributes(label_attributes)
lbFox.set_text(_('Foxs'))
table.attach(lbFox,
0,
1,
3,
4,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=10)
adjFox = gtk.Adjustment(10, 1, 400, 1, 1, 0)
self.spbFox = gtk.SpinButton(adjustment=adjFox,
climb_rate=1.0,
digits=2)
table.attach(self.spbFox,
1,
2,
3,
4,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
ypadding=10)
print "test resize"
print "antes de initWorld"
initWorld()
print "antes de init Green"
initGreen()
print "antes de init Animals"
initAnimals()
hBox.resize_children()
hBox.show_all()
self.drawingarea1.connect('expose-event', self.onDrawingAreaExposed)
def __init__(self, self_seccion_stock, self_ventana_principal):
self_ventana_principal.window.set_sensitive(False)
icono = "../Images/fusa_icon.png"
self.window = gtk.Window()
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_resizable(False)
self.window.set_title("Administrar Base De Datos Stock")
self.window.set_icon(gtk.gdk.pixbuf_new_from_file(icono))
self.window.set_size_request(620, 400)
self.window.connect("delete_event", self.cerrar,
self_ventana_principal)
image_fondo = gtk.Image()
#image_fondo.set_from_file("../Images/fondo_amdBD.png")
fixed_principal = gtk.Fixed()
fixed_principal.add(image_fondo)
self.window.add(fixed_principal)
atributos = pango.AttrList()
atributos.insert(pango.AttrSize(11000, 0, -1))
atributos.insert(pango.AttrWeight(1200, 0, -1))
label = gtk.Label()
label.set_markup("<b>Base de Datos Stock</b>")
label.set_use_markup(True)
frame = gtk.Frame()
frame.set_label_widget(label)
frame.set_property("shadow-type", 4)
frame.set_size_request(600, 310)
fixed_principal.put(frame, 10, 30)
fixed_frame = gtk.Fixed()
frame.add(fixed_frame)
self.button_backup = gtk.Button("Realizar Backup")
self.radio_crear = gtk.RadioButton(None, "Crear")
self.radio_crear.set_property("tooltip-text",
"Crear una nueva Base de Datos")
self.radio_especificar = gtk.RadioButton(self.radio_crear,
"Especificar")
self.radio_especificar.set_property(
"tooltip-text", "Buscar una Base de Datos existente")
self.radio_otras = gtk.RadioButton(self.radio_crear, "Backup")
self.radio_otras.set_property(
"tooltip-text",
"Indique el lugar donde desea \nrealizar el Backup")
fixed_frame.put(self.button_backup, 410, 70)
self.button_cerrar = gtk.Button("Cerrar")
#self.button_cerrar.set_property("relief",2)
self.button_cerrar.set_size_request(90, 40)
fixed_principal.put(self.button_cerrar, 520, 355)
fixed_frame.put(self.radio_crear, 40, 30)
fixed_frame.put(self.radio_especificar, 250, 30)
fixed_frame.put(self.radio_otras, 400, 30)
self.button_buscar = gtk.Button("Buscar...")
fixed_frame.put(self.button_buscar, 260, 70)
self.vbox = gtk.VBox(False, 0)
label_nombre = gtk.Label("Nombre : ")
self.entry_new_BD = gtk.Entry(12)
self.hcaja_crear = gtk.HBox()
self.hcaja_crear.set_size_request(200, 40)
self.hcaja_crear.set_property("homogeneous", 0)
self.hcaja_crear.pack_start(label_nombre, False, True, 1)
self.hcaja_crear.pack_start(self.entry_new_BD, True, True, 1)
self.vbox.pack_start(self.hcaja_crear, False, True, 1)
fixed_ruta = gtk.Fixed()
self.frame_ruta = gtk.Frame("Ruta de Archivo")
self.frame_ruta.set_property("shadow-type", 4)
self.frame_ruta.set_size_request(200, 130)
self.frame_ruta.add(fixed_ruta)
self.radio_predeterminada = gtk.RadioButton(None, "Predeterminada")
self.radio_indicar = gtk.RadioButton(self.radio_predeterminada,
"Indicar")
self.radio_indicar.set_property(
"tooltip-text",
"Especifique la ruta donde desea\nalojar la nueva Base de Datos")
self.button_indicar = gtk.Button("Indicar Ruta")
self.button_indicar.set_size_request(90, 25)
fixed_ruta.put(self.radio_predeterminada, 20, 10)
fixed_ruta.put(self.radio_indicar, 20, 60)
fixed_ruta.put(self.button_indicar, 100, 60)
self.vbox.pack_start(self.frame_ruta, False, True, 1)
self.aceptar_BD = gtk.Button("Aceptar")
self.vbox.pack_start(self.aceptar_BD, False, True, 1)
fixed_frame.put(self.vbox, 40, 70)
self.button_buscar.connect("clicked", self.buscarBD,
self_seccion_stock)
self.button_indicar.connect("clicked", self.indicarBD)
self.radio_crear.connect("toggled", self.elijio_crear)
self.radio_especificar.connect("toggled", self.elijio_especificar)
self.radio_otras.connect("toggled", self.elijio_otras)
self.radio_predeterminada.connect("toggled", self.desactivar_indicar)
self.radio_indicar.connect("toggled", self.activar_indicar)
self.entry_new_BD.connect("changed", self.entry_teclas)
self.button_backup.connect("clicked", self.realizar_backup)
self.button_cerrar.connect("clicked", self.cerrar_boton,
self_ventana_principal)
self.button_buscar.set_sensitive(False)
self.button_indicar.set_sensitive(False)
self.aceptar_BD.set_sensitive(False)
self.frame_ruta.set_sensitive(False)
self.hcaja_crear.set_sensitive(False)
self.button_cerrar.set_property("is-focus", 1)
self.radio_otras.set_active(True)
self.window.show_all()
