def __init__(self, parent=None):
# Create the toplevel window
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.set_title("Aspect Frame")
self.set_border_width(10)
# Create an aspect_frame and add it to our toplevel window
aspect_frame = gtk.AspectFrame(
"2x1", # label
0.5, # center x
0.5, # center y
2, # xsize/ysize = 2
False) # ignore child's aspect
self.add(aspect_frame)
aspect_frame.show()
# Now add a child widget to the aspect frame
drawing_area = gtk.DrawingArea()
# Ask for a 200x200 window, but the AspectFrame will give us a 200x100
# window since we are forcing a 2x1 aspect ratio
drawing_area.set_size_request(200, 200)
aspect_frame.add(drawing_area)
drawing_area.show()
self.show_all()
def set_up_ui(self):
self.board = boardwidget.GoBoardWidget(self.game.get_status(),
self.size)
self.board.connect('motion-notify-event', self.board_motion_cb)
self.board.connect('insert-requested', self.insert_cb)
self.main_view = gtk.VBox()
self.board_aspect = gtk.AspectFrame(None, .5, .5, 1, False)
self.board_aspect.add(self.board)
self.main_view.pack_start(self.board_aspect)
self.buttons_box = gtk.HBox()
self.buttons_alignment = gtk.Alignment(0.5, 1, 0.5, 1)
#Pass button
self.pass_button = gtk.Button(_('Pass'))
self.pass_button.connect("clicked", self.pass_cb)
self.buttons_box.pack_start(self.pass_button, True, True, 10)
#Undo button
self.undo_button = gtk.Button(_('Undo'))
self.undo_button.connect("clicked", self.undo_cb)
self.buttons_box.pack_start(self.undo_button, True, True, 10)
self.buttons_alignment.add(self.buttons_box)
self.main_view.pack_start(self.buttons_alignment, False, padding=10)
self.infopanel = infopanel.InfoPanel()
self.main_view.pack_start(self.infopanel, False)
self.set_canvas(self.main_view)
self.show_all()
def _create_box_cell(self, index):
""" """
self._create_menue_protozoon(index)
cellBox = gtk.VBox()
cellBox.set_border_width(3)
self._widget_list.remember('vbox_' + str(index), cellBox)
hBox = gtk.HBox()
openPopupButton = gtk.Button()
self._widget_list.remember('open_popup_' + str(index), openPopupButton)
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_OUT)
openPopupButton.add(arrow)
hBox.pack_start(openPopupButton, expand=False, fill=False)
fitnessScale = gtk.HScale()
self._widget_list.remember('fitness_' + str(index), fitnessScale)
fitnessScale.set_value_pos(gtk.POS_RIGHT)
fitnessScale.set_digits(0)
fitnessScale.set_adjustment(
gtk.Adjustment(value=1.0,
lower=0.0,
upper=10.0,
step_incr=1.0,
page_incr=1.0,
page_size=1.0))
hBox.pack_start(fitnessScale, expand=True, fill=True)
cellBox.pack_start(hBox, expand=False, fill=True)
aspectframe = gtk.AspectFrame()
drawingarea = gtk.DrawingArea()
self._widget_list.remember('drawingarea_' + str(index), drawingarea)
aspectframe.add(drawingarea)
cellBox.pack_start(aspectframe, expand=True, fill=True)
return cellBox
def __init__(self,
parent,
severity,
title,
message,
accept=False,
both=False,
run=True):
""""""
gtk.Dialog.__init__(self)
self.set_title("%s - %s" % (cons.TUCAN_NAME, title))
self.set_position(gtk.WIN_POS_CENTER)
self.set_resizable(False)
self.set_transient_for(parent)
self.accepted = False
hbox = gtk.HBox()
self.vbox.pack_start(hbox, True, True, 10)
aspect = gtk.AspectFrame()
hbox.pack_start(aspect, True, True, 10)
aspect.set_shadow_type(gtk.SHADOW_NONE)
if severity == cons.SEVERITY_WARNING:
icon = gtk.STOCK_DIALOG_WARNING
elif severity == cons.SEVERITY_ERROR:
icon = gtk.STOCK_DIALOG_ERROR
else:
icon = gtk.STOCK_DIALOG_INFO
hbox.pack_start(gtk.image_new_from_stock(icon, gtk.ICON_SIZE_DIALOG))
if parent:
self.set_icon(self.render_icon(icon, gtk.ICON_SIZE_MENU))
else:
self.set_icon_from_file(media.ICON_TUCAN)
self.label = gtk.Label(message)
hbox.pack_start(self.label)
self.label.set_width_chars(35)
self.label.set_line_wrap(True)
#action area
if both:
close_button = gtk.Button(None, gtk.STOCK_CANCEL)
self.action_area.pack_start(close_button)
close_button.connect("clicked", self.close)
ok_button = gtk.Button(None, gtk.STOCK_OK)
self.action_area.pack_start(ok_button)
ok_button.connect("clicked", self.accept)
elif accept:
ok_button = gtk.Button(None, gtk.STOCK_OK)
self.action_area.pack_start(ok_button)
ok_button.connect("clicked", self.accept)
else:
close_button = gtk.Button(None, gtk.STOCK_CLOSE)
self.action_area.pack_start(close_button)
close_button.connect("clicked", self.close)
self.connect("response", self.close)
self.show_all()
if run:
self.run()
def __init__(self):
self.old_width = 400
self.old_height = 300
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(TITLE)
self.window.set_default_size(self.old_width, self.old_height)
self.window.set_icon_from_file(ICON_IMAGE)
self.window.set_geometry_hints(min_width=100, min_height=100)
self.window.connect('destroy', self.on_exit)
vb = gtk.VBox()
self.window.add(vb)
# region IMAGE
# prepare pixel buffer
pixbuf_loader = gtk.gdk.pixbuf_loader_new_with_mime_type("image/png")
# fill with data
pixbuf_loader.write(data)
# release loader
pixbuf_loader.close()
# define pixbuf
pixbuf = pixbuf_loader.get_pixbuf()
# copy of original data for scaling
self.pixbuf_org = pixbuf.copy()
self.org_width = pixbuf.get_width()
self.org_height = pixbuf.get_height()
self.image = gtk.Image()
# get image ratio
image_ratio = float(self.org_width) / float(self.org_height)
# get window ratio
window_ratio = float(self.old_width) / float(self.old_height)
# fill window respecting aspect
if window_ratio >= image_ratio:
image_h = self.old_height
image_w = int(float(image_h) * image_ratio)
else:
image_w = self.old_width
image_h = int(float(image_w) / image_ratio)
# scale
pixbuf = pixbuf.scale_simple(image_w, image_h, gtk.gdk.INTERP_BILINEAR)
# convert pixbuf to image object
self.image.set_from_pixbuf(pixbuf)
# endregion
aspect_frame = gtk.AspectFrame(obey_child=True)
vb.pack_start(aspect_frame, True, False)
# drawing_area = gtk.DrawingArea()
aspect_frame.add(self.image)
self.window.connect('check-resize', self.scale, self.image,
image_ratio, pixbuf)
message = "Node ID:" + str(node) + " \"" + name + "\""
self.tooltips = gtk.Tooltips()
self.tooltips.set_tip(self.image, message)
self.window.connect("key-press-event", self._key_press_event)
self.window.show_all()
def __init__(self, parent=None):
gtk.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
# initialize last Window Size
self.old_width = 300
self.old_height = 300
self.set_default_size(self.old_width, self.old_height)
self.set_icon_from_file(ICON_IMAGE)
self.set_geometry_hints(min_width=100, min_height=100)
# region IMAGE
pixbuf = gtk.gdk.pixbuf_new_from_file(MAIN_IMAGE)
# copy of original data for scaling
self.pixbuf_org = pixbuf.copy()
self.org_width = pixbuf.get_width()
self.org_height = pixbuf.get_height()
# get image ratio
image_ratio = float(self.org_width) / float(self.org_height)
# get window ratio
window_ratio = float(self.old_width) / float(self.old_height)
# fill window respecting aspect
if window_ratio >= image_ratio:
image_h = self.old_height
image_w = int(float(image_h) * image_ratio)
else:
image_w = self.old_width
image_h = int(float(image_w) / image_ratio)
# scale
pixbuf = pixbuf.scale_simple(image_w, image_h, gtk.gdk.INTERP_BILINEAR)
# convert pixbuf to image object
image = gtk.Image()
image.set_from_pixbuf(pixbuf)
# endregion
#region FRAME
# Create an aspect_frame and add it to our toplevel window
aspect_frame = gtk.AspectFrame(obey_child=True)
# aspect_frame.draw_border
self.add(aspect_frame)
# Now add a child widget to the aspect frame
aspect_frame.add(image)
#endregion
# bind callback to check-resize event
self.connect('check-resize', self.scale, image, image_ratio, pixbuf)
self.show_all()
def create_gui(self):
""" """
page = gtk.HBox()
self._widget_list.remember('zoomPage', page)
aspectframe = gtk.AspectFrame()
drawingarea = gtk.DrawingArea()
self._widget_list.remember('zoomarea', drawingarea)
aspectframe.add(drawingarea)
page.pack_start(aspectframe, expand=True, fill=True)
return page, gtk.Label(_('Zoom'))
def __init__(self, parent, target):
gtk.Dialog.__init__(
self,
C_(
u"HCY Gamut Mask new-from-template dialog: window title",
"New Gamut Mask from Template",
),
parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT),
)
self.set_position(gtk.WIN_POS_MOUSE)
target_mgr = target.get_color_manager()
prefs_ro = deepcopy(target_mgr.get_prefs())
datapath = target_mgr.get_data_path()
mgr = ColorManager(prefs=prefs_ro, datapath=datapath)
mgr.set_wheel_type(target_mgr.get_wheel_type())
self.target = target
for name, desc, mask_shapes_float in self.__templates:
mask = []
for mask_shape_float in mask_shapes_float:
shape = []
for h, c, y in mask_shape_float:
h = mgr.undistort_hue(h)
shape.append(HCYColor(h, c, y))
mask.append(shape)
label = gtk.Label()
label.set_markup("<b>%s</b>\n\n%s" % (name, desc))
label.set_size_request(375, -1)
label.set_line_wrap(True)
label.set_alignment(0, 0.5)
preview = HCYMaskPreview()
preview.set_color_manager(mgr)
preview.set_mask(mask)
preview_frame = gtk.AspectFrame(obey_child=True)
preview_frame.add(preview)
preview_frame.set_shadow_type(gtk.SHADOW_NONE)
hbox = gtk.HBox()
hbox.set_spacing(6)
hbox.pack_start(preview_frame, False, False)
hbox.pack_start(label, True, True)
button = gtk.Button()
button.add(hbox)
button.set_relief(gtk.RELIEF_NONE)
button.connect("clicked", self.__button_clicked_cb, mask)
self.vbox.pack_start(button, True, True)
self.connect("response", self.__response_cb)
self.connect("show", self.__show_cb)
for w in self.vbox:
w.show_all()
ref_color = target.get_managed_color()
mgr.set_color(ref_color)
def __init__(self):
self.generated = False
self.half = 32767 #50% alpha
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("qrgen")
self.window.connect("delete_event", gtk.main_quit)
self.mainbox = gtk.HBox(False, 0)
self.optbox = gtk.VBox(False, 0)
self.options = self.getOptionPane()
self.options.set_expanded(True)
self.advanced = self.getAdvancedPane()
self.debug = self.getDebugPane()
self.genbox = gtk.HBox(False, 0)
self.entry = gtk.Entry()
self.entry.set_text("green pride")
self.entry.connect("changed", self.sichanged)
self.button1 = gtk.Button("Generate")
self.button1.connect("clicked", self.sichanged)
self.genbox.pack_start(self.button1, False, False, 0)
self.genbox.pack_start(self.entry, True, True, 0)
self.aframe = gtk.AspectFrame(None, 0, 0, 1.0, False)
self.screen = Screen()
self.aframe.add(self.screen)
self.optbox.pack_start(self.genbox, False, False, 0)
self.optbox.pack_start(self.options, False, False, 0)
self.optbox.pack_start(self.advanced, False, False, 0)
self.optbox.pack_start(self.debug, False, False, 0)
self.mainbox.pack_start(self.optbox, False, False, 0)
self.mainbox.pack_start(self.aframe, True, True, 0)
self.window.add(self.mainbox)
self.window.set_default_size(390, 150)
self.genbox.show_all()
self.aframe.show_all()
self.optbox.show()
self.mainbox.show()
self.window.show()
def __init__(self, label=None, size=None, aspect=False):
# Create a regular/aspect frame
self.frame = gtk.AspectFrame() if aspect else gtk.Frame()
self.frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.size = size
if label:
self.frame.set_label(label)
self.frame.set_label_align(0.0, 0.0)
frame_label = self.frame.get_label_widget()
markup_str = '<span foreground="%s" size="x-large">%s</span>'
frame_label.set_markup(markup_str % ('black', label))
if size:
width, height = size
self.frame.set_size_request(width, height)
if aspect:
self.frame.set(ratio=(float(width) / height))
def __init__(self):
self._faces = ['h', 's', 'v']
gtk.VBox.__init__(self)
ColorAdjuster.__init__(self)
self.__square = _HSVSquareInnerSquare(self)
self.__ring = _HSVSquareOuterRing(self)
s_align = gtk.Alignment(xalign=0.5,
yalign=0.5,
xscale=0.54,
yscale=0.54)
plz_be_square = gtk.AspectFrame()
plz_be_square.set_shadow_type(gtk.SHADOW_NONE)
s_align.add(plz_be_square)
plz_be_square.add(self.__square)
self.__ring.add(s_align)
self.pack_start(self.__ring, True, True)
def __init__(self):
self._faces = ['h', 's', 'v']
gtk.VBox.__init__(self)
ColorAdjuster.__init__(self)
self.__slice = HSVCubeSlice(self)
self.__slider = HSVCubeSlider(self)
s_align = gtk.Alignment(xalign=0.5,
yalign=0.5,
xscale=0.54,
yscale=0.54)
plz_be_square = gtk.AspectFrame()
plz_be_square.set_shadow_type(gtk.SHADOW_NONE)
s_align.add(plz_be_square)
plz_be_square.add(self.__slice)
self.__slider.add(s_align)
self.pack_start(self.__slider, True, True)
def _create_box_incomming(self, index):
""" """
self._create_menue_incomming(index)
cellBox = gtk.VBox()
hBox = gtk.HBox()
openPopupButton = gtk.Button()
self._widget_list.remember('incomingbutton_' + str(index),
openPopupButton)
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_OUT)
openPopupButton.add(arrow)
hBox.pack_start(openPopupButton, expand=False, fill=False)
cellBox.pack_start(hBox, expand=False, fill=True)
aspectframe = gtk.AspectFrame()
drawingarea = gtk.DrawingArea()
self._widget_list.remember('incomingarea_' + str(index), drawingarea)
aspectframe.add(drawingarea)
cellBox.pack_start(aspectframe, expand=True, fill=True)
return cellBox
def __init__(self):
window = gtk.Window(gtk.WINDOW_TOPLEVEL);
window.set_title("Aspect Frame")
window.connect("destroy", lambda x: gtk.main_quit())
window.set_border_width(10)
# Create an aspect_frame and add it to our toplevel window
aspect_frame = gtk.AspectFrame("2x1", # label
0.5, # center x
0.5, # center y
2, # xsize/ysize = 2
False) # ignore child's aspect
window.add(aspect_frame)
aspect_frame.show()
# Now add a child widget to the aspect frame
drawing_area = gtk.DrawingArea()
# Ask for a 200x200 window, but the AspectFrame will give us a 200x100
# window since we are forcing a 2x1 aspect ratio
drawing_area.set_size_request(200, 200)
aspect_frame.add(drawing_area)
drawing_area.show()
window.show()
def _createUi(self):
""" Creates the Viewer GUI """
# drawing area
self.aframe = gtk.AspectFrame(xalign=0.5,
yalign=0.5,
ratio=4.0 / 3.0,
obey_child=False)
self.pack_start(self.aframe, expand=True)
self.internal = ViewerWidget(self.action)
self.internal.show()
self.aframe.add(self.internal)
self.external_window = gtk.Window()
vbox = gtk.VBox()
vbox.set_spacing(SPACING)
self.external_window.add(vbox)
self.external = ViewerWidget(self.action)
vbox.pack_start(self.external)
self.external_window.connect("delete-event",
self._externalWindowDeleteCb)
self.external_window.connect("configure-event",
self._externalWindowConfigureCb)
self.external_vbox = vbox
self.external_vbox.show_all()
# Slider
self.posadjust = gtk.Adjustment()
self.slider = gtk.HScale(self.posadjust)
self.slider.set_draw_value(False)
self.slider.connect("button-press-event", self._sliderButtonPressCb)
self.slider.connect("button-release-event",
self._sliderButtonReleaseCb)
self.slider.connect("scroll-event", self._sliderScrollCb)
self.pack_start(self.slider, expand=False)
self.moving_slider = False
self.slider.set_sensitive(False)
# Buttons/Controls
bbox = gtk.HBox()
boxalign = gtk.Alignment(xalign=0.5, yalign=0.5)
boxalign.add(bbox)
self.pack_start(boxalign, expand=False)
self.goToStart_button = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS)
self.goToStart_button.connect("clicked", self._goToStartCb)
self.goToStart_button.set_tooltip_text(
_("Go to the beginning of the timeline"))
self.goToStart_button.set_sensitive(False)
bbox.pack_start(self.goToStart_button, expand=False)
self.back_button = gtk.ToolButton(gtk.STOCK_MEDIA_REWIND)
self.back_button.connect("clicked", self._backCb)
self.back_button.set_tooltip_text(_("Go back one second"))
self.back_button.set_sensitive(False)
bbox.pack_start(self.back_button, expand=False)
self.playpause_button = PlayPauseButton()
self.playpause_button.connect("play", self._playButtonCb)
bbox.pack_start(self.playpause_button, expand=False)
self.playpause_button.set_sensitive(False)
self.forward_button = gtk.ToolButton(gtk.STOCK_MEDIA_FORWARD)
self.forward_button.connect("clicked", self._forwardCb)
self.forward_button.set_tooltip_text(_("Go forward one second"))
self.forward_button.set_sensitive(False)
bbox.pack_start(self.forward_button, expand=False)
self.goToEnd_button = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT)
self.goToEnd_button.connect("clicked", self._goToEndCb)
self.goToEnd_button.set_tooltip_text(
_("Go to the end of the timeline"))
self.goToEnd_button.set_sensitive(False)
bbox.pack_start(self.goToEnd_button, expand=False)
# current time
self.timecode_entry = TimeWidget()
self.timecode_entry.setWidgetValue(0)
self.timecode_entry.connect("value-changed", self._jumpToTimecodeCb)
self.timecode_entry.connectFocusEvents(self._entryFocusInCb,
self._entryFocusOutCb)
bbox.pack_start(self.timecode_entry, expand=False, padding=10)
self._haveUI = True
screen = gdk.screen_get_default()
height = screen.get_height()
if height >= 800:
# show the controls and force the aspect frame to have at least the same
# width (+110, which is a magic number to minimize dead padding).
bbox.show_all()
width, height = bbox.size_request()
width += 110
height = int(width / self.aframe.props.ratio)
self.aframe.set_size_request(width, height)
self.show_all()
self.buttons = boxalign
def __init__(self, section, name, config, accounts=False):
""""""
gtk.VBox.__init__(self)
vbox = gtk.VBox()
frame = gtk.Frame()
label = gtk.Label()
label.set_markup("<big><b>" + name + "</b></big>")
frame.set_label_widget(label)
frame.set_border_width(10)
self.pack_start(frame)
frame.add(vbox)
hbox = gtk.HBox()
label = gtk.Label()
label.set_markup("<b>" + _("Author") + ":</b>")
hbox.pack_start(label, False, False, 10)
label = gtk.Label(config.get(section, service_config.OPTION_AUTHOR))
hbox.pack_start(label, False)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
label = gtk.Label()
label.set_markup("<b>" + _("Version") + ":</b>")
hbox.pack_start(label, False)
label = gtk.Label(config.get(section, service_config.OPTION_VERSION))
hbox.pack_start(label, False, False, 10)
vbox.pack_start(hbox, False, False, 5)
if not accounts:
hbox = gtk.HBox()
label = gtk.Label()
label.set_markup("<b>" + _("Slots") + ":</b>")
hbox.pack_start(label, False, False, 10)
label = gtk.Label(config.get_slots(section))
hbox.pack_start(label, False)
vbox.pack_start(hbox, False, False, 5)
hbox = gtk.HBox()
label = gtk.Label()
label.set_markup("<b>" + _("Captcha") + ":</b>")
hbox.pack_start(label, False, False, 10)
label = gtk.Label(config.get(section, service_config.OPTION_CAPTCHA))
hbox.pack_start(label, False)
vbox.pack_start(hbox, False, False, 5)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
vbox.pack_start(aspect)
hbox = gtk.HBox()
vbox.pack_start(hbox, False, False, 5)
label = gtk.Label()
label.set_markup("<b>%s:</b>\n<i>* %s</i>" % (_("Wait"), _("Seconds to wait on Limit Exceeded.")))
hbox.pack_start(label, False, False, 5)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
wait = gtk.SpinButton(None, 4, 0)
wait.set_property("shadow-type", gtk.SHADOW_NONE)
wait.set_range(5,3600)
wait.set_increments(5,0)
wait.set_numeric(True)
wait.set_value(config.get_wait(section))
hbox.pack_start(wait, False, False, 5)
wait.connect("value-changed", self.change_wait, section, config.set_wait)
def __init__(self, section, name, config, get_cookie):
""""""
InfoPreferences.__init__(self, section, name, config, True)
self.get_cookie = get_cookie
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_ACCOUNT))
frame.set_border_width(10)
self.pack_start(frame, False, False, 1)
scroll = gtk.ScrolledWindow()
scroll.set_size_request(-1, 110)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
frame.add(scroll)
store = gtk.ListStore(gtk.gdk.Pixbuf, str, str, bool, bool, str)
self.treeview = gtk.TreeView(store)
scroll.add(self.treeview)
self.treeview.set_rules_hint(True)
#self.treeview.set_headers_visible(False)
tree_icon = gtk.TreeViewColumn('Active')
icon_cell = gtk.CellRendererPixbuf()
icon_cell.set_property("width", 50)
tree_icon.pack_start(icon_cell, True)
tree_icon.add_attribute(icon_cell, 'pixbuf', 0)
self.treeview.append_column(tree_icon)
tree_name = gtk.TreeViewColumn('User Name')
name_cell = gtk.CellRendererText()
name_cell.set_property("width", 120)
name_cell.set_property("editable", True)
name_cell.connect("edited", self.change, 1)
tree_name.pack_start(name_cell, True)
tree_name.add_attribute(name_cell, 'text', 1)
self.treeview.append_column(tree_name)
tree_pass = gtk.TreeViewColumn('Password')
pass_cell = gtk.CellRendererText()
pass_cell.set_property("width", 120)
pass_cell.set_property("editable", True)
pass_cell.connect("edited", self.change, 2)
pass_cell.connect("editing-started", self.show_password)
tree_pass.pack_start(pass_cell, True)
tree_pass.add_attribute(pass_cell, 'text', 5)
self.treeview.append_column(tree_pass)
tree_enable = gtk.TreeViewColumn('Enable')
enable_cell = gtk.CellRendererToggle()
enable_cell.connect("toggled", self.toggled)
tree_enable.pack_start(enable_cell, False)
tree_enable.add_attribute(enable_cell, 'visible', 4)
tree_enable.add_attribute(enable_cell, 'active', 3)
self.treeview.append_column(tree_enable)
self.active_service_icon = self.treeview.render_icon(gtk.STOCK_YES, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.unactive_service_icon = self.treeview.render_icon(gtk.STOCK_NO, gtk.ICON_SIZE_LARGE_TOOLBAR)
accounts = config.get_accounts(section)
for name in accounts.keys():
password, enabled, active = accounts[name]
if active:
icon = self.active_service_icon
else:
icon = self.unactive_service_icon
store.append([icon, name, password, enabled, active, "".join(["*" for i in range(len(password))])])
frame = gtk.Frame()
frame.set_border_width(10)
frame.set_shadow_type(gtk.SHADOW_NONE)
self.pack_start(frame, False, False)
bbox = gtk.HButtonBox()
bbox.set_layout(gtk.BUTTONBOX_EDGE)
frame.add(bbox)
button = gtk.Button(None, gtk.STOCK_ADD)
button.connect("clicked", self.add)
bbox.pack_start(button)
button = gtk.Button(None, gtk.STOCK_REMOVE)
button.connect("clicked", self.remove)
bbox.pack_start(button)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
bbox.pack_start(aspect)
button = gtk.Button(None, gtk.STOCK_CONNECT)
button.connect("clicked", self.check)
bbox.pack_start(button)
def __init__(self):
gtk.Dialog.__init__(
self,
title=_("Program Information"),
parent=common.get_main_window(),
flags=gtk.DIALOG_DESTROY_WITH_PARENT | gtk.DIALOG_NO_SEPARATOR,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK,
gtk.RESPONSE_OK))
self.set_border_width(5)
self.accel_group = gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.hbox = gtk.HBox()
self.hbox.set_spacing(6)
self.vbox.pack_start(self.hbox, expand=True, fill=True, padding=0)
# Icon setup
self.vbox_icon = gtk.VBox()
self.hbox.pack_start(self.vbox_icon,
expand=False,
fill=False,
padding=0)
self.button_icon = gtk.Button()
self.button_icon.set_accel_path
self.button_icon.add_accelerator('grab-focus', self.accel_group,
ord('i'), gtk.gdk.MOD1_MASK, 0)
self.vbox_icon.pack_start(self.button_icon,
expand=False,
fill=False,
padding=0)
self.button_icon_aspectframe = gtk.AspectFrame()
self.button_icon_aspectframe.set_shadow_type(gtk.SHADOW_NONE)
self.button_icon.add(self.button_icon_aspectframe)
self.icon = gtk.Image()
self.icon.filename = None
self.button_icon_aspectframe.add(self.icon)
# Fields setup
self.table = gtk.Table()
self.table.set_row_spacings(6)
self.table.set_col_spacings(6)
self.hbox.pack_start(self.table, expand=True, fill=True, padding=0)
row = 0
self.label_type = gtk.Label(_('_Type:'))
self.label_type.set_use_underline(True)
self.label_type.set_alignment(1.0, 0.5)
self.combobox_type = gtk.combo_box_new_text()
self.combobox_type.append_text(_('Application'))
self.combobox_type.append_text(_('Application in Terminal'))
self.label_type.set_mnemonic_widget(self.combobox_type)
self.table.attach(self.label_type, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.combobox_type, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_name = gtk.Label(_('_Name:'))
self.label_name.set_use_underline(True)
self.label_name.set_alignment(1.0, 0.5)
self.entry_name = gtk.Entry()
self.label_name.set_mnemonic_widget(self.entry_name)
self.table.attach(self.label_name, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_name, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_command = gtk.Label(_('Comm_and:'))
self.label_command.set_use_underline(True)
self.label_command.set_alignment(1.0, 0.5)
self.entry_command = gtk.Entry()
self.label_command.set_mnemonic_widget(self.entry_command)
self.button_command = gtk.Button(_('_Browse...'))
self.table.attach(self.label_command, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_command, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
self.table.attach(self.button_command, 2, 3, row, row + 1, gtk.FILL, 0)
row += 1
self.label_comment = gtk.Label(_('Co_mment:'))
self.label_comment.set_use_underline(True)
self.label_comment.set_alignment(1.0, 0.5)
self.entry_comment = gtk.Entry()
self.label_comment.set_mnemonic_widget(self.entry_comment)
self.table.attach(self.label_comment, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.entry_comment, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_uninstall = gtk.Label(_('_Uninstall:'))
self.label_uninstall.set_use_underline(True)
self.label_uninstall.set_alignment(1.0, 0.5)
self.entry_uninstall = gtk.Entry()
self.label_uninstall.set_mnemonic_widget(self.entry_uninstall)
self.table.attach(self.label_uninstall, 0, 1, row, row + 1, gtk.FILL,
0)
self.table.attach(self.entry_uninstall, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_category = gtk.Label(_('C_ategory:'))
self.label_category.set_use_underline(True)
self.label_category.set_alignment(1.0, 0.5)
self.combobox_category = gtk.ComboBoxEntry()
self.combobox_category_completion = gtk.EntryCompletion()
self.combobox_category.child.set_completion(
self.combobox_category_completion)
self.combobox_category_model = gtk.ListStore(str)
self.combobox_category.set_model(self.combobox_category_model)
self.combobox_category.set_text_column(0)
self.combobox_category_completion.set_model(
self.combobox_category_model)
self.combobox_category_completion.set_text_column(0)
for category in wine.common.XDG_MENU_CATEGORIES:
self.combobox_category_model.append((category, ))
self.label_category.set_mnemonic_widget(self.combobox_category)
self.checkbutton_showinmenu = gtk.CheckButton(_('_Show in menu'), True)
self.checkbutton_showinmenu.set_tooltip_text(
_("Note that the program may not show up in the menu until you have clicked ok"
))
self.table.attach(self.label_category, 0, 1, row, row + 1, gtk.FILL, 0)
self.table.attach(self.combobox_category, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
self.table.attach(self.checkbutton_showinmenu, 2, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self.label_pulseaudio = gtk.Label(_('_PulseAudio:'))
self.label_pulseaudio.set_use_underline(True)
self.label_pulseaudio.set_alignment(1.0, 0.5)
self.checkbutton_pulseaudio = gtk.CheckButton(
_('_Disable PulseAudio whilst running'), True)
self.checkbutton_pulseaudio.set_tooltip_text(
_("Shut down PulseAudio when starting this program and start it again afterwards"
))
self.label_pulseaudio.set_mnemonic_widget(self.checkbutton_pulseaudio)
self.table.attach(self.label_pulseaudio, 0, 1, row, row + 1, gtk.FILL,
0)
self.table.attach(self.checkbutton_pulseaudio, 1, 3, row, row + 1,
gtk.EXPAND | gtk.FILL, 0)
row += 1
self._set_default_icon()
self.connect('delete-event', self._destroy)
self.connect('destroy-event', self._destroy)
self.set_deletable(False)
self.filechooser_command = FileChooserProgram()
self.filechooser_icon = FileChooserIcon()
self.button_command.connect('clicked', self._on_edit_program_command)
self.button_icon.connect('clicked', self._on_edit_program_icon)
self.filechooser_command.connect('response',
self._on_filechooser_command_response)
self.filechooser_icon.connect('response',
self._on_filechooser_icon_response)
def __init__(self, handle):
"""Set up the XoScope activity."""
activity.Activity.__init__(self, handle)
self._instance_directory = os.path.join(self.get_activity_root(),\
'instance')
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self._capturing = False
self._mode = 'live'
# 0, 2 or 5 second delay before capturing the image
self._delay = 0
# Zoom 1x, 2x, 4x
self._zoom = 1
# Exposure bracketing
self._bracketing = '0'
# Preview mode stuff
self._num_pics = 0
# Index of pic to be displayed in preview mode
self._pic_index = 0
# This holds the image titles and name information. Saved
# across activity instances
self._images = []
# Flag to store whether image preview element needs to resize
# the pixbuf
self._needs_resize = False
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Control'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self._controls_toolbar = activity_toolbar
advanced_toolbar = self.toolbox.get_activity_toolbar()
advanced_toolbar = gtk.Toolbar()
#self.toolbox.add_toolbar(_('Advanced controls'), advanced_toolbar)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_toolbar = self.activity_button.page
self._controls_toolbar = self.get_toolbar_box().toolbar
self._controls_toolbar.show()
advanced_toolbar = gtk.Toolbar()
#advanced_toolbar.show_all()
advanced_button = ToolbarButton()
advanced_button.props.page = advanced_toolbar
advanced_button.props.label = _('Advanced controls')
advanced_button.props.icon_name = 'advanced'
#advanced_button.show()
#toolbar_box.toolbar.insert(advanced_button, -1)
self._live_toolitem = gtk.ToolItem()
self._live_toolbar_container = gtk.HBox()
self._preview_toolitem = gtk.ToolItem()
self._preview_toolbar_container = gtk.HBox()
separator = gtk.SeparatorToolItem()
if not OLD_TOOLBAR:
separator.props.draw = True
else:
separator.props.draw = False
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._photo_button = ToolButton('photo')
self._photo_button.props.label = _('Capture photo')
self._photo_button.connect('clicked',
self.__capture_image_cb)
self._live_toolbar_container.add(self._photo_button)
self._photo_button.show()
self._delay_button = ToolButton('delay_%d' % self._delay)
self._delay_button.props.label = _('Capture delay')
self._delay_button.connect('clicked',
self.__change_capture_delay_cb)
self._live_toolbar_container.add(self._delay_button)
self._delay_button.show()
self._zoom_button = ToolButton('zoom_%d' % self._zoom)
self._zoom_button.props.label = _('Image Zoom')
self._zoom_button.connect('clicked',
self.__change_image_zoom_cb)
self._live_toolbar_container.add(self._zoom_button)
self._zoom_button.show()
#if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
# self._bracketing_button = ToolButton('bracketing_%s' % self._bracketing)
# self._bracketing_button.props.label = _('bracketing mode')
# self._bracketing_button.connect('clicked',
# self.__change_capture_bracketing_cb)
# self._live_toolbar_container.add(self._bracketing_button)
# self._bracketing_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._live_toolbar_container.add(separator)
separator.show()
# Camera control settings follow
if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
self._exposure_button = ToolButton('exposure')
self._exposure_button.set_palette(ScalePalette('Exposure',\
v4l2.V4L2_CID_EXPOSURE))
self._exposure_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._exposure_button)
self._exposure_button.show()
if self._check_available_control(v4l2.V4L2_CID_GAIN):
self._gain_button = ToolButton('gain')
self._gain_button.set_palette(ScalePalette('Gain',\
v4l2.V4L2_CID_GAIN,
self._check_available_control(v4l2.V4L2_CID_AUTOGAIN)))
self._gain_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._gain_button, -1)
self._gain_button.show()
if self._check_available_control(v4l2.V4L2_CID_BRIGHTNESS):
self._brightness_button = ToolButton('brightness')
self._brightness_button.set_palette(ScalePalette('Brightness',\
v4l2.V4L2_CID_BRIGHTNESS,
self._check_available_control(
v4l2.V4L2_CID_AUTOBRIGHTNESS)))
self._brightness_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._brightness_button)
self._brightness_button.show()
if self._check_available_control(v4l2.V4L2_CID_CONTRAST):
self._contrast_button = ToolButton('contrast')
self._contrast_button.set_palette(ScalePalette('Contrast',\
v4l2.V4L2_CID_CONTRAST))
self._contrast_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._contrast_button)
self._contrast_button.show()
if self._check_available_control(v4l2.V4L2_CID_SATURATION):
self._saturation_button = ToolButton('saturation')
self._saturation_button.set_palette(ScalePalette('Saturation',\
v4l2.V4L2_CID_SATURATION))
self._saturation_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._saturation_button, -1)
self._saturation_button.show()
if self._check_available_control(
v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE):
self._white_balance_button = ToolButton('white_balance')
self._white_balance_button.set_palette(ScalePalette('White'
' balance', v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE,
self._check_available_control(
v4l2.V4L2_CID_AUTO_WHITE_BALANCE)))
self._white_balance_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._white_balance_button, -1)
self._white_balance_button.show()
if self._check_available_control(v4l2.V4L2_CID_HUE):
self._color_tone_button = ToolButton('color_tone')
self._color_tone_button.set_palette(ScalePalette('Color'
' tone', v4l2.V4L2_CID_HUE,
self._check_available_control(
v4l2.V4L2_CID_HUE_AUTO)))
self._color_tone_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._color_tone_button, -1)
self._color_tone_button.show()
#if self._check_available_control(v4l2.V4L2_CID_NIGHT_MODE):
# self._night_mode_button = ToolButton('night_mode')
# self._night_mode_button.set_palette(ScalePalette('Night mode',\
# v4l2.V4L2_CID_NIGHT_MODE))
# self._night_mode_button.connect('clicked',
# self.__button_clicked_cb)
# self._live_toolbar_container.add(self._night_mode_button)
# self._night_mode_button.show()
self._previous_image = ToolButton('go-previous-paired')
self._previous_image.label = _('Previous image')
self._previous_image.connect('clicked',
self.__previous_image_clicked_cb)
self._preview_toolbar_container.add(self._previous_image)
self._previous_image.show()
self._next_image = ToolButton('go-next-paired')
self._next_image.label = _('Next image')
self._next_image.connect('clicked',
self.__next_image_clicked_cb)
self._preview_toolbar_container.add(self._next_image)
self._next_image.show()
self._image_name_entry = gtk.Entry()
self._image_name_entry.set_text('')
self._image_name_entry.set_size_request(400, -1)
self._image_name_entry.connect('activate',
self.__image_name_entry_activated_cb)
self._preview_toolbar_container.add(self._image_name_entry)
self._image_name_entry.show()
self._save_to_journal = ToolButton('save_to_journal')
self._save_to_journal.label = _('Save to journal')
self._save_to_journal.connect('clicked',
self.__save_to_journal_clicked_cb)
self._preview_toolbar_container.add(self._save_to_journal)
self._save_to_journal.show()
self._trash = ToolButton('trash')
self._trash.label = _('Delete')
self._trash.connect('clicked',
self.__trash_clicked_cb)
self._preview_toolbar_container.add(self._trash)
self._trash.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._mode_button = ToolButton('%s_mode' % self._mode)
self._mode_button.props.label = _('Mode')
self._mode_button.connect('clicked',
self.__switch_modes_cb)
self._controls_toolbar.insert(self._mode_button, -1)
self._mode_button.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
activity_stop = StopButton(self)
toolbar_box.toolbar.insert(activity_stop, -1)
activity_stop.show()
self._preview_toolitem.add(self._preview_toolbar_container)
self._live_toolitem.add(self._live_toolbar_container)
self._preview_toolbar_container.show()
self._live_toolbar_container.show()
if self._mode == 'preview':
self._controls_toolbar.insert(self._preview_toolitem, 1)
self._preview_toolitem.show()
else:
self._controls_toolbar.insert(self._live_toolitem, 1)
self._live_toolitem.show()
self._mode = 'live'
self._controls_toolbar.show()
activity_toolbar.show()
self._main_view = gtk.HBox()
self._movie_window = gtk.DrawingArea()
self._movie_window.connect('realize',
self.__movie_window_realize_cb)
self._movie_window.unset_flags(gtk.DOUBLE_BUFFERED)
self._movie_window.set_flags(gtk.APP_PAINTABLE)
self._main_view.add(self._movie_window)
self._preview_frame = gtk.AspectFrame(None, 0.5, 0.5, 1, True)
self._preview_window = gtk.Image()
self._preview_frame.add(self._preview_window)
self._preview_window.connect('size_allocate',
self.__preview_window_size_allocate_cb)
self.xoscope = gst.Pipeline('xoscope_pipe')
camsrc = gst.element_factory_make('v4l2src', 'camsrc')
caps = gst.Caps('video/x-raw-yuv')
filt = gst.element_factory_make('capsfilter', 'filter')
filt.set_property('caps', caps)
ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace',
'ffmpegcolorspace')
self._disp_sink = gst.element_factory_make('xvimagesink', 'disp_sink')
# http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
self._disp_sink.set_property('sync', False)
self.image_sink = gst.element_factory_make('fakesink',
'image_sink')
self.image_sink.set_property('silent', True)
tee = gst.element_factory_make('tee', 'tee')
queue = gst.element_factory_make('queue', 'dispqueue')
queue.set_property('leaky', True)
queue.set_property('max-size-buffers', 20)
queue2 = gst.element_factory_make('queue', 'imagequeue')
queue2.set_property('leaky', True)
queue2.set_property('max-size-buffers', 20)
self._zoom_element = gst.element_factory_make('videobox', 'zoombox')
jpeg = gst.element_factory_make('jpegenc', 'pbjpeg')
jpeg.set_property('quality', 100)
self.xoscope.add(camsrc, filt, ffmpegcolorspace,\
self._zoom_element, self._disp_sink, tee, queue, queue2,\
self.image_sink, jpeg)
gst.element_link_many(camsrc, filt, self._zoom_element,\
ffmpegcolorspace, tee, queue, self._disp_sink)
gst.element_link_many(tee, queue2, jpeg, self.image_sink)
bus = self.xoscope.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', self.__on_message_cb)
bus.connect('sync-message::element', self.__on_sync_message_cb)
self._main_view.show()
self._movie_window.show()
self.set_canvas(self._main_view)
# If we start playing without a delay, the live view window
# doesn't get attached to the main canvas properly (This is
# a problem on slow computers like xo1).
gobject.timeout_add(2000, self.__start_live_view)
def __init__(self, gui):#, upload_services):
""""""
gtk.Dialog.__init__(self)
self.gui = gui
self.set_transient_for(gui)
# self.set_icon_from_file(media.ICON_UPLOAD)
self.set_title(("Input Files"))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(600,500)
self.history_path = cons.DEFAULT_PATH
main_hbox = gtk.HBox()
self.vbox.pack_start(main_hbox)
self.file_icon = self.render_icon(gtk.STOCK_FILE, gtk.ICON_SIZE_BUTTON)
self.correct_icon = self.render_icon(gtk.STOCK_APPLY, gtk.ICON_SIZE_MENU)
self.incorrect_icon = self.render_icon(gtk.STOCK_CANCEL, gtk.ICON_SIZE_MENU)
#package treeview
frame = gtk.Frame()
main_hbox.pack_start(frame, True)
frame.set_border_width(5)
scroll = gtk.ScrolledWindow()
frame.add(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.package_treeview = gtk.TreeView(gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, bool))
scroll.add(self.package_treeview)
self.package_treeview.set_rules_hint(True)
self.package_treeview.set_headers_visible(False)
tree_icon = gtk.TreeViewColumn('Icon')
icon_cell = gtk.CellRendererPixbuf()
tree_icon.pack_start(icon_cell, True)
tree_icon.add_attribute(icon_cell, 'pixbuf', 0)
self.package_treeview.append_column(tree_icon)
tree_name = gtk.TreeViewColumn('Name')
name_cell = gtk.CellRendererText()
tree_name.pack_start(name_cell, True)
tree_name.add_attribute(name_cell, 'text', 1)
self.package_treeview.append_column(tree_name)
tree_size = gtk.TreeViewColumn('Size')
size_cell = gtk.CellRendererText()
tree_size.pack_start(size_cell, False)
tree_size.add_attribute(size_cell, 'text', 2)
self.package_treeview.append_column(tree_size)
service_vbox = gtk.VBox()
main_hbox.pack_start(service_vbox, False, False)
# services treeview
frame = gtk.Frame()
service_vbox.pack_start(frame)
frame.set_size_request(200, -1)
frame.set_border_width(5)
# frame.set_label_widget(gtk.image_new_from_file(media.ICON_PREFERENCES_SERVICES))
scroll = gtk.ScrolledWindow()
frame.add(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
services = gtk.ListStore(gtk.gdk.Pixbuf, str, int, str, bool, gobject.TYPE_PYOBJECT)
self.services_treeview = gtk.TreeView(services)
self.services_treeview.get_selection().connect("changed", self.select)
scroll.add(self.services_treeview)
self.services_treeview.set_rules_hint(True)
self.services_treeview.set_headers_visible(False)
tree_icon = gtk.TreeViewColumn('Icon')
icon_cell = gtk.CellRendererPixbuf()
tree_icon.pack_start(icon_cell, True)
tree_icon.add_attribute(icon_cell, 'pixbuf', 0)
self.services_treeview.append_column(tree_icon)
tree_name = gtk.TreeViewColumn('Name')
name_cell = gtk.CellRendererText()
tree_name.pack_start(name_cell, True)
tree_name.add_attribute(name_cell, 'text', 1)
self.services_treeview.append_column(tree_name)
tree_add = gtk.TreeViewColumn('Add')
add_cell = gtk.CellRendererToggle()
add_cell.connect("toggled", self.toggled)
tree_add.pack_start(add_cell, True)
tree_add.add_attribute(add_cell, 'active', 4)
self.services_treeview.append_column(tree_add)
#plugins
self.plugins_frame = gtk.Frame()
service_vbox.pack_start(self.plugins_frame, False, False)
self.plugins_frame.set_size_request(200, 100)
self.plugins_frame.set_border_width(5)
for service, size, unit, plugins in SERVICES:
vbox = gtk.VBox()
first = None
for plugin in plugins:
first = gtk.RadioButton(first, plugin)
vbox.pack_start(first, False, False, 1)
services.append([self.correct_icon, service, size, unit, False, vbox])
#choose path
hbox = gtk.HBox()
self.vbox.pack_start(hbox, False, False, 5)
path_button = gtk.Button(None, gtk.STOCK_OPEN)
path_button.set_size_request(90,40)
hbox.pack_start(path_button, False, False, 5)
path_button.connect("clicked", self.choose_files)
path_label = gtk.Label(("Choose files to upload."))
hbox.pack_start(path_label, False, False, 5)
aspect = gtk.AspectFrame()
hbox.pack_start(aspect, True, True)
aspect.set_shadow_type(gtk.SHADOW_NONE)
clear_button = gtk.Button(None, gtk.STOCK_CLEAR)
clear_button.set_size_request(190,40)
hbox.pack_start(clear_button, False, False, 5)
clear_button.connect("clicked", self.clear)
#action area
cancel_button = gtk.Button(None, gtk.STOCK_CANCEL)
add_button = gtk.Button(None, gtk.STOCK_ADD)
self.action_area.pack_start(cancel_button)
self.action_area.pack_start(add_button)
cancel_button.connect("clicked", self.close)
add_button.connect("clicked", self.add_files)
self.result = None
self.connect("response", self.close)
self.show_all()
self.set_focus(path_button)
self.run()
def __init__(self, parent, stream):
""""""
gtk.Dialog.__init__(self)
self.set_transient_for(parent)
self.set_title("%s - Log View" % cons.TUCAN_NAME)
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(700, 500)
self.set_icon(self.render_icon(gtk.STOCK_FILE, gtk.ICON_SIZE_MENU))
self.stream = stream
self.back_buffer = gtk.TextBuffer()
self.back_buffer.set_text(self.stream.read())
frame = gtk.Frame()
self.vbox.pack_start(frame)
frame.set_border_width(10)
hbox = gtk.HBox()
frame.add(hbox)
#auto scroll
scroll = gtk.ScrolledWindow()
hbox.pack_start(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.get_vadjustment().connect("changed", self.changed)
scroll.get_vadjustment().connect("value-changed", self.value_changed)
#textview
buffer = gtk.TextBuffer()
self.textview = gtk.TextView(buffer)
scroll.add(self.textview)
self.textview.set_wrap_mode(gtk.WRAP_NONE)
self.textview.set_editable(False)
self.textview.set_cursor_visible(False)
self.textview.modify_base(gtk.STATE_NORMAL,
gtk.gdk.color_parse("black"))
table = buffer.get_tag_table()
for name, color in COLORS.items():
tag = gtk.TextTag(name)
tag.set_property("foreground", color)
tag.set_property("left_margin", 10)
tag.set_property("right_margin", 10)
table.add(tag)
#combo
hbox = gtk.HBox()
self.vbox.pack_start(hbox, False, False, 10)
buttonbox = gtk.HButtonBox()
hbox.pack_start(buttonbox, False, False, 10)
label = gtk.Label("Minimum severity shown.")
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.combo = gtk.combo_box_new_text()
buttonbox.pack_start(self.combo)
self.combo.connect("changed", self.reload)
for s in SEVERITY:
self.combo.append_text(s)
self.combo.set_active(2)
#action area
button = gtk.Button("Report ")
self.action_area.pack_start(button)
pixbuf = gtk.gdk.pixbuf_new_from_file_at_size(media.ICON_SEND, 24, 24)
button.set_image(gtk.image_new_from_pixbuf(pixbuf))
button.connect("clicked", self.report)
button = gtk.Button(None, gtk.STOCK_CLOSE)
self.action_area.pack_start(button)
button.connect("clicked", self.close)
self.connect("response", self.close)
self.show_all()
gobject.timeout_add_seconds(1, self.update)
self.run()
def __init__(self, message):
""""""
gtk.Dialog.__init__(self)
self.set_icon(
self.render_icon(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DND))
self.set_title("%s - %s" % (cons.TUCAN_NAME, ("Recover Help")))
self.set_position(gtk.WIN_POS_CENTER)
self.set_modal(True)
self.set_resizable(False)
hbox = gtk.HBox()
self.vbox.pack_start(hbox, True, False, 5)
aspect = gtk.AspectFrame()
hbox.pack_start(aspect)
aspect.set_shadow_type(gtk.SHADOW_NONE)
image = gtk.image_new_from_stock(gtk.STOCK_DIALOG_ERROR,
gtk.ICON_SIZE_DIALOG)
hbox.pack_start(image)
label = gtk.Label("An unexpected error forced Tucan to exit.")
hbox.pack_start(label)
label.set_width_chars(35)
label.set_line_wrap(True)
self.expander = gtk.Expander("Show details")
self.vbox.pack_start(self.expander, True, True, 5)
frame = gtk.Frame()
self.expander.add(frame)
frame.set_border_width(10)
scroll = gtk.ScrolledWindow()
frame.add(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.buffer = gtk.TextBuffer()
self.buffer.set_text(message)
textview = gtk.TextView(self.buffer)
scroll.add(textview)
textview.set_wrap_mode(gtk.WRAP_WORD)
textview.set_editable(False)
textview.set_cursor_visible(False)
hbox = gtk.HButtonBox()
self.vbox.pack_start(hbox, True, True, 5)
hbox.set_layout(gtk.BUTTONBOX_SPREAD)
button = gtk.Button("Remove Configuration")
hbox.pack_start(button)
button.connect("clicked", self.remove_conf)
button = gtk.Button("Report Problem")
hbox.pack_start(button)
button.connect("clicked", self.report_problem)
#action area
button = gtk.Button(None, gtk.STOCK_QUIT)
self.action_area.pack_start(button)
button.connect("clicked", self.close)
button = gtk.Button("Restart ")
self.action_area.pack_start(button)
button.connect("clicked", self.restart)
button.set_image(
gtk.image_new_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON))
self.connect("response", self.close)
self.show_all()
self.set_focus(button)
self.set_urgency_hint(True)
def run(self):
self.maFenetre = gtk.Window()
self.maFenetre.set_title(config.get('non_glade_theme', 'title'))
self.maFenetre.connect("destroy", self.Quitter)
self.maFenetre.set_icon_from_file(
'/usr/share/pixmaps/handymenu_icon.png')
self.maFenetre.set_modal(True)
separateur = gtk.HSeparator()
separateur.set_size_request(150, 10)
separateur2 = gtk.HSeparator()
separateur2.set_size_request(150, 10)
separateur3 = gtk.HSeparator()
separateur3.set_size_request(150, 10)
fram1 = gtk.AspectFrame(label=config.get('non_glade_theme', 'title'),
xalign=0.5,
yalign=0.4,
ratio=1.0,
obey_child=True)
fram1.set_shadow_type(gtk.SHADOW_OUT)
boutonvBox = gtk.VBox()
checkOption1 = gtk.CheckButton(config.get('non_glade_theme', 'check1'))
if config.get('non_glade_theme', 'check1_active') == 'True':
checkOption1.set_active(True)
# checkOption2 = gtk.CheckButton(config.get('non_glade_theme', 'check2'))
# if config.get('non_glade_theme', 'check2_active') == 'True':
# checkOption2.set_active(True)
checkOption1.connect("clicked", self.on_redimensionnement)
# checkOption2.connect("clicked", self.position_ouverture)
boutonvBox.add(checkOption1)
# boutonvBox.add(checkOption2)
fram1.add(boutonvBox)
fram2 = gtk.Frame(config.get('non_glade_theme', 'fram2'))
fram2.set_shadow_type(gtk.SHADOW_OUT)
listevbox = gtk.VBox()
self.liste_banniere = gtk.combo_box_new_text()
self.liste_banniere.append_text(config.get('non_glade_theme', 'list1'))
self.liste_banniere.set_wrap_width(0)
self.liste_banniere.set_active(0)
self.liste_bannieres_dispo(self.liste_banniere)
self.liste_banniere.connect('changed', self.banniere_choix)
liste_icones = gtk.combo_box_new_text()
liste_icones.append_text(config.get('non_glade_theme', 'list2'))
liste_icones.set_active(0)
self.liste_icones_dispo(liste_icones)
liste_icones.connect('changed', self.icones_choix)
listevbox.add(self.liste_banniere)
listevbox.add(liste_icones)
fram2.add(listevbox)
boutonQuitter = gtk.ToggleButton(
label=config.get('non_glade_theme', 'quit'))
boutonQuitter.connect("clicked", self.Quitter)
mainvbox = gtk.VBox()
mainvbox.add(separateur)
mainvbox.add(fram1)
mainvbox.add(separateur2)
mainvbox.add(fram2)
mainvbox.add(separateur3)
mainvbox.add(boutonQuitter)
self.maFenetre.add(mainvbox)
self.maFenetre.show_all()
gtk.main()
def __init__(self, parent, default_path, packages):
""""""
gtk.Dialog.__init__(self)
self.set_icon_from_file(media.ICON_PACKAGE)
self.set_transient_for(parent)
self.set_title("%s - %s" % (cons.TUCAN_NAME, _("Advanced Packages")))
self.set_position(gtk.WIN_POS_CENTER)
self.set_size_request(600,400)
self.packages = packages
self.packages_info = []
self.history_path = default_path
#radio
frame = gtk.Frame()
self.vbox.pack_start(frame, False, False)
frame.set_border_width(10)
hbox = gtk.HBox()
frame.add(hbox)
multi = gtk.RadioButton(None, "Auto Package Mode")
multi.connect("toggled", self.change_mode, True)
hbox.pack_start(multi)
single = gtk.RadioButton(multi, "Single Package Mode")
single.connect("toggled", self.change_mode, False)
hbox.pack_start(single)
#treeview
frame = gtk.Frame()
self.vbox.pack_start(frame)
frame.set_border_width(10)
scroll = gtk.ScrolledWindow()
frame.add(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.multi_model = gtk.ListStore(gtk.gdk.Pixbuf, str, str, str, int)
self.single_model = gtk.ListStore(gtk.gdk.Pixbuf, str, str, str, int)
self.treeview = gtk.TreeView(self.multi_model)
self.treeview.get_selection().connect("changed", self.select)
scroll.add(self.treeview)
self.treeview.set_rules_hint(True)
#self.treeview.set_headers_visible(False)
tree_icon = gtk.TreeViewColumn('Icon')
icon_cell = gtk.CellRendererPixbuf()
tree_icon.pack_start(icon_cell, True)
tree_icon.add_attribute(icon_cell, 'pixbuf', 0)
self.treeview.append_column(tree_icon)
tree_path = gtk.TreeViewColumn('Path')
path_cell = gtk.CellRendererText()
tree_path.pack_start(path_cell, True)
tree_path.add_attribute(path_cell, 'text', 1)
self.treeview.append_column(tree_path)
self.treeview.connect("row-activated", self.choose)
tree_name = gtk.TreeViewColumn('Name')
name_cell = gtk.CellRendererText()
name_cell.set_property("editable", True)
name_cell.connect("edited", self.change, 2)
tree_name.pack_start(name_cell, True)
tree_name.add_attribute(name_cell, 'text', 2)
self.treeview.append_column(tree_name)
tree_pass = gtk.TreeViewColumn('Password')
pass_cell = gtk.CellRendererText()
pass_cell.set_property("editable", True)
pass_cell.connect("edited", self.change, 3)
tree_pass.pack_start(pass_cell, True)
tree_pass.add_attribute(pass_cell, 'text', 3)
self.treeview.append_column(tree_pass)
#fill treestore
package_icon = gtk.gdk.pixbuf_new_from_file_at_size(media.ICON_PACKAGE, 32, 32)
single_package_name = misc.name_package()
single_package_links = []
for package_name, package_links in self.packages:
single_package_links += package_links
self.multi_model.append((package_icon, default_path, package_name, None, len(package_links)))
self.multi_packages = self.packages
self.single_package = [(single_package_name, single_package_links)]
self.single_model.append((package_icon, default_path, single_package_name, None, len(single_package_links)))
#choose path
hbox = gtk.HBox()
self.vbox.pack_start(hbox, False, False, 5)
path_button = gtk.Button(None, gtk.STOCK_OPEN)
hbox.pack_start(path_button, False, False, 10)
path_button.set_size_request(90,40)
path_button.connect("clicked", self.choose_path)
path_label = gtk.Label(_("Choose new path for selected Package."))
hbox.pack_start(path_label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect, True, True)
#info
frame = gtk.Frame()
hbox.pack_start(frame)
frame.set_border_width(10)
self.info_name = gtk.Label()
self.info_name.set_markup("<b>%s: </b>" % ("Packages"))
frame.set_label_widget(self.info_name)
vbox = gtk.VBox()
frame.add(vbox)
self.info_label = gtk.Label(len(packages))
vbox.pack_start(self.info_label, False, False, 5)
#action area
cancel_button = gtk.Button(None, gtk.STOCK_CANCEL)
self.action_area.pack_start(cancel_button)
cancel_button.connect("clicked", self.close)
ok_button = gtk.Button(None, gtk.STOCK_OK)
self.action_area.pack_start(ok_button)
ok_button.connect("clicked", self.configure_packages)
self.connect("response", self.close)
self.show_all()
self.run()
def init_main(self):
""""""
vbox = gtk.VBox()
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_LANGUAGE))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
hbox = gtk.HBox()
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
vbox1.pack_start(hbox, False, False, 5)
label = gtk.Label(_("Choose language: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.language = gtk.combo_box_new_text()
for lang in [lang[0] for lang in LANGUAGES]:
self.language.append_text(lang)
self.language.set_active([lang[1] for lang in LANGUAGES
].index(self.config.get_languaje()))
hbox.pack_start(self.language, False, False, 10)
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_NETWORK))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
label = gtk.Label(_("Max simultaneous downloads: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.max_downloads = gtk.SpinButton(None, 1, 0)
self.max_downloads.set_range(1, 20)
self.max_downloads.set_increments(1, 0)
self.max_downloads.set_numeric(True)
self.max_downloads.set_value(self.config.get_max_downloads())
hbox.pack_start(self.max_downloads, False, False, 10)
vbox1.pack_start(hbox, False, False, 2)
hbox = gtk.HBox()
label = gtk.Label(_("Max download speed: "))
hbox.pack_start(label, False, False, 10)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(aspect)
self.max_download_speed = gtk.SpinButton(None, 4, 0)
self.max_download_speed.set_range(0, 5000)
self.max_download_speed.set_increments(4, 0)
self.max_download_speed.set_numeric(True)
self.max_download_speed.set_value(self.config.get_max_download_speed())
hbox.pack_start(self.max_download_speed, False, False, 10)
vbox1.pack_start(hbox, False, False, 2)
#hbox = gtk.HBox()
#label = gtk.Label(_("Max simultaneous uploads: "))
#hbox.pack_start(label, False, False, 10)
#aspect = gtk.AspectFrame()
#aspect.set_shadow_type(gtk.SHADOW_NONE)
#hbox.pack_start(aspect)
#self.max_uploads = gtk.SpinButton(None, 1, 0)
#self.max_uploads.set_range(1,10)
#self.max_uploads.set_increments(1,0)
#self.max_uploads.set_numeric(True)
#self.max_uploads.set_value(self.config.get_max_uploads())
#hbox.pack_start(self.max_uploads, False, False, 10)
#vbox1.pack_start(hbox, False, False, 2)
frame = gtk.Frame()
frame.set_label_widget(gtk.image_new_from_file(media.ICON_FOLDER))
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
vbox1 = gtk.VBox()
frame.add(vbox1)
hbox = gtk.HBox()
vbox1.pack_start(hbox, False, False, 5)
label = gtk.Label(_("Downloads Folder: "))
hbox.pack_start(label, False, False, 10)
path = self.config.get_downloads_folder()
self.downloads_folder = gtk.Label(path)
self.downloads_folder.set_width_chars(30)
self.downloads_folder.set_alignment(0, 0.5)
self.downloads_folder.set_ellipsize(pango.ELLIPSIZE_START)
hbox.pack_start(self.downloads_folder, False, False, 10)
bbox = gtk.HButtonBox()
bbox.set_layout(gtk.BUTTONBOX_END)
hbox.pack_start(bbox, True, True, 10)
button = gtk.Button(None, gtk.STOCK_OPEN)
button.connect("clicked", self.choose_path)
bbox.pack_start(button)
vbox.show_all()
return vbox
def _createUi(self):
""" Creates the Viewer GUI """
# drawing area
self.aframe = gtk.AspectFrame(xalign=0.5,
yalign=0.5,
ratio=4.0 / 3.0,
obey_child=False)
self.pack_start(self.aframe, expand=True)
self.drawingarea = ViewerWidget(self.action)
self.aframe.add(self.drawingarea)
# Slider
self.posadjust = gtk.Adjustment()
self.slider = gtk.HScale(self.posadjust)
self.slider.set_draw_value(False)
self.slider.connect("button-press-event", self._sliderButtonPressCb)
self.slider.connect("button-release-event",
self._sliderButtonReleaseCb)
self.slider.connect("scroll-event", self._sliderScrollCb)
self.pack_start(self.slider, expand=False)
self.moving_slider = False
self.slider.set_sensitive(False)
# Buttons/Controls
bbox = gtk.HBox()
boxalign = gtk.Alignment(xalign=0.5, yalign=0.5)
boxalign.add(bbox)
self.pack_start(boxalign, expand=False)
self.rewind_button = gtk.ToolButton(gtk.STOCK_MEDIA_REWIND)
self.rewind_button.connect("clicked", self._rewindCb)
self.rewind_button.set_sensitive(False)
bbox.pack_start(self.rewind_button, expand=False)
self.back_button = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS)
self.back_button.connect("clicked", self._backCb)
self.back_button.set_sensitive(False)
bbox.pack_start(self.back_button, expand=False)
self.playpause_button = PlayPauseButton()
self.playpause_button.connect("play", self._playButtonCb)
bbox.pack_start(self.playpause_button, expand=False)
self.playpause_button.set_sensitive(False)
self.next_button = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT)
self.next_button.connect("clicked", self._nextCb)
self.next_button.set_sensitive(False)
bbox.pack_start(self.next_button, expand=False)
self.forward_button = gtk.ToolButton(gtk.STOCK_MEDIA_FORWARD)
self.forward_button.connect("clicked", self._forwardCb)
self.forward_button.set_sensitive(False)
bbox.pack_start(self.forward_button, expand=False)
# current time
self.timelabel = gtk.Label()
self.timelabel.set_markup("<tt>00:00:00.000</tt>")
self.timelabel.set_alignment(1.0, 0.5)
bbox.pack_start(self.timelabel, expand=False, padding=10)
self._haveUI = True
screen = gdk.screen_get_default()
height = screen.get_height()
if height >= 800:
# show the controls and force the aspect frame to have at least the same
# width (+110, which is a magic number to minimize dead padding).
bbox.show_all()
width, height = bbox.size_request()
width += 110
height = int(width / self.aframe.props.ratio)
self.aframe.set_size_request(width, height)
def init_services(self):
""""""
vbox = gtk.VBox()
frame = gtk.Frame()
frame.set_size_request(-1, 300)
vbox.pack_start(frame)
frame.set_border_width(10)
scroll = gtk.ScrolledWindow()
frame.add(scroll)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
store = gtk.ListStore(gtk.gdk.Pixbuf, str, bool, gobject.TYPE_PYOBJECT)
self.treeview = gtk.TreeView(store)
scroll.add(self.treeview)
self.treeview.connect("row-activated", self.service_preferences)
self.treeview.set_rules_hint(True)
#self.treeview.set_headers_visible(False)
tree_icon = gtk.TreeViewColumn('Icon')
icon_cell = gtk.CellRendererPixbuf()
icon_cell.set_property("width", 50)
tree_icon.pack_start(icon_cell, False)
tree_icon.add_attribute(icon_cell, 'pixbuf', 0)
self.treeview.append_column(tree_icon)
tree_name = gtk.TreeViewColumn('Name')
name_cell = gtk.CellRendererText()
name_cell.set_property("width", 300)
name_cell.set_property("xalign", 0.1)
tree_name.pack_start(name_cell, True)
tree_name.add_attribute(name_cell, 'text', 1)
self.treeview.append_column(tree_name)
tree_enable = gtk.TreeViewColumn('Enabled')
enable_cell = gtk.CellRendererToggle()
enable_cell.connect("toggled", self.toggled)
tree_enable.pack_start(enable_cell, True)
tree_enable.add_attribute(enable_cell, 'active', 2)
self.treeview.append_column(tree_enable)
#fill store
for path, icon_path, name, enabled, service_config in self.config.get_services(
):
self.add_service(path, icon_path, name, enabled, service_config)
frame = gtk.Frame()
frame.set_border_width(10)
frame.set_shadow_type(gtk.SHADOW_NONE)
vbox.pack_start(frame, False, False)
bbox = gtk.HButtonBox()
bbox.set_layout(gtk.BUTTONBOX_EDGE)
frame.add(bbox)
button = gtk.Button(None, gtk.STOCK_FIND)
button.connect("clicked", self.update_manager)
bbox.pack_start(button)
button = gtk.Button(None, gtk.STOCK_INFO)
button.connect("clicked", self.service_info)
bbox.pack_start(button)
aspect = gtk.AspectFrame()
aspect.set_shadow_type(gtk.SHADOW_NONE)
bbox.pack_start(aspect)
self.toggle_all_button = gtk.Button("Enable All")
self.toggle_all_button.connect("clicked", self.toggled_all)
bbox.pack_start(self.toggle_all_button)
self.check_toggled_all()
hbox = gtk.HBox()
vbox.pack_start(hbox, False, False, 5)
label = gtk.Label()
hbox.pack_start(label, False, False, 10)
label.set_markup("<i>* " +
_("Restart Tucan to apply service changes.") + "</i>")
return vbox
def get_page_widget(self):
frame = gtk.AspectFrame(obey_child=True)
frame.set_shadow_type(gtk.SHADOW_NONE)
frame.add(self.__table)
return frame
def __init__(self, mapping=None):
"""
Optionally takes mapping- see get_mapping for formatting
Other options include the width and height, but you probably shouldn't touch those for now...
"""
self.limitedUpEntry = Entries.UnitEntry("KBps")
self.limitedDownEntry = Entries.UnitEntry("KBps")
if not mapping:
self.downloadLimit = 100
self.uploadLimit = 100
self.mapping = [[], [], [], [], [], [], []]
for i in range(7):
for j in range(24):
self.mapping[i].append(0)
else:
self.set_mapping(mapping)
self.initialized = False #we need to initialize the gui mapping of the schedule?
self.layout = None
self.pixmap = None
self.text = None
self.previousTime = time.time()
self.previousBox = []
#warning, these proportions need to be exact- xBlock and yBlock shouldn't have any rounding errors apart from the width wtf?!?
self.width = 391
self.height = 130
self.textOffset = 30
self.legendOffset = 25
self.xBlock = int((self.width-self.textOffset)/24) #quantized x unit
self.yBlock = int((self.height-self.legendOffset)/7) #quantized y unit
self.drawing_area = gtk.DrawingArea()
#connections
self.drawing_area.set_size_request(self.width, self.height) #24/7 + 30 : 1
self.drawing_area.connect("expose_event", self.expose_event)
self.drawing_area.connect("motion_notify_event", self.motion_notify_event)
self.drawing_area.connect("button_press_event", self.button_press_event)
self.drawing_area.connect("leave_notify_event", self.mouse_left)
self.drawing_area.set_events(gtk.gdk.EXPOSURE_MASK
| gtk.gdk.LEAVE_NOTIFY_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
self.limitedUpEntry.set_value(self.uploadLimit)
self.limitedDownEntry.set_value(self.downloadLimit)
vbox = gtk.VBox(False, 0)
frame = gtk.AspectFrame('Scheduler', ratio=self.width/self.height, obey_child=True)
self.label = gtk.Label("")
hbox = gtk.HBox(False, 4)
label = gtk.Label("Limited Upload (0=unlimited)")
label.show()
vbox.pack_start(label, False, True, 2)
entryHBox = gtk.HBox()
entryHBox.pack_start(self.limitedUpEntry.get_gtk_element(), True, True, 0)
entryLabel = gtk.Label("")
entryLabel.set_markup('<span size="large" weight="bold">KBps</span>')
entryHBox.pack_end(entryLabel, False, False, 0)
entryHBox.show_all()
vbox.pack_start(entryHBox, False, True, 0)
sep = gtk.HSeparator()
sep.show()
label = gtk.Label("Limited Download (0=unlimited)")
label.show()
vbox.pack_start(sep, False, True, 6)
vbox.pack_start(label, False, True, 0)
entryHBox = gtk.HBox()
entryHBox.pack_start(self.limitedDownEntry.get_gtk_element(), True, True, 0)
entryLabel = gtk.Label("")
entryLabel.set_markup('<span size="large" weight="bold">KBps</span>')
entryHBox.pack_end(entryLabel, False, False, 0)
entryHBox.show_all()
vbox.pack_start(entryHBox, False, True, 0)
sep = gtk.HSeparator()
sep.show()
vbox.pack_start(sep, False, True, 6)
vbox.pack_start(self.label, False, True, 0)
hbox.pack_start(self.drawing_area, False, False, 0)
hbox.pack_start(vbox, False, False, 0)
frame.add(hbox)
self.drawing_area.show()
self.limitedDownEntry.get_gtk_element().show()
self.limitedUpEntry.get_gtk_element().show()
self.label.show()
vbox.show()
hbox.show()
frame.show()
self.container = frame #use the hbox above if you want a handle on the child
