def __init__(self, config, parent=None):
self.cnt = 1
self.conf = config
self.lastsel = ""
self.oldfind = ""
self.full = False
self.stopspeak = True
self.stopload = False
self.olditer = None
self.move = None
self.mark = None
self.deftitle = "ePub Viewer: "
self.speech_pid = None
self.iterlist = []
self.iterlist2 = []
self.stags = []
self.xtags = []
gtk.Window.__init__(self)
self.connect("unmap", self.OnExit)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', self.destroyme)
try:
self.set_icon_from_file("epub.png")
except:
try:
self.set_icon_from_file("/usr/share/pyepub/epub.png")
except:
print "Cannot load app icon."
www = gtk.gdk.screen_width()
hhh = gtk.gdk.screen_height()
self.set_default_size(3 * www / 4, 3 * hhh / 4)
self.set_position(gtk.WIN_POS_CENTER)
self.set_title(self.deftitle)
hpaned = gtk.HPaned()
hpaned.set_border_width(2)
vpaned = gtk.VPaned()
vpaned.set_border_width(2)
self.add(hpaned)
view1 = gtk.TextView()
view1.set_border_width(0)
view1.set_left_margin(8)
view1.set_right_margin(8)
view1.set_editable(False)
view1.connect("key-press-event", self.key_press_event)
view1.connect("key-release-event", self.key_rel_event)
view1.connect("event-after", self.event_after)
view1.connect("expose-event", self.expose_event)
view1.connect("motion-notify-event", self.motion_notify_event)
view1.connect("visibility-notify-event", self.visibility_notify_event)
self.view = view1
self.buffer_1 = view1.get_buffer()
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(view1)
view2 = gtk.TextView()
#view2.set_border_width(8)
view2.set_editable(False)
view2.set_wrap_mode(gtk.WRAP_WORD)
view2.unset_flags(gtk.CAN_FOCUS)
self.buffer_2 = view2.get_buffer()
sw2 = gtk.ScrolledWindow()
sw2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw2.add(view2)
view2.connect("key-press-event", self.key_press_event2)
view2.connect("event-after", self.event_after2)
view2.connect("motion-notify-event", self.motion_notify_event2)
view2.connect("visibility-notify-event", self.visibility_notify_event2)
vbox = gtk.VBox()
vbox.set_spacing(5)
vbox.add(sw)
lab1 = gtk.Label("Idle")
lab1.set_justify(gtk.JUSTIFY_RIGHT)
lab2 = gtk.Label(" ")
lab3 = gtk.Label(" ")
lab4 = gtk.Label(" ")
lab5 = gtk.Label(" ")
#butt1 = gtk.Button(" Show TOC File ");
butt2 = gtk.Button(" Pre_v ")
butt2.connect("clicked", self.prev)
butt3 = gtk.Button(" N_ext ")
butt3.connect("clicked", self.next)
butt2a = gtk.Button(" PgUp ")
butt3a = gtk.Button(" PgDn ")
self.butt4 = gtk.Button(" _Read ")
self.butt4.connect("clicked", self.read_tts)
butt5 = gtk.Button(" _Home ")
butt5.connect("clicked", self.home)
butt5a = gtk.Button(" En_d ")
butt5a.connect("clicked", self.end)
butt6 = gtk.Button(" E_xit ")
butt6.connect("clicked", self.exit)
butt7 = gtk.Button(" _Find ")
butt7.connect("clicked", self.find)
hbox = gtk.HBox()
#hbox.pack_start(butt1, False)
hbox.pack_start(butt2, False)
hbox.pack_start(butt3, False)
hbox.pack_start(butt2a, False)
hbox.pack_start(butt3a, False)
hbox.pack_start(butt5, False)
hbox.pack_start(butt5a, False)
hbox.pack_start(butt7, False)
hbox.pack_start(lab3, False)
hbox.pack_start(self.butt4, False)
hbox.pack_start(lab4, False)
hbox.pack_start(butt6, False)
hbox.pack_start(lab1)
hbox.pack_start(lab2, False)
self.hbox = hbox
vbox.pack_end(hbox, False)
self.prog = lab1
vpaned.add(sw2)
vpaned.add2(vbox)
hpaned.add2(vpaned)
treeview = self.create_tree()
treeview.connect("row-activated", self.tree_sel)
treeview.connect("cursor-changed", self.tree_sel_row)
treeview.connect("key-press-event", self.key_press_event3)
self.treeview = treeview
sw3 = gtk.ScrolledWindow()
sw3.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw3.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw3.add(treeview)
frame2 = gtk.Frame()
frame2.add(sw3)
hpaned.add(frame2)
self.hpaned = hpaned
hpaned.set_position(200)
vpaned.set_position(1)
self.iter = self.buffer_1.get_iter_at_offset(0)
self.iter2 = self.buffer_2.get_iter_at_offset(0)
self.set_focus(view1)
self.show_all()
if self.conf.fullscreen:
#self.set_default_size(www, hhh)
self.window.fullscreen()
self.full = True
self.hpaned.set_position(0)
def build_gui(self, container):
vpaned = gtk.VPaned()
width, height = 200, 200
# Uncomment to debug; passing parent logger generates too
# much noise in the main logger
#zi = FitsImageCanvasGtk.FitsImageCanvas(logger=self.logger)
zi = FitsImageCanvasGtk.FitsImageCanvas(logger=None)
zi.enable_autozoom('off')
zi.enable_autocuts('off')
zi.enable_zoom(False)
#zi.set_scale_limits(0.001, 1000.0)
zi.zoom_to(self.default_zoom, redraw=False)
zi.add_callback('zoom-set', self.zoomset)
#zi.add_callback('motion', self.showxy)
zi.set_bg(0.4, 0.4, 0.4)
zi.show_pan_mark(True, redraw=False)
self.zoomimage = zi
iw = zi.get_widget()
iw.set_size_request(width, height)
vpaned.pack1(iw, resize=True, shrink=True)
vbox = gtk.VBox()
vbox.pack_start(gtk.Label("Zoom Radius:"),
padding=2,
fill=True,
expand=False)
adj = gtk.Adjustment(lower=1, upper=100)
adj.set_value(self.zoom_radius)
scale = GtkHelp.HScale(adj)
scale.set_size_request(200, -1)
scale.set_digits(0)
scale.set_draw_value(True)
scale.set_value_pos(gtk.POS_BOTTOM)
#scale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self.w_radius = scale
scale.connect('value-changed', self.set_radius_cb)
vbox.pack_start(scale, padding=0, fill=True, expand=False)
vbox.pack_start(gtk.Label("Zoom Amount:"),
padding=2,
fill=True,
expand=False)
adj = gtk.Adjustment(lower=-20, upper=30)
adj.set_value(self.zoom_amount)
scale = GtkHelp.HScale(adj)
scale.set_size_request(200, -1)
scale.set_digits(0)
scale.set_draw_value(True)
scale.set_value_pos(gtk.POS_BOTTOM)
#scale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self.w_amount = scale
scale.connect('value-changed', self.set_amount_cb)
vbox.pack_start(scale, padding=0, fill=True, expand=False)
captions = (
('Zoom', 'label'),
("Relative Zoom", 'checkbutton'),
("Lag Time", 'spinbutton'),
('Defaults', 'button'),
)
w, b = GtkHelp.build_info(captions)
b.zoom.set_text(self.fv.scale2text(zi.get_scale()))
self.wzoom = b
b.relative_zoom.set_active(not self.t_abszoom)
b.relative_zoom.sconnect("toggled", self.set_absrel_cb)
b.defaults.connect("clicked", lambda w: self.set_defaults())
adj = b.lag_time.get_adjustment()
adj.configure(0, 0, 20, 1, 1, 1)
adj.set_value(self.lagtime)
b.lag_time.set_digits(0)
b.lag_time.set_wrap(True)
b.lag_time.connect('value-changed', self.setlag_cb)
vbox.pack_start(w, padding=4, fill=True, expand=False)
sw = gtk.ScrolledWindow()
sw.set_border_width(2)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add_with_viewport(vbox)
vpaned.pack2(sw, resize=True, shrink=True)
vpaned.show_all()
vpaned.set_position(height)
container.pack_start(vpaned, padding=0, fill=True, expand=True)
def __init__(self,
worker,
toolbar,
viewer_window,
click_callback=None,
key_press_callback=None):
gtk.VBox.__init__(self)
self.toolbar = toolbar
self.viewer_window = viewer_window
self.il = ImageLoader(self)
self.imarea = overlay_widgets.DrawableOverlayHover()
self.imarea.add_with_bg(toolbar, 0, 1, 0, None)
self.imarea.connect("draw", self.draw)
self.imarea.set_property("can-focus", True)
self.worker = worker
self.plugin_controller = None
self.mouse_hover = False
self.mouse_hover_pos = None
self.command_highlight_ind = -1
self.command_highlight_bd = False
self.zoom_level = 'fit'
self.zoom_position = (
0, 0) #either center or a tuple of left/top coordinates
self.zoom_position_request = None
self.freeze_image_refresh = False
self.change_block = False
self.vscrolladj = gtk.Adjustment()
self.hscrolladj = gtk.Adjustment()
self.vscroll = gtk.VScrollbar(self.vscrolladj)
self.hscroll = gtk.HScrollbar(self.hscrolladj)
self.vscrolladj.connect("value-changed", self.scroll_signal, True)
self.hscrolladj.connect("value-changed", self.scroll_signal, False)
self.imarea.add_events(gtk.gdk.SCROLL_MASK)
self.imarea.connect("scroll-event", self.scroll_signal_pane)
self.scroll_inc = 15
self.imarea.show_all()
self.image_box = gtk.VBox()
self.image_box.pack_start(self.imarea)
self.image_box.show()
#Add scrollbars
self.image_table = gtk.Table(
rows=2, columns=2,
homogeneous=False) ##plugins can add widgets to the box
self.image_table.attach(self.image_box,
0,
1,
0,
1,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=gtk.EXPAND | gtk.FILL,
xpadding=0,
ypadding=0)
self.image_table.attach(self.vscroll,
1,
2,
0,
1,
xoptions=0,
yoptions=gtk.EXPAND | gtk.FILL,
xpadding=0,
ypadding=0)
self.image_table.attach(self.hscroll,
0,
1,
1,
2,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=0,
xpadding=0,
ypadding=0)
self.image_table.show()
self.vpane = gtk.VPaned()
self.vpane.add1(self.image_table) ##plugins can add widgets with add2
self.pack_start(self.vpane)
self.vpane.show()
#self.imarea.add_events(gtk.gdk.EXPOSURE_MASK)
self.conf_id = self.imarea.connect("size-allocate", self.size_signal)
#self.imarea.connect("realize",self.realize_signal)
self.connect("destroy", self._destroy)
#self.imarea.add_events(gtk.gdk.SCROLL_MASK)
#self.imarea.add_events(gtk.gdk.BUTTON_MOTION_MASK)
self.imarea.add_events(gtk.gdk.BUTTON_PRESS_MASK)
self.imarea.add_events(gtk.gdk.BUTTON_RELEASE_MASK)
self.imarea.connect("button-press-event", self.button_press)
self.imarea.connect("button-release-event", self.button_press)
self.imarea.add_events(gtk.gdk.KEY_PRESS_MASK)
self.imarea.add_events(gtk.gdk.KEY_RELEASE_MASK)
self.imarea.add_events(gtk.gdk.POINTER_MOTION_MASK)
self.imarea.connect("motion-notify-event", self.mouse_motion_signal)
#self.imarea.add_events(gtk.gdk.ENTER_NOTIFY_MASK)
#self.imarea.connect("enter-notify-event",self.mouse_enter_signal)
self.imarea.add_events(gtk.gdk.LEAVE_NOTIFY_MASK)
self.imarea.connect("leave-notify-event", self.mouse_leave_signal)
self.target_list = [
('image-filename', gtk.TARGET_SAME_APP, self.TARGET_TYPE_IMAGE)
] #("XdndDirectSave0", 0, self.TARGET_TYPE_XDS),
self.target_list = gtk.target_list_add_uri_targets(
self.target_list, self.TARGET_TYPE_URI_LIST)
#target_list=gtk.target_list_add_text_targets(target_list,self.TARGET_TYPE_URI_LIST)
self.imarea.drag_source_set(
gtk.gdk.BUTTON1_MASK, self.target_list,
gtk.gdk.ACTION_COPY) #| gtk.gdk.ACTION_MOVE)
## target_list=[('tag-tree-row', gtk.TARGET_SAME_APP, 0)]
## target_list=gtk.target_list_add_uri_targets(target_list,1)
## self.imarea.drag_dest_set(gtk.DEST_DEFAULT_ALL,
## target_list,
## gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_COPY)
self.imarea.connect("drag-data-get", self.drag_get_signal)
## self.imarea.connect("drag-begin", self.drag_begin_signal) ##not needed when using drag_source_set
## self.imarea.connect("drag-end",self.drag_end_signal)
## self.imarea.connect("drag-data-received",self.drag_receive_signal)
self.imarea.connect("drag-motion", self.drag_motion_signal)
self.imarea.connect("drag-leave", self.drag_leave_signal)
#self.imarea.drag_source_set_icon_stock('browser-drag-icon')
if click_callback:
self.imarea.connect_after("button-press-event", click_callback)
if key_press_callback:
self.imarea.connect("key-press-event", key_press_callback)
self.imarea.connect("key-release-event", key_press_callback)
pluginmanager.mgr.register_callback(
't_collection_item_metadata_changed', self.meta_changed)
# self.imarea.set_size_request(128,96)
self.item = None
self.browser = None
self.last_sizing = None
self.freeze_image_refresh = False
self.freeze_image_resize = False
self.fullscreen = False
class AppMainWindow():
def __init__(self, buff, fname=None, parent=None):
register_stock_icons()
# Create the toplevel window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
try:
self.set_screen(parent.get_screen())
except AttributeError:
window.connect('destroy', lambda *w: gtk.main_quit())
if fname:
strx = "PyEdit: ''%s''" % fname
else:
strx = "PyEdit"
window.set_title(strx)
window.set_position(gtk.WIN_POS_CENTER)
#if full:
# self.set_default_size(www, hhh)
#else:
www = gtk.gdk.screen_width()
hhh = gtk.gdk.screen_height()
#window.set_default_size(3*www/4, 2*hhh/4)
merge = gtk.UIManager()
window.set_data("ui-manager", merge)
merge.insert_action_group(self.__create_action_group(), 0)
window.add_accel_group(merge.get_accel_group())
try:
mergeid = merge.add_ui_from_string(ui_info)
except gobject.GError, msg:
print "Building menus failed: %s" % msg
bar = merge.get_widget("/MenuBar")
bar.show()
table = gtk.Table(2, 4, False)
window.add(table)
table.attach(
bar,
# X direction # # Y direction
0,
1,
0,
1,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
bar = merge.get_widget("/ToolBar")
bar.set_tooltips(True)
bar.show()
table.attach(
bar,
# X direction # # Y direction
0,
1,
1,
2,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
hpaned = gtk.HPaned()
hpaned.set_border_width(5)
vpaned = gtk.VPaned()
vpaned.set_border_width(5)
self.treestore = gtk.TreeStore(str)
#tv = peddoc.pedDoc("Hello\nBuffer\Here")
#tv = gtk.TreeView()
# we'll add some data now - 4 rows with 3 child rows each
for parent in range(4):
piter = self.treestore.append(None, ['parent %i' % parent])
for child in range(3):
self.treestore.append(
piter, ['child %i of parent %i' % (child, parent)])
# create the TreeView using treestore
self.frame2 = gtk.Frame()
self.tv = gtk.TreeView(self.treestore)
# create a CellRendererText to render the data
self.cell = gtk.CellRendererText()
# create the TreeViewColumn to display the data
self.tvcolumn = gtk.TreeViewColumn('Functions')
# add the cell to the tvcolumn and allow it to expand
self.tvcolumn.pack_start(self.cell, True)
# set the cell "text" attribute to column 0 - retrieve text
# from that column in treestore
self.tvcolumn.add_attribute(self.cell, 'text', 0)
# add tvcolumn to treeview
self.tv.append_column(self.tvcolumn)
self.frame2.add(self.tv)
hpaned.add(self.frame2)
hpaned.pack2(vpaned)
hpaned.set_position(1)
# Create document
area = peddoc.pedDoc(buff, None, window)
frame = gtk.Frame()
frame.add(area)
vpaned.add(frame)
vpaned.set_position(1)
hadj = gtk.Adjustment(0, 0, 100)
vadj = gtk.Adjustment(0, 0, 100)
hadj.connect("value-changed", area.hscroll)
vadj.connect("value-changed", area.vscroll)
# Create main document window
area2 = peddoc.pedDoc(buff, None, window)
area2.set_scroll_adjustments(hadj, vadj)
frame = gtk.Frame()
frame.add(area2)
vscroll = gtk.VScrollbar(vadj)
hbox = gtk.HBox()
hbox.pack_start(frame, True, True)
hbox.pack_end(vscroll, False, False)
hscroll = gtk.HScrollbar(hadj)
vbox = gtk.VBox()
vbox.pack_start(hbox, True, True)
vbox.pack_end(hscroll, False, False)
vpaned.pack2(vbox)
table.attach(
hpaned,
# X direction Y direction
0,
1,
2,
3,
gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL,
0,
0)
# Create statusbar
self.statusbar = gtk.Statusbar()
table.attach(
self.statusbar,
# X direction Y direction
0,
1,
3,
4,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
window.connect("window_state_event", self.update_resize_grip)
window.connect("destroy", OnExit)
#window.set_focus(area)
window.show_all()
#window.activate_focus()
winx = self
window.set_focus(area)
# Set the signal handler for 1s tick
#signal.signal(signal.SIGALRM, handler)
#signal.alarm(1)
self.update_statusbar("Initial")
def _init_gui_elements(self):
self._dialog = gimpui.Dialog(title=pg.config.PLUGIN_TITLE,
role=pg.config.PLUGIN_NAME)
self._dialog.set_transient()
self._dialog.set_default_size(*self._DIALOG_SIZE)
self._dialog.set_border_width(self._DIALOG_BORDER_WIDTH)
self._dialog.set_default_response(gtk.RESPONSE_CANCEL)
self._folder_chooser_label = gtk.Label()
self._folder_chooser_label.set_markup("<b>" + _("Save in folder:") +
"</b>")
self._folder_chooser_label.set_alignment(0.0, 0.5)
self._folder_chooser = gtk.FileChooserWidget(
action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
self._vbox_folder_chooser = gtk.VBox(homogeneous=False)
self._vbox_folder_chooser.set_spacing(self._DIALOG_VBOX_SPACING)
self._vbox_folder_chooser.pack_start(
self._folder_chooser_label,
expand=False,
fill=False,
padding=self._SAVE_IN_FOLDER_LABEL_PADDING)
self._vbox_folder_chooser.pack_start(self._folder_chooser)
self._init_gui_previews()
self._preview_label = gtk.Label()
self._preview_label.set_markup("<b>" + _("Preview") + "</b>")
self._preview_label.set_alignment(0.0, 0.5)
self._hbox_preview_label = gtk.HBox()
self._hbox_preview_label.set_border_width(
self._PREVIEW_LABEL_BORDER_WIDTH)
self._hbox_preview_label.pack_start(self._preview_label)
self._vpaned_previews = gtk.VPaned()
self._vpaned_previews.pack1(self._name_preview,
resize=True,
shrink=True)
self._vpaned_previews.pack2(self._image_preview,
resize=True,
shrink=True)
self._vbox_previews = gtk.VBox()
self._vbox_previews.pack_start(self._hbox_preview_label,
expand=False,
fill=False)
self._vbox_previews.pack_start(self._vpaned_previews,
expand=True,
fill=True)
self._frame_previews = gtk.Frame()
self._frame_previews.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self._frame_previews.add(self._vbox_previews)
self._file_extension_label = gtk.Label()
self._file_extension_label.set_markup("<b>{}:</b>".format(
gobject.markup_escape_text(
self._settings["main/file_extension"].display_name)))
self._file_extension_label.set_alignment(0.0, 0.5)
self._file_extension_entry = pg.gui.FileExtensionEntry(
minimum_width_chars=self._FILE_EXTENSION_ENTRY_MIN_WIDTH_CHARS,
maximum_width_chars=self._FILE_EXTENSION_ENTRY_MAX_WIDTH_CHARS)
self._file_extension_entry.set_activates_default(True)
self._save_as_label = gtk.Label()
self._save_as_label.set_markup("<b>{}:</b>".format(
gobject.markup_escape_text(_("Save as"))))
self._save_as_label.set_alignment(0.0, 0.5)
self._dot_label = gtk.Label(".")
self._dot_label.set_alignment(0.0, 1.0)
self._filename_pattern_entry = pg.gui.FilenamePatternEntry(
renamer.get_field_descriptions(renamer.FIELDS),
minimum_width_chars=self._FILENAME_PATTERN_ENTRY_MIN_WIDTH_CHARS,
maximum_width_chars=self._FILENAME_PATTERN_ENTRY_MAX_WIDTH_CHARS,
default_item=self._settings["main/layer_filename_pattern"].
default_value)
self._filename_pattern_entry.set_activates_default(True)
self._label_message = message_label_.MessageLabel()
self._hbox_export_name_labels = gtk.HBox(homogeneous=False)
self._hbox_export_name_labels.pack_start(self._file_extension_label,
expand=False,
fill=False)
self._hbox_export_name_labels.pack_start(self._save_as_label,
expand=False,
fill=False)
self._hbox_export_name_entries = gtk.HBox(homogeneous=False)
self._hbox_export_name_entries.set_spacing(
self._HBOX_EXPORT_NAME_ENTRIES_SPACING)
self._hbox_export_name_entries.pack_start(self._filename_pattern_entry,
expand=False,
fill=False)
self._hbox_export_name_entries.pack_start(self._dot_label,
expand=False,
fill=False)
self._hbox_export_name_entries.pack_start(self._file_extension_entry,
expand=False,
fill=False)
self._hbox_export_name = gtk.HBox(homogeneous=False)
self._hbox_export_name.set_spacing(
self._HBOX_EXPORT_LABELS_NAME_SPACING)
self._hbox_export_name.pack_start(self._hbox_export_name_labels,
expand=False,
fill=False)
self._hbox_export_name.pack_start(self._hbox_export_name_entries,
expand=False,
fill=False)
self._hbox_export_name_and_message = gtk.HBox(homogeneous=False)
self._hbox_export_name_and_message.set_spacing(
self._HBOX_EXPORT_NAME_AND_MESSAGE_HORIZONTAL_SPACING)
self._hbox_export_name_and_message.set_border_width(
self._HBOX_EXPORT_NAME_AND_MESSAGE_BORDER_WIDTH)
self._hbox_export_name_and_message.pack_start(self._hbox_export_name,
expand=False,
fill=False)
self._hbox_export_name_and_message.pack_start(self._label_message,
expand=True,
fill=True)
self._box_procedures = operations_.OperationBox(
self._settings["main/procedures"],
builtin_procedures.BUILTIN_PROCEDURES,
_("Add P_rocedure..."),
_("Edit Procedure"),
add_custom_operation_text=_("Add Custom Procedure..."))
self._box_constraints = operations_.OperationBox(
self._settings["main/constraints"],
builtin_constraints.BUILTIN_CONSTRAINTS,
_("Add C_onstraint..."),
_("Edit Constraint"),
allow_custom_operations=False)
self._hbox_operations = gtk.HBox(homogeneous=True)
self._hbox_operations.set_spacing(
self._MORE_SETTINGS_HORIZONTAL_SPACING)
self._hbox_operations.set_border_width(
self._MORE_SETTINGS_BORDER_WIDTH)
self._hbox_operations.pack_start(self._box_procedures,
expand=True,
fill=True)
self._hbox_operations.pack_start(self._box_constraints,
expand=True,
fill=True)
self._vbox_chooser_and_settings = gtk.VBox()
self._vbox_chooser_and_settings.set_spacing(self._DIALOG_VBOX_SPACING)
self._vbox_chooser_and_settings.pack_start(self._vbox_folder_chooser,
expand=True,
fill=True)
self._vbox_chooser_and_settings.pack_start(
self._hbox_export_name_and_message, expand=False, fill=False)
self._vpaned_chooser_and_operations = gtk.VPaned()
self._vpaned_chooser_and_operations.pack1(
self._vbox_chooser_and_settings, resize=True, shrink=False)
self._vpaned_chooser_and_operations.pack2(self._hbox_operations,
resize=False,
shrink=True)
self._hpaned_settings_and_previews = gtk.HPaned()
self._hpaned_settings_and_previews.pack1(
self._vpaned_chooser_and_operations, resize=True, shrink=False)
self._hpaned_settings_and_previews.pack2(self._frame_previews,
resize=True,
shrink=True)
self._button_export = self._dialog.add_button(_("_Export"),
gtk.RESPONSE_OK)
self._button_export.set_flags(gtk.CAN_DEFAULT)
self._button_export.hide()
self._button_cancel = self._dialog.add_button(_("_Cancel"),
gtk.RESPONSE_CANCEL)
self._button_cancel.hide()
self._dialog.set_alternative_button_order(
[gtk.RESPONSE_OK, gtk.RESPONSE_CANCEL])
self._button_stop = gtk.Button()
self._button_stop.set_label(_("_Stop"))
self._button_stop.set_no_show_all(True)
self._label_button_settings = gtk.Label(_("_Settings"))
self._label_button_settings.set_use_underline(True)
self._hbox_button_settings = gtk.HBox()
self._hbox_button_settings.pack_start(self._label_button_settings,
expand=True,
fill=True)
self._hbox_button_settings.pack_start(gtk.Arrow(
gtk.ARROW_DOWN, gtk.SHADOW_IN),
expand=False,
fill=False)
self._button_settings = gtk.Button()
self._button_settings.add(self._hbox_button_settings)
self._menu_item_show_more_settings = gtk.CheckMenuItem(
_("Show More Settings"))
self._menu_item_save_settings = gtk.MenuItem(_("Save Settings"))
self._menu_item_reset_settings = gtk.MenuItem(_("Reset settings"))
self._menu_settings = gtk.Menu()
self._menu_settings.append(self._menu_item_show_more_settings)
self._menu_settings.append(self._menu_item_save_settings)
self._menu_settings.append(self._menu_item_reset_settings)
self._menu_settings.show_all()
self._dialog.action_area.pack_end(self._button_stop,
expand=False,
fill=False)
self._dialog.action_area.pack_start(self._button_settings,
expand=False,
fill=False)
self._dialog.action_area.set_child_secondary(self._button_settings,
True)
if _webbrowser_module_found:
self._button_help = gtk.Button()
self._button_help.set_label(_("_Help"))
self._dialog.action_area.pack_start(self._button_help,
expand=False,
fill=False)
self._dialog.action_area.set_child_secondary(
self._button_help, True)
self._progress_bar = gtk.ProgressBar()
self._progress_bar.set_ellipsize(pango.ELLIPSIZE_MIDDLE)
self._progress_bar.set_no_show_all(True)
self._hbox_contents = gtk.HBox()
self._hbox_contents.pack_start(self._hpaned_settings_and_previews,
expand=True,
fill=True)
self._hbox_contents.set_border_width(
self._DIALOG_CONTENTS_BORDER_WIDTH)
self._dialog.vbox.set_spacing(self._DIALOG_VBOX_SPACING)
self._dialog.vbox.pack_start(self._hbox_contents,
expand=True,
fill=True)
self._dialog.vbox.pack_end(self._progress_bar,
expand=False,
fill=False)
# Move the action area above the progress bar.
self._dialog.vbox.reorder_child(self._dialog.action_area, -1)
def __init__(self):
"""Object constructor.
Here main user interface elements comes into life. It divides the window
and put all the widgets in appriopriate places.
@note Dual inheritance requires to not use of super().
@todo Add proper docking mechanisms in future.
"""
Singleton.__init__(self, type=gtk.WINDOW_TOPLEVEL)
gtk.Window.__init__(self, type=gtk.WINDOW_TOPLEVEL)
self.set_title('Robotiq')
self.prepare_icons()
p = PersistentContainer()
width = int(p.window.width or 400)
height = int(p.window.height or 300)
x = int(p.window.x or 200)
y = int(p.window.y or 200)
self.set_default_size(width, height)
self.move(x, y)
#gobject.type_register(MainWindow)
self.uimanager = gtk.UIManager()
self.actiongroup = gtk.ActionGroup('MainActionGroup')
self._prepare_actions(self.actiongroup)
self.uimanager.insert_action_group(self.actiongroup, 0)
self.uimanager.add_ui_from_file('ui/mainui.xml')
accelgroup = self.uimanager.get_accel_group()
self.add_accel_group(accelgroup)
with warnings.catch_warnings():
# Suppress warnings of not filled menu at this stage
warnings.simplefilter('ignore', gtk.Warning)
self.main_menu = self.uimanager.get_widget('/MenuBar')
#self.main_menu.show()
self.uimanager.get_widget('/MenuBar/HelpMenu').set_right_justified(True)
self.toolbar = self.uimanager.get_widget('/Toolbar')
#self.toolbar.show()
# TODO: Temporary elements in window
self.command_output = CommandOutput(None) # FIXME: provide access to data by dispatcher instead of object
#self.command_output.show()
self.set_geometry_hints(self.command_output, 150, 200, -1, -1, 150, 200, 1, 1, 0.75, 10)
self.frame_cmd_output = gtk.Frame()
self.frame_cmd_output.set_shadow_type(gtk.SHADOW_IN)
#self.frame_cmd_output.show()
self.frame_cmd_output.add(self.command_output)
self.command_entry = CommandEntry(None, None) #self.command_output) # FIXME: provide access to console by dispatcher instead of object
#self.command_entry.show()
# TODO: going to be dockable
self.right_vpaned = gtk.VPaned()
dupa1 = gtk.Label(_('Placeholder'))
self.control_buttons = ControlButtons()
#self.control_buttons.show()
self.frame_ctrl_buttons = gtk.Frame()
#self.frame_ctrl_buttons.show()
self.frame_ctrl_buttons.add(self.control_buttons)
dupa1.show()
self.right_vpaned.pack1(dupa1)
self.right_vpaned.pack2(self.frame_ctrl_buttons)
self.right_vpaned.show()
self.top_hpaned = gtk.HPaned()
self.top_hpaned.pack1(self.frame_cmd_output, True, False)
self.top_hpaned.pack2(self.right_vpaned, True)
#self.top_hpaned.show()
self.statusbar = gtk.Statusbar()
#self.statusbar.show()
self.vbox = gtk.VBox(False, 2)
self.add(self.vbox)
self.vbox.pack_start(self.main_menu, False, False, 0)
self.vbox.pack_start(self.toolbar, False, False, 0)
self.vbox.pack_end(self.statusbar, False, False, 0)
self.vbox.pack_end(self.command_entry, False, False, 0)
self.vbox.pack_end(self.top_hpaned, True, True, 0)
self.vbox.show()
self._prepare_keys_table()
self._prepare_dispatchions()
self._prepare_signals()
self._comm_ui = CommunicationUserInterface()
self._cmds_ui = CommandsUserInterface()
return
def __init__(self):
"""
Constructor
"""
gtk.VBox.__init__(self)
#prepare images:
offline_image = gtk.Image()
offline_image.set_from_file(Globals.icon_dir+'/gray-icon.png')
self.offline_pixbuf = offline_image.get_pixbuf()
online_image = gtk.Image()
online_image.set_from_file(Globals.icon_dir+'/green-icon.png')
self.online_pixbuf = online_image.get_pixbuf()
mainbox = gtk.HBox()
self.pack_start(mainbox)
buddieslistview = self.create_buddy_list_view()
mainbox.pack_start(buddieslistview, False, False)
serverlistbox = gtk.VBox()
mainbox.pack_start(serverlistbox)
self.filter = BuddiesFilter(self)
self.filter.show()
serverlistbox.pack_start(self.filter, False, False)
# top pane area
paned = gtk.VPaned()
paned.show()
serverlistbox.pack_start(paned)
# bottom add a statusbar
self.statusbar = StatusBar(self)
serverlistbox.pack_start(self.statusbar, False, False)
# serverlist window
self.serverlist = ServerList(self)
paned.pack1(self.serverlist, True, False)
#paned.add1(self.serverlist)
# bottom panearea
bottompane = gtk.HPaned()
paned.pack2(bottompane, True, False)
#paned.add2(bottompane)
#left box
self.playerlist = PlayerList()
bottompane.pack1(self.playerlist, False, False)
#right box
self.detailsbox = ServerDetailBox()
vbox = gtk.VBox()
bottompane.pack2(vbox, True, False)
buttonbox = gtk.HBox()
#self.detailsbox.pack_start(buttonbox, False, False)
vbox.pack_start(buttonbox, False, False)
vbox.pack_start(self.detailsbox)
addfav_button = gtk.Button('Add to Favorites')
favimage = gtk.Image()
favimage.set_from_stock(gtk.STOCK_ADD, gtk.ICON_SIZE_BUTTON)
addfav_button.set_image(favimage)
refresh_button = gtk.Button('Refresh')
refreshimage = gtk.Image()
refreshimage.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_BUTTON)
refresh_button.set_image(refreshimage)
connect_button = gtk.Button('Connect')
connectimage = gtk.Image()
connectimage.set_from_stock(gtk.STOCK_CONNECT, gtk.ICON_SIZE_BUTTON)
connect_button.set_image(connectimage)
buttonbox.pack_start(refresh_button, True, True)
buttonbox.pack_start(connect_button, True, True)
buttonbox.pack_start(addfav_button, True, True)
refresh_button.connect("clicked", self.onRefreshButtonClicked)
addfav_button.connect("clicked", self.onAddFavButtonClicked)
connect_button.connect("clicked", self.connect_button_clicked)
self.show_all()
def __init__(self,
cmd_args,
description=None,
title=None,
stock_id=gtk.STOCK_EXECUTE,
hide_progress=False,
modal=True,
event_queue=None):
self.proc = None
window = get_dialog_parent()
self.dialog = gtk.Dialog(buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT),
parent=window)
self.dialog.set_modal(modal)
self.dialog.set_default_size(*DIALOG_SIZE_PROCESS)
self._is_destroyed = False
self.dialog.set_icon(
self.dialog.render_icon(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_MENU))
self.cmd_args = cmd_args
self.event_queue = event_queue
str_cmd_args = [rose.gtk.util.safe_str(a) for a in cmd_args]
if description is not None:
str_cmd_args = [description]
if title is None:
self.dialog.set_title(" ".join(str_cmd_args[0:2]))
else:
self.dialog.set_title(title)
if callable(cmd_args[0]):
self.label = gtk.Label(self.DIALOG_FUNCTION_LABEL)
else:
self.label = gtk.Label(self.DIALOG_PROCESS_LABEL)
self.label.set_use_markup(True)
self.label.show()
self.image = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_DIALOG)
self.image.show()
image_vbox = gtk.VBox()
image_vbox.pack_start(self.image, expand=False, fill=False)
image_vbox.show()
top_hbox = gtk.HBox()
top_hbox.pack_start(image_vbox,
expand=False,
fill=False,
padding=DIALOG_PADDING)
top_hbox.show()
hbox = gtk.HBox()
hbox.pack_start(self.label,
expand=False,
fill=False,
padding=DIALOG_PADDING)
hbox.show()
main_vbox = gtk.VBox()
main_vbox.show()
main_vbox.pack_start(hbox,
expand=False,
fill=False,
padding=DIALOG_SUB_PADDING)
cmd_string = str_cmd_args[0]
if str_cmd_args[1:]:
if callable(cmd_args[0]):
cmd_string += "(" + " ".join(str_cmd_args[1:]) + ")"
else:
cmd_string += " " + " ".join(str_cmd_args[1:])
self.cmd_label = gtk.Label()
self.cmd_label.set_markup("<b>" + cmd_string + "</b>")
self.cmd_label.show()
cmd_hbox = gtk.HBox()
cmd_hbox.pack_start(self.cmd_label,
expand=False,
fill=False,
padding=DIALOG_PADDING)
cmd_hbox.show()
main_vbox.pack_start(cmd_hbox,
expand=False,
fill=True,
padding=DIALOG_SUB_PADDING)
# self.dialog.set_modal(True)
self.progress_bar = gtk.ProgressBar()
self.progress_bar.set_pulse_step(0.1)
self.progress_bar.show()
hbox = gtk.HBox()
hbox.pack_start(self.progress_bar,
expand=True,
fill=True,
padding=DIALOG_PADDING)
hbox.show()
main_vbox.pack_start(hbox,
expand=False,
fill=False,
padding=DIALOG_SUB_PADDING)
top_hbox.pack_start(main_vbox,
expand=True,
fill=True,
padding=DIALOG_PADDING)
if self.event_queue is None:
self.dialog.vbox.pack_start(top_hbox, expand=True, fill=True)
else:
text_view_scroll = gtk.ScrolledWindow()
text_view_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
text_view_scroll.show()
text_view = gtk.TextView()
text_view.show()
self.text_buffer = text_view.get_buffer()
self.text_tag = self.text_buffer.create_tag()
self.text_tag.set_property("scale", pango.SCALE_SMALL)
text_view.connect('size-allocate', self._handle_scroll_text_view)
text_view_scroll.add(text_view)
text_expander = gtk.Expander(self.DIALOG_LOG_LABEL)
text_expander.set_spacing(DIALOG_SUB_PADDING)
text_expander.add(text_view_scroll)
text_expander.show()
top_pane = gtk.VPaned()
top_pane.pack1(top_hbox, resize=False, shrink=False)
top_pane.show()
self.dialog.vbox.pack_start(top_pane,
expand=True,
fill=True,
padding=DIALOG_SUB_PADDING)
top_pane.pack2(text_expander, resize=True, shrink=True)
if hide_progress:
progress_bar.hide()
self.ok_button = self.dialog.get_action_area().get_children()[0]
self.ok_button.hide()
for child in self.dialog.vbox.get_children():
if isinstance(child, gtk.HSeparator):
child.hide()
self.dialog.show()
def __init__(self, config, db, sql, mainwin, debug=True):
self.conf = config
self.db = db
self.cursor = self.db.cursor
self.sql = sql
self.main_window = mainwin
self.debug = debug
self.liststore = [
] # gtk.ListStore[] stores the contents of the grids
self.listcols = [
] # gtk.TreeViewColumn[][] stores the columns in the grids
filters_display = {
"Heroes": True,
"Sites": True,
#"Games" : True,
#"Limits" : True,
#"LimitSep" : True,
#"LimitType" : True,
#"Type" : True,
"Seats": True,
#"SeatSep" : True,
"Dates": True,
#"Groups" : True,
#"GroupsAll" : True,
#"Button1" : True,
"Button2": True
}
self.stats_frame = None
self.stats_vbox = None
self.detailFilters = [] # the data used to enhance the sql select
self.main_hbox = gtk.HPaned()
self.filters = TourneyFilters.TourneyFilters(self.db,
self.conf,
self.sql,
display=filters_display)
#self.filters.registerButton1Name(_("_Filters"))
#self.filters.registerButton1Callback(self.showDetailFilter)
self.filters.registerButton2Name(_("_Refresh Stats"))
self.filters.registerButton2Callback(self.refreshStats)
# ToDo: store in config
# ToDo: create popup to adjust column config
# columns to display, keys match column name returned by sql, values in tuple are:
# is column displayed, column heading, xalignment, formatting, celltype
self.columns = [
["siteName", True, _("Site"), 0.0, "%s", "str"]
#,["tourney", False, _("Tourney"), 0.0, "%s", "str"] # true not allowed for this line
,
["category", True, _("Cat."), 0.0, "%s", "str"],
["limitType", True,
_("Limit"), 0.0, "%s", "str"],
["currency", True, _("Curr."), 0.0, "%s", "str"],
["buyIn", True, _("BuyIn"), 1.0, "%3.2f", "str"],
["fee", True, _("Fee"), 1.0, "%3.2f", "str"],
["playerName", False,
_("Name"), 0.0, "%s",
"str"] # true not allowed for this line (set in code)
,
["tourneyCount", True,
_("#"), 1.0, "%1.0f", "str"],
["itm", True, _("ITM%"), 1.0, "%3.2f", "str"],
["_1st", False, _("1st"), 1.0, "%1.0f", "str"],
["_2nd", True, _("2nd"), 1.0, "%1.0f", "str"],
["_3rd", True, _("3rd"), 1.0, "%1.0f", "str"],
["unknownRank", True,
_("Rank?"), 1.0, "%1.0f", "str"],
["spent", True, _("Spent"), 1.0, "%3.2f", "str"],
["won", True, _("Won"), 1.0, "%3.2f", "str"],
["roi", True, _("ROI%"), 1.0, "%3.0f", "str"],
["profitPerTourney", True,
_("$/Tour"), 1.0, "%3.2f", "str"]
]
self.stats_frame = gtk.Frame()
self.stats_frame.show()
self.stats_vbox = gtk.VPaned()
self.stats_vbox.show()
self.stats_frame.add(self.stats_vbox)
# self.fillStatsFrame(self.stats_vbox)
#self.main_hbox.pack_start(self.filters.get_vbox())
#self.main_hbox.pack_start(self.stats_frame, expand=True, fill=True)
self.main_hbox.pack1(self.filters.get_vbox())
self.main_hbox.pack2(self.stats_frame)
self.main_hbox.show()
def __init__(self, parent=None):
gtk.Window.__init__(self)
self.editors.add(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('delete-event', self.close)
self.set_title("odML Editor")
self.set_default_size(800, 600)
# Check available screen size and adjust default app size to 1024x768 if possible.
screen = self.get_screen()
# Use first available monitor as default.
currmon = 0
actwin = screen.get_active_window()
# Set current monitor only, when active window returns not None.
if actwin:
currmon = screen.get_monitor_at_window(actwin)
mondims = screen.get_monitor_geometry(currmon)
if mondims.width >= 1024 and mondims.height >= 768:
self.set_default_size(1024, 768)
icons = load_icon_pixbufs("odml-logo")
self.set_icon_list(icons)
merge = gtk.UIManager()
merge.connect('connect-proxy', self.on_uimanager__connect_proxy)
merge.connect('disconnect-proxy', self.on_uimanager__disconnect_proxy)
# ### CHANGE :-
# The 'set-data' method in PyGTK is no longer available.
# Now, we have to set it just as a data member of the object.
self.ui_manager = merge
merge.insert_action_group(self.__create_action_group(), 0)
self.add_accel_group(merge.get_accel_group())
try:
mergeid = merge.add_ui_from_string(UI_INFO)
except gobject.GError as msg:
print("building menus failed: %s" % msg)
menu_bar = merge.get_widget("/MenuBar")
menu_bar.show()
table = gtk.Table(n_rows=2, n_columns=6, homogeneous=False)
self.add(table)
# Every line of arguments addresses first the X and then the Y direction
table.attach(menu_bar, 0, 2, 0, 1, gtk.EXPAND | gtk.FILL, 0, 0, 0)
tool_bar = merge.get_widget("/ToolBar")
tool_bar.show()
table.attach(tool_bar, 0, 2, 1, 2, gtk.EXPAND | gtk.FILL, 0, 0, 0)
tool_button = merge.get_widget("/ToolBar/Open")
tool_button.connect("clicked", self.open_file)
tool_button.set_arrow_tooltip_text("Open a recently used file")
tool_button.set_label("Open")
tool_button.set_tooltip_text("Open Files")
navigation_bar = NavigationBar()
navigation_bar.on_selection_change = self.on_navigate
self._navigation_bar = navigation_bar
# schematic organization
# -vpaned---------------------------
# | -hpaned-----+-------------------
# || | -property_view(vbox)
# || scrolled: | | info_bar
# || section_tv| +----------------
# || | | scrolled: property_tv
# || | \----------------
# |\------------+-------------------
# +----------------------------------
# | --frame: navigation bar -------
# | +-------------------------------
# | | scrolled: _property_view
# | \-------------------------------
# \----------------------------------
hpaned = gtk.HPaned()
hpaned.show()
hpaned.set_position(150)
section_tv = SectionView(self.registry)
section_tv.execute = self.execute
section_tv.on_section_change = self.on_section_change
section_view = gtk.VBox(homogeneous=False, spacing=0)
tmp = gtk.Frame.new("Sections")
tmp.add(ScrolledWindow(section_tv._treeview))
tmp.show()
section_view.pack_start(tmp, True, True, 1)
section_view.show()
hpaned.add1(section_view)
property_tv = PropertyView(self.registry)
property_tv.execute = self.execute
property_tv.on_property_select = self.on_object_select
property_view = gtk.VBox(homogeneous=False, spacing=0)
info_bar = EditorInfoBar()
self._info_bar = info_bar
property_view.pack_start(info_bar, False, False, 1)
tmp = gtk.Frame.new("Properties")
tmp.add(ScrolledWindow(property_tv._treeview))
tmp.show()
property_view.pack_start(tmp, True, True, 1)
property_view.show()
hpaned.add2(property_view)
self._property_tv = property_tv
self._section_tv = section_tv
# property_view to edit ODML-Properties
# to edit properties of Document, Section or Property:
self._property_view = AttributeView(self.execute)
frame = gtk.Frame()
frame.set_label_widget(navigation_bar)
frame.add(ScrolledWindow(self._property_view._treeview))
frame.show()
vpaned = gtk.VPaned()
vpaned.show()
# Adjust Attribute view position to default window size
vpaned.set_position(self.get_default_size().height - 300)
vpaned.pack1(hpaned, resize=True, shrink=False)
vpaned.pack2(frame, resize=False, shrink=True)
# Check if odML-tables is available
self.odml_tables_available = False
try:
from odmltables import gui
from odmltables import VERSION as OT_VERSION
if CheckVer(OT_VERSION) >= ODMLTABLES_VERSION:
self.odml_tables_available = True
except (ImportError, AttributeError) as err:
print("[Info] odMLTables not available: %s" % err)
class Tab(gtk.HBox):
"""
a tab container
"""
child = vpaned
self.Tab = Tab
notebook = gtk.Notebook()
notebook.connect("switch-page", self.on_tab_select)
notebook.connect("create-window", self.on_new_tab_window)
notebook.show()
self.notebook = notebook
# Every line of arguments addresses first the X and then the Y direction
table.attach(notebook, 0, 2, 3, 4, gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL, 0, 0)
statusbar = gtk.Statusbar()
table.attach(statusbar, 0, 2, 5, 6, gtk.EXPAND | gtk.FILL, 0, 0, 0)
self._statusbar = statusbar
statusbar.show()
self.show_all()
def interface():
global ntb, tview_exec, tview_src
# window
window = gtk.Window()
window.set_wmclass(PACKAGE, PACKAGE)
window.set_title(PACKAGE)
window.resize(800, 600)
window.set_resizable(True)
window.connect('destroy', quit)
# HPaned
vpaned = gtk.VPaned()
window.add(vpaned)
# ScrolledWindow for clist
sw_clist = gtk.ScrolledWindow()
sw_clist.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vpaned.pack1(sw_clist, False, False)
# CList to launch examples
clist = CList(cols=[('Examples (double click for demo)',
gobject.TYPE_STRING, 0, 0, 0, 0)],
cbs=[('row-activated', on_clist_row_doubleclicked)])
clist.get_selection().connect('changed', on_clist_row_clicked)
clist.set_rules_hint(True)
clist.append_row(['Signing a template file'])
clist.append_row(['Signing a file with a dynamicaly created template'])
clist.append_row([
'Signing a file with a dynamicaly created template and an X509 certificate'
])
clist.append_row(['Verifying a file using a single key'])
clist.append_row(['Verifying a file using keys manager'])
clist.append_row(['Verifying a file signed with X509 certificate'])
clist.append_row(['Verifying a signature with additional restrictions'])
clist.append_row(['Encrypting data using a template file'])
clist.append_row(
['Encrypting XML file with a dynamicaly created template'])
clist.append_row([
'Encrypting XML file with a session key and dynamicaly created template'
])
clist.append_row(['Decrypting an encrypted file using a single key'])
clist.append_row(['Decrypting an encrypted file using keys manager'])
clist.append_row(
['Decrypting an encrypted file using a custom keys manager'])
sw_clist.add(clist)
# Notebook
ntb = gtk.Notebook()
vpaned.pack2(ntb, False, False)
# ScrolledWindow for TextView Source
sw_tview_src = gtk.ScrolledWindow()
sw_tview_src.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
ntb.append_page(sw_tview_src, gtk.Label("Source"))
# TextView Source
tview_src = TView()
sw_tview_src.add(tview_src)
# ScrolledWindow for TextView Execution
sw_tview_exec = gtk.ScrolledWindow()
sw_tview_exec.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
ntb.append_page(sw_tview_exec, gtk.Label("Execution"))
# TextView Execution
tview_exec = TView()
sw_tview_exec.add(tview_exec)
# Show all widgets
window.show_all()
def build_gui(self, container):
self.pickcenter = None
vpaned = gtk.VPaned()
nb = gtk.Notebook()
#nb.set_group_id(group)
#nb.connect("create-window", self.detach_page, group)
nb.set_tab_pos(gtk.POS_RIGHT)
nb.set_scrollable(True)
nb.set_show_tabs(True)
nb.set_show_border(False)
self.w.nb1 = nb
vpaned.pack1(nb, resize=True, shrink=True)
cm, im = self.fv.cm, self.fv.im
di = FitsImageCanvasGtk.FitsImageCanvas(logger=self.logger)
di.enable_autozoom('off')
di.enable_autocuts('off')
di.enable_zoom(True)
di.enable_cuts(True)
di.zoom_to(3, redraw=False)
di.set_callback('zoom-set', self.zoomset)
di.set_cmap(cm, redraw=False)
di.set_imap(im, redraw=False)
di.set_callback('motion', self.detailxy)
di.set_bg(0.4, 0.4, 0.4)
self.pickimage = di
iw = di.get_widget()
width, height = 200, 200
iw.set_size_request(width, height)
label = gtk.Label('Image')
label.show()
nb.append_page(iw, label)
nb.set_tab_reorderable(iw, True)
#nb.set_tab_detachable(iw, True)
if have_mpl:
self.w.fig = matplotlib.figure.Figure()
self.w.ax = self.w.fig.add_subplot(111, axisbg='black')
self.w.ax.set_aspect('equal', adjustable='box')
self.w.ax.set_title('Contours')
#self.w.ax.grid(True)
canvas = FigureCanvas(self.w.fig)
#canvas.set_size_request(width, height)
self.w.canvas = canvas
self.w.canvas.show_all()
canvas.connect("scroll_event", self.plot_scroll)
#canvas.connect("key_press_event", self.pan_plot)
canvas.connect("motion_notify_event", self.plot_motion_notify)
canvas.connect("button_press_event", self.plot_button_press)
canvas.connect("button_release_event", self.plot_button_release)
label = gtk.Label('Contour')
label.show()
nb.append_page(canvas, label)
nb.set_tab_reorderable(canvas, True)
#nb.set_tab_detachable(canvas, True)
self.w.fig2 = matplotlib.figure.Figure()
self.w.ax2 = self.w.fig2.add_subplot(111, axisbg='white')
#self.w.ax2.set_aspect('equal', adjustable='box')
self.w.ax2.set_ylabel('brightness')
self.w.ax2.set_xlabel('pixels')
self.w.ax2.set_title('FWHM')
self.w.ax.grid(True)
canvas = FigureCanvas(self.w.fig2)
#canvas.set_size_request(width, height)
self.w.canvas2 = canvas
self.w.canvas2.show_all()
label = gtk.Label('FWHM')
label.show()
nb.append_page(canvas, label)
nb.set_tab_reorderable(canvas, True)
#nb.set_tab_detachable(canvas, True)
sw = gtk.ScrolledWindow()
sw.set_border_width(2)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
vbox = gtk.VBox()
sw.add_with_viewport(vbox)
self.msgFont = pango.FontDescription("Sans 14")
tw = gtk.TextView()
tw.set_wrap_mode(gtk.WRAP_WORD)
tw.set_left_margin(4)
tw.set_right_margin(4)
tw.set_editable(False)
tw.set_left_margin(4)
tw.set_right_margin(4)
tw.modify_font(self.msgFont)
self.tw = tw
fr = gtk.Frame(" Instructions ")
fr.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
fr.set_label_align(0.1, 0.5)
fr.add(tw)
vbox.pack_start(fr, padding=4, fill=True, expand=False)
fr = gtk.Frame(" Pick ")
fr.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
fr.set_label_align(0.1, 0.5)
nb = gtk.Notebook()
#nb.set_group_id(group)
#nb.connect("create-window", self.detach_page, group)
nb.set_tab_pos(gtk.POS_BOTTOM)
nb.set_scrollable(True)
nb.set_show_tabs(True)
nb.set_show_border(False)
self.w.nb2 = nb
fr.add(nb)
vbox.pack_start(fr, padding=4, fill=True, expand=False)
# Build report panel
captions = (
('Zoom', 'label', 'Contour Zoom', 'label'),
('Object_X', 'label', 'Object_Y', 'label'),
('RA', 'label', 'DEC', 'label'),
('Equinox', 'label', 'Background', 'label'),
('Sky Level', 'label', 'Brightness', 'label'),
('FWHM X', 'label', 'FWHM Y', 'label'),
('FWHM', 'label', 'Star Size', 'label'),
('Sample Area', 'label', 'Default Region', 'button'),
)
w, b = GtkHelp.build_info(captions)
self.w.update(b)
b.zoom.set_text(self.fv.scale2text(di.get_scale()))
self.wdetail = b
b.default_region.connect('clicked', lambda w: self.reset_region())
self.w.tooltips.set_tip(b.default_region,
"Reset region size to default")
# Pick field evaluation status
label = gtk.Label()
label.set_alignment(0.05, 0.5)
self.w.eval_status = label
w.pack_start(self.w.eval_status, fill=False, expand=False, padding=2)
# Pick field evaluation progress bar and stop button
hbox = gtk.HBox()
btn = gtk.Button("Stop")
btn.connect('clicked', lambda w: self.eval_intr())
btn.set_sensitive(False)
self.w.btn_intr_eval = btn
hbox.pack_end(btn, fill=False, expand=False, padding=2)
self.w.eval_pgs = gtk.ProgressBar()
# GTK3
#self.w.eval_pgs.set_orientation(gtk.ORIENTATION_HORIZONTAL)
#self.w.eval_pgs.set_inverted(False)
hbox.pack_start(self.w.eval_pgs, fill=True, expand=True, padding=4)
w.pack_start(hbox, fill=False, expand=False, padding=2)
label = gtk.Label("Report")
label.show()
nb.append_page(w, label)
nb.set_tab_reorderable(w, True)
#nb.set_tab_detachable(w, True)
# Build settings panel
captions = (
('Show Candidates', 'checkbutton'),
('Radius', 'xlabel', '@Radius', 'spinbutton'),
('Threshold', 'xlabel', '@Threshold', 'entry'),
('Min FWHM', 'xlabel', '@Min FWHM', 'spinbutton'),
('Max FWHM', 'xlabel', '@Max FWHM', 'spinbutton'),
('Ellipticity', 'xlabel', '@Ellipticity', 'entry'),
('Edge', 'xlabel', '@Edge', 'entry'),
('Max side', 'xlabel', '@Max side', 'spinbutton'),
('Redo Pick', 'button'),
)
w, b = GtkHelp.build_info(captions)
self.w.update(b)
self.w.tooltips.set_tip(b.radius, "Radius for peak detection")
self.w.tooltips.set_tip(
b.threshold, "Threshold for peak detection (blank=default)")
self.w.tooltips.set_tip(b.min_fwhm, "Minimum FWHM for selection")
self.w.tooltips.set_tip(b.max_fwhm, "Maximum FWHM for selection")
self.w.tooltips.set_tip(b.ellipticity,
"Minimum ellipticity for selection")
self.w.tooltips.set_tip(b.edge, "Minimum edge distance for selection")
self.w.tooltips.set_tip(b.show_candidates, "Show all peak candidates")
# radius control
adj = b.radius.get_adjustment()
b.radius.set_digits(2)
b.radius.set_numeric(True)
adj.configure(self.radius, 5.0, 200.0, 1.0, 10.0, 0)
def chg_radius(w):
self.radius = float(w.get_text())
self.w.lbl_radius.set_text(str(self.radius))
return True
b.lbl_radius.set_text(str(self.radius))
b.radius.connect('value-changed', chg_radius)
# threshold control
def chg_threshold(w):
threshold = None
ths = w.get_text().strip()
if len(ths) > 0:
threshold = float(ths)
self.threshold = threshold
self.w.lbl_threshold.set_text(str(self.threshold))
return True
b.lbl_threshold.set_text(str(self.threshold))
b.threshold.connect('activate', chg_threshold)
# min fwhm
adj = b.min_fwhm.get_adjustment()
b.min_fwhm.set_digits(2)
b.min_fwhm.set_numeric(True)
adj.configure(self.min_fwhm, 0.1, 200.0, 0.1, 1, 0)
def chg_min(w):
self.min_fwhm = w.get_value()
self.w.lbl_min_fwhm.set_text(str(self.min_fwhm))
return True
b.lbl_min_fwhm.set_text(str(self.min_fwhm))
b.min_fwhm.connect('value-changed', chg_min)
# max fwhm
adj = b.max_fwhm.get_adjustment()
b.max_fwhm.set_digits(2)
b.max_fwhm.set_numeric(True)
adj.configure(self.max_fwhm, 0.1, 200.0, 0.1, 1, 0)
def chg_max(w):
self.max_fwhm = w.get_value()
self.w.lbl_max_fwhm.set_text(str(self.max_fwhm))
return True
b.lbl_max_fwhm.set_text(str(self.max_fwhm))
b.max_fwhm.connect('value-changed', chg_max)
# Ellipticity control
def chg_ellipticity(w):
minellipse = None
val = w.get_text().strip()
if len(val) > 0:
minellipse = float(val)
self.min_ellipse = minellipse
self.w.lbl_ellipticity.set_text(str(self.min_ellipse))
return True
b.lbl_ellipticity.set_text(str(self.min_ellipse))
b.ellipticity.connect('activate', chg_ellipticity)
# Edge control
def chg_edgew(w):
edgew = None
val = w.get_text().strip()
if len(val) > 0:
edgew = float(val)
self.edgew = edgew
self.w.lbl_edge.set_text(str(self.edgew))
return True
b.lbl_edge.set_text(str(self.edgew))
b.edge.connect('activate', chg_edgew)
adj = b.max_side.get_adjustment()
b.max_side.set_digits(0)
b.max_side.set_numeric(True)
adj.configure(self.max_side, 5, 10000, 10, 100, 0)
def chg_max_side(w):
self.max_side = int(w.get_value())
self.w.lbl_max_side.set_text(str(self.max_side))
return True
b.lbl_max_side.set_text(str(self.max_side))
b.max_side.connect('value-changed', chg_max_side)
b.redo_pick.connect('clicked', lambda w: self.redo())
b.show_candidates.set_active(self.show_candidates)
b.show_candidates.connect('toggled', self.show_candidates_cb)
label = gtk.Label("Settings")
label.show()
nb.append_page(w, label)
nb.set_tab_reorderable(w, True)
#nb.set_tab_detachable(w, True)
# Build controls panel
captions = (
('Sky cut', 'button', 'Delta sky', 'xlabel', '@Delta sky',
'entry'),
('Bright cut', 'button', 'Delta bright', 'xlabel', '@Delta bright',
'entry'),
)
w, b = GtkHelp.build_info(captions)
self.w.update(b)
self.w.tooltips.set_tip(b.sky_cut, "Set image low cut to Sky Level")
self.w.tooltips.set_tip(b.delta_sky, "Delta to apply to low cut")
self.w.tooltips.set_tip(b.bright_cut,
"Set image high cut to Sky Level+Brightness")
self.w.tooltips.set_tip(b.delta_bright, "Delta to apply to high cut")
b.sky_cut.set_sensitive(False)
self.w.btn_sky_cut = b.sky_cut
self.w.btn_sky_cut.connect('clicked', lambda w: self.sky_cut())
self.w.sky_cut_delta = b.delta_sky
b.lbl_delta_sky.set_text(str(self.delta_sky))
b.delta_sky.set_text(str(self.delta_sky))
def chg_delta_sky(w):
delta_sky = 0.0
val = w.get_text().strip()
if len(val) > 0:
delta_sky = float(val)
self.delta_sky = delta_sky
self.w.lbl_delta_sky.set_text(str(self.delta_sky))
return True
b.delta_sky.connect('activate', chg_delta_sky)
b.bright_cut.set_sensitive(False)
self.w.btn_bright_cut = b.bright_cut
self.w.btn_bright_cut.connect('clicked', lambda w: self.bright_cut())
self.w.bright_cut_delta = b.delta_bright
b.lbl_delta_bright.set_text(str(self.delta_bright))
b.delta_bright.set_text(str(self.delta_bright))
def chg_delta_bright(w):
delta_bright = 0.0
val = w.get_text().strip()
if len(val) > 0:
delta_bright = float(val)
self.delta_bright = delta_bright
self.w.lbl_delta_bright.set_text(str(self.delta_bright))
return True
b.delta_bright.connect('activate', chg_delta_bright)
label = gtk.Label("Controls")
label.show()
nb.append_page(w, label)
nb.set_tab_reorderable(w, True)
#nb.set_tab_detachable(w, True)
btns = gtk.HButtonBox()
btns.set_layout(gtk.BUTTONBOX_START)
btns.set_spacing(3)
btns.set_child_size(15, -1)
btn = gtk.Button("Close")
btn.connect('clicked', lambda w: self.close())
btns.add(btn)
vbox.pack_start(btns, padding=4, fill=True, expand=False)
vpaned.pack2(sw, resize=True, shrink=True)
vpaned.set_position(280)
vpaned.show_all()
container.pack_start(vpaned, padding=0, fill=True, expand=True)
def preinitialize(self, name, gfxmanager, clone):
# preinitialize is called by GfxWindowBase.__init__ on the
# main thread *before* GhostGfxWindow.__init__ is called.
debug.mainthreadTest()
self.gtk = None
self.closed = None # State data used at window-close time.
self.name = name
self.oofcanvas = None
self.realized = 0
self.zoomed = 0
self.settings = ghostgfxwindow.GfxSettings()
self.mouseHandler = mousehandler.nullHandler # doesn't do anything
# Build all the GTK objects for the interior of the box. These
# actually get added to the window itself after the SubWindow
# __init__ call. They need to be created first so the
# GhostGfxWindow can operate on them, and then create the menus
# which are handed off to the SubWindow.
self.mainpane = gtk.VPaned()
gtklogger.setWidgetName(self.mainpane, 'Pane0')
# Pane dividing upper pane horizontally into 2 parts.
self.paned1 = gtk.HPaned()
gtklogger.setWidgetName(self.paned1, "Pane2")
# "resize=True" here means that when the window is resized
# vertically, the canvas and toolboxes will resize, but the
# layer list won't. It also makes the layer list compact when
# the window is first opened. This is what we want. However,
# on some systems (those using Unity WM, maybe) the layer list
# is completely collapsed in the initial window, which is
# unfriendly but not fatal. Ubuntu 17.10 doesn't have the
# problem so it's not going to be fixed.
self.mainpane.pack1(self.paned1, resize=True)
gtklogger.connect_passive(self.paned1, 'size-allocate')
# The toolbox is in the left half of paned1 (ie the left frame of 3)
toolboxframe = gtk.Frame()
toolboxframe.set_shadow_type(gtk.SHADOW_IN)
self.paned1.pack1(toolboxframe, resize=True)
## TODO OPT: Does the frame size really need to be logged? It
## should just follow from the pane size.
gtklogger.setWidgetName(toolboxframe, "ToolboxFrame")
gtklogger.connect_passive(toolboxframe, 'size-allocate')
# Box containing the toolbox label and the scroll window for
# the toolbox itself.
toolboxbox1 = gtk.VBox()
toolboxframe.add(toolboxbox1)
hbox = gtk.HBox()
toolboxbox1.pack_start(hbox, expand=0, fill=0, padding=2)
hbox.pack_start(gtk.Label("Toolbox:"), expand=0, fill=0, padding=3)
self.toolboxchooser = chooser.ChooserWidget(
[], callback=self.switchToolbox, name="TBChooser")
hbox.pack_start(self.toolboxchooser.gtk, expand=1, fill=1, padding=3)
# Scroll window for the toolbox itself.
toolboxbox2 = gtk.ScrolledWindow()
gtklogger.logScrollBars(toolboxbox2, 'TBScroll')
toolboxbox2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolboxbox1.pack_start(toolboxbox2, expand=1, fill=1)
# Actually, the tool box goes inside yet another box, so that
# we have a gtk.VBox that we can refer to later.
self.toolboxbody = gtk.VBox()
toolboxbox2.add_with_viewport(self.toolboxbody)
self.toolboxGUIs = [] # GUI wrappers for toolboxes.
self.current_toolbox = None
# The canvas is in the right half of paned1. The toolbar goes
# on top of the canvas.
self.canvasBox = gtk.VBox()
toolbarFrame = gtk.Frame()
toolbarFrame.set_shadow_type(gtk.SHADOW_IN)
self.canvasBox.pack_start(toolbarFrame, expand=0, fill=0, padding=0)
self.toolbarBox = gtk.VBox()
toolbarFrame.add(self.toolbarBox)
self.canvasFrame = gtk.Frame()
self.canvasFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.canvasFrame, "Canvas")
self.canvasBox.pack_start(self.canvasFrame,
expand=1,
fill=1,
padding=0)
self.paned1.pack2(self.canvasBox, resize=True)
# Bottom part of main pane is a list of layers. The actual
# DisplayLayer objects are stored in self.display.
layerFrame = gtk.Frame(label='Layers')
self.mainpane.pack2(layerFrame, resize=False)
self.layerScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.layerScroll, "LayerScroll")
self.layerScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
layerFrame.add(self.layerScroll)
self.layerList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.layerListView = gtk.TreeView(self.layerList)
gtklogger.setWidgetName(self.layerListView, "LayerList")
self.layerListView.set_row_separator_func(self.layerRowSepFunc)
self.layerListView.set_reorderable(True)
self.layerListView.set_fixed_height_mode(False)
self.layerScroll.add(self.layerListView)
gtklogger.adoptGObject(self.layerList,
self.layerListView,
access_method=self.layerListView.get_model)
# Handle right-clicks on the layer list. They pop up the
# Layer menu.
gtklogger.connect(self.layerListView, 'button-press-event',
self.layerListButtonCB)
# The row-deleted and row-inserted signals are used to detect
# when the user has reordered rows manually. When the program
# does anything that might cause these signals to be emitted,
# it must first call suppressRowOpSignals.
self.rowOpSignals = [
gtklogger.connect(self.layerList, "row-deleted",
self.listRowDeletedCB),
gtklogger.connect(self.layerList, "row-inserted",
self.listRowInsertedCB)
]
self.destination_path = None
showcell = gtk.CellRendererToggle()
showcol = gtk.TreeViewColumn("Show")
showcol.pack_start(showcell, expand=False)
showcol.set_cell_data_func(showcell, self.renderShowCell)
self.layerListView.append_column(showcol)
gtklogger.adoptGObject(showcell,
self.layerListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(showcell, 'toggled', self.showcellCB)
## cmapcell = gtk.CellRendererToggle()
## cmapcell.set_radio(True)
## cmapcol = gtk.TreeViewColumn("Map")
## cmapcol.pack_start(cmapcell, expand=False)
## cmapcol.set_cell_data_func(cmapcell, self.renderCMapCell)
## self.layerListView.append_column(cmapcol)
## gtklogger.adoptGObject(cmapcell, self.layerListView,
## access_function='findCellRenderer',
## access_kwargs={'col':1, 'rend':0})
## gtklogger.connect(cmapcell, 'toggled', self.cmapcellCB)
layercell = gtk.CellRendererText()
layercol = gtk.TreeViewColumn("What")
layercol.set_resizable(True)
layercol.pack_start(layercell, expand=True)
layercol.set_cell_data_func(layercell, self.renderLayerCell)
self.layerListView.append_column(layercol)
methodcell = gtk.CellRendererText()
methodcol = gtk.TreeViewColumn("How")
methodcol.set_resizable(True)
methodcol.pack_start(methodcell, expand=True)
methodcol.set_cell_data_func(methodcell, self.renderMethodCell)
self.layerListView.append_column(methodcol)
gtklogger.adoptGObject(self.layerListView.get_selection(),
self.layerListView,
access_method=self.layerListView.get_selection)
self.selsignal = gtklogger.connect(self.layerListView.get_selection(),
'changed', self.selectionChangedCB)
gtklogger.connect(self.layerListView, 'row-activated',
self.layerDoubleClickCB)
def _application_window_create(self):
application_window = gtk.VBox()
#application_window.move(0, 0)
#application_window.set_default_size(700, -1)
#gtk.window_set_default_icon_from_file(join(pixmaps_dir,
# 'gazpacho-icon.png'))
#application_window.connect('delete-event', self._delete_event)
# Create the different widgets
menubar = self._construct_menu_and_toolbar(application_window)
self._palette = MiniPalette(self.cb, self._catalogs)
self._palette.connect('toggled', self._palette_button_clicked)
ebox = gtk.VBox()
self.editor_combo = gtk.combo_box_new_text()
ebox.pack_start(self.editor_combo, expand=False)
self._editor = editor.Editor(self)
self._editor.set_show_tabs(False)
ebox.pack_start(self._editor)
for i in range(self._editor.get_n_pages()):
page = self._editor.get_nth_page(i)
label = self._editor.get_tab_label_text(page)
self.editor_combo.append_text(label)
self.editor_combo.set_active(0)
self.editor_combo.connect('changed', self.cb_editor_selected)
widget_view = self._widget_tree_view_create()
self.gactions_view = self._gactions_view_create()
self._statusbar = self._construct_statusbar()
# Layout them on the window
main_vbox = gtk.VBox()
application_window.add(main_vbox)
top_box = gtk.HBox()
main_vbox.pack_start(top_box, expand=False)
#top_box.pack_start(toolbar)
#top_box.pack_start(menubar, False)
self.menu = menubar
hbox = gtk.VBox(spacing=6)
self.selector_image = gtk.Image()
self.selector_image.set_from_file(os.path.join(pixmaps_dir, 'selector.png'))
self.expander_label = ExpanderLabel(self.cb, self.selector_image)
#hbox.pack_start(self.expander_label, expand=False)
hbox2 = gtk.HBox()
hbox.pack_start(hbox2, expand=False)
self._palette_expander = gtk.Expander()
self._palette_expander.set_label_widget(self.expander_label)
self._palette_expander.add(self._palette)
hbox2.pack_start(self._palette_expander)
self.selector = self._palette._selector
#self.selector.set_mode(False)
#self.selector.set_active(True)
#self.selector.set_relief(gtk.RELIEF_NONE)
#self.selector.add(get_resized_image_copy(self.selector_image, 14))
#self.selector.connect('toggled', self.cb_selector)
hbox2.pack_start(self.selector, expand=False)
vpaned = gtk.VPaned()
hbox.pack_start(vpaned, True, True)
notebook = gtk.Notebook()
notebook.append_page(widget_view, gtk.Label(('Widgets')))
notebook.append_page(self.gactions_view, gtk.Label(('Actions')))
notebook.set_size_request(200, -1)
#vpaned.set_position(200)
vpaned.pack1(notebook, True, True)
vpaned.pack2(ebox, True, True)
self._editor.set_size_request(200, -1)
main_vbox.pack_start(hbox)
#main_vbox.pack_end(self._statusbar, False)
#self.refresh_undo_and_redo()
self._editor._load_signal_page()
self.signals_list = self._editor._signal_editor._signals_list
self.signals_list.connect('row-activated', self.cb_signal_activated)
return application_window
def __init__(self):
self.views = (Views.ViewContainer(), Views.ViewContainer())
self.status = Views.StatusMonitor()
self.needDiff = True
self.diffMatches = {}
self.status.completionCallbacks.append(self.loadingFinished)
# Two scrolling columns for our transaction lists,
# with one non-scrolled column in the middle for our diff markers.
# Everything scrolls vertically in unison.
listScroll = Views.ScrollContainer(hAxes=(True, False, True))
self.diffStatus = DiffStatusColumn()
self.diffStatus.view.set_size_request(20, 1)
self.diffStatus.view.set_vadjustment(listScroll.vAdjust[0])
frame = gtk.Frame()
frame.add(self.diffStatus.view)
listScroll.add(frame, 1, 0, 0)
timingBox = gtk.VBox(True)
paned = gtk.VPaned()
if Views.gnomecanvas:
paned.add1(timingBox)
paned.add2(listScroll)
paned.set_position(250)
self.events = {}
self.summaries = {}
transactionLists = []
for i, view in (
(0, self.views[0]),
(2, self.views[1]),
):
self.events[view] = []
self.summaries[view] = []
tlist = Views.TransactionList(view)
transactionLists.append(tlist)
tlist.view.set_hadjustment(listScroll.hAdjust[i])
tlist.view.set_vadjustment(listScroll.vAdjust[0])
tlist.root.set_size_request(1, 1)
listScroll.attachEvent(tlist.root)
frame = gtk.Frame()
frame.add(tlist.root)
listScroll.add(frame, i)
Views.TransactionDetailWindow(view).connectToList(tlist.view)
timing = Views.TimingDiagram(view)
self.status.watchCursor(timing.cursor)
timingBox.pack_start(timing.root)
# When a transaction is hilighted in one view,
# try to find a matching transaction in the other view
view.hilight.observers.append(self.matchHilights)
transactionLists[0].diffPartner = transactionLists[1]
transactionLists[1].diffPartner = transactionLists[0]
mainvbox = gtk.VBox(False)
mainvbox.pack_start(paned, True)
mainvbox.pack_start(self.status.statusbar, False)
self.window = gtk.Window()
self.window.set_default_size(1200, 900)
self.window.add(mainvbox)
self.window.show_all()
gtk.widget_set_default_direction(gtk.TEXT_DIR_LTR)
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_default_size(400, 200)
window.connect("destroy", lambda q: gtk.main_quit())
hbox = gtk.HBox(homogeneous=False, spacing=5)
window.add(hbox)
hpane = gtk.HPaned()
hbox.pack_start(hpane, True, True, 0)
label = gtk.Label("HPane Left")
hpane.add1(label)
label = gtk.Label("HPane Right")
hpane.add2(label)
vpane = gtk.VPaned()
hbox.pack_start(vpane, True, True, 0)
label = gtk.Label("VPane Top")
vpane.add1(label)
label = gtk.Label("VPane Bottom")
vpane.add2(label)
window.show_all()
gtk.main()
def __init__(self, plugin=None, quit_cb=None):
gtk.EventBox.__init__(self)
self.search_string = None
self.last_search_iter = None
self.completion_win = None
self.insert_string = None
self.cursor_iter = None
self.plugin = plugin
self.wins = []
self.current_word = ""
self.wl = []
self.ac_w = None
self.set_size_request(470, 300)
self.connect("delete_event", self.file_exit)
self.quit_cb = quit_cb
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.show()
self.menubar, self.toolbar = self.create_menu()
hdlbox = gtk.HandleBox()
self.vbox.pack_start(hdlbox, expand=False)
hdlbox.show()
hdlbox.add(self.menubar)
self.menubar.show()
hdlbox = gtk.HandleBox()
self.vbox.pack_start(hdlbox, expand=False)
hdlbox.show()
hdlbox.add(self.toolbar)
self.toolbar.show()
self.vpaned = gtk.VPaned()
self.vbox.pack_start(self.vpaned, expand=True, fill=True)
self.vpaned.show()
self.vbox1 = gtk.VBox()
self.vpaned.add1(self.vbox1)
self.vbox.show()
self.vbox1.show()
self.hpaned = gtk.HPaned()
self.vbox1.pack_start(self.hpaned, True, True)
self.hpaned.set_border_width(5)
self.hpaned.show()
# the gtksourceview
lm = gtksourceview.SourceLanguagesManager()
buff = CulebraBuffer()
self.new = True
buff.set_data('languages-manager', lm)
# self.editor = gtksourceview.SourceView(buff)
self.editor = CulebraView(buff)
self.plugin.pida.mainwindow.connect('delete-event', self.file_exit)
font_desc = pango.FontDescription('monospace 10')
if font_desc:
self.editor.modify_font(font_desc)
buff.connect('insert-text', self.insert_at_cursor_cb)
buff.set_data("save", False)
manager = buff.get_data('languages-manager')
language = manager.get_language_from_mime_type("text/x-python")
buff.set_highlight(True)
buff.set_language(language)
scrolledwin2 = gtk.ScrolledWindow()
scrolledwin2.add(self.editor)
self.editor.set_auto_indent(True)
self.editor.set_show_line_numbers(True)
self.editor.set_show_line_markers(True)
self.editor.set_tabs_width(4)
self.editor.connect('key-press-event', self.text_key_press_event_cb)
self.editor.connect('move-cursor', self.move_cursor)
self.editor.set_margin(80)
self.editor.set_show_margin(True)
self.editor.set_smart_home_end(True)
self.editor.set_highlight_current_line(True)
scrolledwin2.show()
self.editor.show()
self.editor.grab_focus()
buff.set_data('filename', "untitled.py")
self.wins.append([buff, "untitled.py"])
self.current_buffer = 0
self.hpaned.add2(scrolledwin2)
self.hpaned.set_position(200)
self.dirty = 0
self.clipboard = gtk.Clipboard(selection='CLIPBOARD')
self.dirname = "."
# sorry, ugly
self.filetypes = {}
return
def __init__(self, app, main_window, viewerid=None):
Viewer.__init__(self, app, main_window, viewerid,
viewer_name="three_pane_viewer")
self._ui_ready = False
# node selections
self._current_page = None # current page in editor
self._treeview_sel_nodes = [] # current selected nodes in treeview
self._queue_list_select = [] # nodes to select in listview after
# treeview change
self._new_page_occurred = False
self.back_button = None
self._view_mode = DEFAULT_VIEW_MODE
self.connect("history-changed", self._on_history_changed)
#=========================================
# widgets
# treeview
self.treeview = KeepNoteTreeView()
self.treeview.set_get_node(self._app.get_node)
self.treeview.connect("select-nodes", self._on_tree_select)
self.treeview.connect("delete-node", self.on_delete_node)
self.treeview.connect("error", lambda w, t, e:
self.emit("error", t, e))
self.treeview.connect("edit-node", self._on_edit_node)
self.treeview.connect("goto-node", self.on_goto_node)
self.treeview.connect("activate-node", self.on_activate_node)
self.treeview.connect("drop-file", self._on_attach_file)
# listview
self.listview = KeepNoteListView()
self.listview.set_get_node(self._app.get_node)
self.listview.connect("select-nodes", self._on_list_select)
self.listview.connect("delete-node", self.on_delete_node)
self.listview.connect("goto-node", self.on_goto_node)
self.listview.connect("activate-node", self.on_activate_node)
self.listview.connect("goto-parent-node",
lambda w: self.on_goto_parent_node())
self.listview.connect("error", lambda w, t, e:
self.emit("error", t, e))
self.listview.connect("edit-node", self._on_edit_node)
self.listview.connect("drop-file", self._on_attach_file)
self.listview.on_status = self.set_status # TODO: clean up
# editor
#self.editor = KeepNoteEditor(self._app)
#self.editor = RichTextEditor(self._app)
self.editor = ContentEditor(self._app)
rich_editor = RichTextEditor(self._app)
self.editor.add_editor("text/xhtml+xml", rich_editor)
self.editor.add_editor("text", TextEditor(self._app))
self.editor.set_default_editor(rich_editor)
self.editor.connect("view-node", self._on_editor_view_node)
self.editor.connect("child-activated", self._on_child_activated)
self.editor.connect("visit-node", lambda w, n:
self.goto_node(n, False))
self.editor.connect("error", lambda w, t, e: self.emit("error", t, e))
self.editor.connect("window-request", lambda w, t:
self.emit("window-request", t))
self.editor.view_nodes([])
self.editor_pane = gtk.VBox(False, 5)
self.editor_pane.pack_start(self.editor, True, True, 0)
#=====================================
# layout
# TODO: make sure to add underscore for these variables
# create a horizontal paned widget
self.hpaned = gtk.HPaned()
self.pack_start(self.hpaned, True, True, 0)
self.hpaned.set_position(DEFAULT_HSASH_POS)
# layout major widgets
self.paned2 = gtk.VPaned()
self.hpaned.add2(self.paned2)
self.paned2.set_position(DEFAULT_VSASH_POS)
# treeview and scrollbars
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(self.treeview)
self.hpaned.add1(sw)
# listview with scrollbars
self.listview_sw = gtk.ScrolledWindow()
self.listview_sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.listview_sw.set_shadow_type(gtk.SHADOW_IN)
self.listview_sw.add(self.listview)
self.paned2.add1(self.listview_sw)
#self.paned2.child_set_property(self.listview_sw, "shrink", True)
# layout editor
self.paned2.add2(self.editor_pane)
self.treeview.grab_focus()
def create(self):
self.connect("destroy", self.destroy_cb)
ClientUtil.add_updater(self)
self.catch_event("no_credits")
def on_launched(button):
self.start()
self._start_listening_for_event("launched", self.app, on_launched)
self.popupMenu = TorrentPopupMenu(self)
#everything changes in relation to this magic number
maggicPadding = 2
self.statusRow = BTUtilityStatusRow(self.app, maggicPadding)
self.buttonRow = BTUtilityButtonRow(self.app, maggicPadding)
self._start_listening_for_event("add_file", self.buttonRow,
self._add_file_cb)
self._start_listening_for_event("remove_file", self.buttonRow,
self._remove_file_cb)
self._start_listening_for_event("pause_torrent", self.buttonRow,
self._pause_cb)
self._start_listening_for_event("toggle_anonymity", self.buttonRow,
self._toggle_anon_cb)
self.rows = {}
self.curDownload = None
self.exitDialog = None
self.trackerEditDialog = None
#create a liststore with one string column to use as the model
#COLUMNS:
#0: File name
typeList = [
gobject.TYPE_STRING,
#1: Amount done
gobject.TYPE_FLOAT,
#2: Status
gobject.TYPE_STRING,
#3: ETA
gobject.TYPE_STRING,
#4: Peers
gobject.TYPE_STRING,
#5: Seeds
gobject.TYPE_STRING,
#6: Download Rate
gobject.TYPE_STRING,
#7: Upload Rate
gobject.TYPE_STRING,
#8: Download Amount
gobject.TYPE_STRING,
#9: Upload Amount
gobject.TYPE_STRING,
#10: Upload Amount
gobject.TYPE_STRING,
#11: the hash for the download. Stored hex-encoded, because nulls mess up gtk
gobject.TYPE_STRING,
#12: is the row visible?
gobject.TYPE_BOOLEAN
]
self.attrIdx = {}
self.attrIdx["name"] = 0
self.attrIdx["progress"] = 1
self.attrIdx["progressMsg"] = 2
self.attrIdx["status"] = 3
self.attrIdx["peers"] = 4
self.attrIdx["seeds"] = 5
self.attrIdx["rateUp"] = 6
self.attrIdx["rateDown"] = 7
self.attrIdx["amountUp"] = 8
self.attrIdx["amountDown"] = 9
self.attrIdx["copies"] = 10
self.attrIdx["hash"] = 11
self.attrIdx["visibility"] = 12
self.liststore = gtk.ListStore(*typeList)
COLUMN_NAMES = [
"Name", "Progress", "Time Left", "Peers", "Seeds", "Down Rate",
"Up Rate", "Down Amt", "Up Amt", "Copies"
]
modelfilter, treeview = GTKUtils.make_listview(self.liststore,
COLUMN_NAMES)
GTKUtils.make_text_cell(treeview.columns[0], 0)
GTKUtils.make_progress_cell(treeview.columns[1], 1, 2)
for i in range(2, len(COLUMN_NAMES)):
GTKUtils.make_text_cell(treeview.columns[i], i + 1)
#make treeview searchable
treeview.set_search_column(0)
#attach the filtermodel and treeview
treeview.set_model(gtk.TreeModelSort(modelfilter))
treeview.connect("cursor-changed", self.row_change_cb)
treeview.connect("button-press-event", self.button_press_cb)
treeview.connect("button-press-event", self.button_press_cb)
# treeview.set_size_request(-1, 30)
treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.treeview, self.modelfilter = treeview, modelfilter
self.modelfilter.set_visible_func(self.visible_cb)
topBox = gtk.VBox()
topBox.pack_start(self.buttonRow, False, False, 0)
scrolledTorrentsBox = GTKUtils.make_scroll_box(
treeview,
hPolicy=gtk.POLICY_AUTOMATIC,
vPolicy=gtk.POLICY_AUTOMATIC)
scrolledTorrentsBoxAlign = gtk.Alignment(0, 0, 1, 1)
scrolledTorrentsBoxAlign.set_padding(0, maggicPadding, maggicPadding,
maggicPadding)
scrolledTorrentsBoxAlign.add(scrolledTorrentsBox)
topBox.pack_start(scrolledTorrentsBoxAlign, True, True, 0)
self.priorityBox = gtk.HBox()
self.priorityBox.pack_start(
gtk.Label("Select a torrent to set the priority for its files."),
True, True, 0)
self.priorityBox.set_border_width(0)
self.peerBox = gtk.HBox()
self.peerBox.pack_start(
gtk.Label("Select a torrent to see your peers in the swarm."),
True, True, 0)
self.bwGraph = BWGraph.BWGraph(self.app, root=self)
self.bwGraph.container.set_size_request(-1, 150)
self.notebook = ClosableTabNotebook.ClosableTabNotebook()
self.notebook.set_show_border(True)
self.notebook.set_border_width(0)
self.bwGraph.label = gtk.Label("BitTorrent Traffic")
self.priorityBox.label = gtk.Label("Priorities")
self.priorityBox.container = self.priorityBox
self.peerBox.label = gtk.Label("Peers")
self.peerBox.container = self.peerBox
self.notebook.show_display(self.bwGraph)
self.notebook.show_display(self.priorityBox)
self.notebook.show_display(self.peerBox)
self.notebook.show_display(self.bwGraph)
alignBottom = gtk.Alignment(0, 0, 1, 1)
alignBottom.set_padding(0, maggicPadding + 3, maggicPadding + 2,
maggicPadding + 2)
alignBottom.add(self.notebook)
vBoxBottom = gtk.VBox()
vBoxBottom.pack_start(alignBottom, True, True, 0)
vBoxBottom.pack_end(self.statusRow, False, False, 0)
vpane = gtk.VPaned()
self.menuBar = BitTorrentMenuBar(self.controller, self)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_OUT)
frame.add(topBox)
alignTop = gtk.Alignment(1, 1, 1, 1)
alignTop.set_padding(10, 0, maggicPadding + 3, maggicPadding + 3)
alignTop.add(frame)
topContainer = gtk.VBox()
topContainer.pack_start(self.menuBar.create_menus(), False, False, 0)
topContainer.pack_start(alignTop, True, True, 0)
vpane.pack1(topContainer, resize=True, shrink=False)
vpane.pack2(vBoxBottom, resize=False, shrink=False)
self.label = gtk.Label("")
self.label.set_markup(
"<span size='x-large' weight='bold'>Bit Twister</span>")
self.container = vpane
vpane.set_position(400)
self.add(self.container)
self.container.show_all()
def __init__(self, config, querylist, mainwin, debug=True):
self.debug = debug
self.conf = config
self.main_window = mainwin
self.sql = querylist
self.liststore = [
] # gtk.ListStore[] stores the contents of the grids
self.listcols = [
] # gtk.TreeViewColumn[][] stores the columns in the grids
self.MYSQL_INNODB = 2
self.PGSQL = 3
self.SQLITE = 4
# create new db connection to avoid conflicts with other threads
self.db = Database.Database(self.conf, sql=self.sql)
self.cursor = self.db.cursor
settings = {}
settings.update(self.conf.get_db_parameters())
settings.update(self.conf.get_import_parameters())
settings.update(self.conf.get_default_paths())
# text used on screen stored here so that it can be configured
self.filterText = {
'handhead': _('Hand Breakdown for all levels listed above')
}
filters_display = {
"Heroes": True,
"Sites": True,
"Games": True,
"Currencies": True,
"Limits": True,
"LimitSep": True,
"LimitType": True,
"Type": True,
"Seats": True,
"SeatSep": True,
"Dates": True,
"Groups": True,
"GroupsAll": True,
"Button1": True,
"Button2": True
}
self.filters = Filters.Filters(self.db,
self.conf,
self.sql,
display=filters_display)
self.filters.registerButton1Name(_("_Filters"))
self.filters.registerButton1Callback(self.showDetailFilter)
self.filters.registerButton2Name(_("_Refresh Stats"))
self.filters.registerButton2Callback(self.refreshStats)
# ToDo: store in config
# ToDo: create popup to adjust column config
# columns to display, keys match column name returned by sql, values in tuple are:
# is column displayed(summary then position), column heading, xalignment, formatting, celltype
self.columns = self.conf.get_gui_cash_stat_params()
# Detail filters: This holds the data used in the popup window, extra values are
# added at the end of these lists during processing
# sql test, screen description, min, max
self.handtests = [ # already in filter class : ['h.seats', 'Number of Players', 2, 10]
['h.maxSeats', 'Size of Table', 2, 10],
['h.playersVpi', 'Players who VPI', 0, 10],
['h.playersAtStreet1', 'Players at Flop', 0, 10],
['h.playersAtStreet2', 'Players at Turn', 0, 10],
['h.playersAtStreet3', 'Players at River', 0, 10],
['h.playersAtStreet4', 'Players at Street7', 0, 10],
['h.playersAtShowdown', 'Players at Showdown', 0, 10],
['h.street0Raises', 'Bets to See Flop', 0, 5],
['h.street1Raises', 'Bets to See Turn', 0, 5],
['h.street2Raises', 'Bets to See River', 0, 5],
['h.street3Raises', 'Bets to See Street7', 0, 5],
['h.street4Raises', 'Bets to See Showdown', 0, 5]
]
self.cardstests = [
[Card.DATABASE_FILTERS['pair'],
_('Pocket pairs')],
[Card.DATABASE_FILTERS['suited'],
_('Suited')],
[
Card.DATABASE_FILTERS['suited_connectors'],
_('Suited connectors')
],
[Card.DATABASE_FILTERS['offsuit'],
_('Offsuit')],
[
Card.DATABASE_FILTERS['offsuit_connectors'],
_('Offsuit connectors')
],
]
self.stats_frame = None
self.stats_vbox = None
self.detailFilters = [] # the data used to enhance the sql select
self.cardsFilters = []
#self.main_hbox = gtk.HBox(False, 0)
#self.main_hbox.show()
self.main_hbox = gtk.HPaned()
self.stats_frame = gtk.Frame()
self.stats_frame.show()
self.stats_vbox = gtk.VPaned()
self.stats_vbox.show()
self.stats_frame.add(self.stats_vbox)
self.top_pane_height = 0
self.height_inc = None
# self.fillStatsFrame(self.stats_vbox)
#self.main_hbox.pack_start(self.filters.get_vbox())
#self.main_hbox.pack_start(self.stats_frame, expand=True, fill=True)
self.main_hbox.pack1(self.filters.get_vbox())
self.main_hbox.pack2(self.stats_frame)
self.main_hbox.show()
# Make sure Hand column is not displayed.
hand_column = (x for x in self.columns if x[0] == 'hand').next()
hand_column[colshowsumm] = hand_column[colshowposn] = False
# If rfi and steal both on for summaries, turn rfi off.
rfi_column = (x for x in self.columns if x[0] == 'rfi').next()
steals_column = (x for x in self.columns if x[0] == 'steals').next()
if rfi_column[colshowsumm] and steals_column[colshowsumm]:
rfi_column[colshowsumm] = False
# If rfi and steal both on for position breakdowns, turn steals off.
if rfi_column[colshowposn] and steals_column[colshowposn]:
steals_column[colshowposn] = False
self.last_pos = -1
def __init__(self, user, server, window):
self.att_filelist = []
self.user = user
self.server = server
self.window = window
self.window.set_size_request(800, 600)
self.vbox = gtk.VBox(False, 2)
self.vbox.set_size_request(800, 600)
self.hbox = gtk.HBox(False, 2)
self.hbox.set_size_request(800, 50)
self.vbox.pack_start(self.hbox, False, False, 2)
self.vbox.show()
self.vpaned = gtk.VPaned()
self.vbox.add(self.vpaned)
self.label = gtk.Label(user)
self.vpaned.add1(self.label)
self.label.show()
self.panedbox = gtk.HBox(False, 2)
self.vpaned.add2(self.panedbox)
self.panedbox.show()
button = gtk.Button('Quit')
button.set_size_request(100, 50)
button.connect('clicked', self.quit)
self.hbox.pack_end(button, False, False, 2)
button.show()
self.window.add(self.vbox)
self.pvbox = gtk.VBox(False, 0)
self.panedbox.add(self.pvbox)
self.pvbox.show()
self.hBox1 = gtk.HBox()
self.hBox1.set_size_request(800, 100)
self.hBox1.show()
self.pvbox.pack_start(self.hBox1, False, False, 0)
self.vBox1 = gtk.VBox()
self.vBox1.set_size_request(80, 100)
self.vBox1.show()
self.hBox1.pack_start(self.vBox1, False, False, 0)
self.fromaddr_label = gtk.Label('From')
self.fromaddr_label.show()
self.vBox1.pack_start(self.fromaddr_label, False, False, 5)
self.vBox2 = gtk.VBox()
self.vBox2.set_size_request(700, 100)
self.vBox2.show()
self.hBox1.pack_start(self.vBox2, False, False, 5)
self.fromaddr_entry = gtk.Entry()
self.fromaddr_entry.set_max_length(30)
self.vBox2.pack_start(self.fromaddr_entry, False, False, 0)
self.fromaddr_entry.show()
self.toaddr_label = gtk.Label('To')
self.toaddr_label.show()
self.vBox1.pack_start(self.toaddr_label, False, False, 5)
self.to_entry = gtk.Entry()
self.vBox2.pack_start(self.to_entry, False, False, 0)
self.to_entry.show()
self.sub_label = gtk.Label('Subject')
self.sub_label.show()
self.vBox1.pack_start(self.sub_label, False, False, 5)
self.sub_entry = gtk.Entry()
self.sub_entry.set_max_length(30)
self.vBox2.pack_start(self.sub_entry, False, False, 0)
self.sub_entry.show()
att_file_box = gtk.EventBox()
att_file_box.set_size_request(30, 20)
self.pvbox.pack_start(att_file_box, False, False, 2)
att_file_box.show()
self.att_filelist_box_main = gtk.VBox(False, 0)
self.att_filelist_box_main.show()
self.att_filelist_box = gtk.VBox(False, 0)
self.att_filelist_box.show()
self.att_filelist_box_main.pack_start(self.att_filelist_box)
self.att_file_label = gtk.Label('Attach a file')
att_file_box.add(self.att_file_label)
self.att_file_label.show()
self.att_file_label.set_size_request(10, 20)
att_file_box.set_events(gtk.gdk.BUTTON_PRESS_MASK)
att_file_box.connect("button_press_event", self.select_file)
att_file_box.realize()
# self.att_file_box.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND1))
# Set background color to green
att_file_box.modify_bg(
gtk.STATE_NORMAL,
att_file_box.get_colormap().alloc_color("orange"))
self.pvbox.pack_start(self.att_filelist_box_main, False, False, 0)
self.sw = gtk.ScrolledWindow()
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView()
self.textbuffer = self.textview.get_buffer()
self.sw.add(self.textview)
self.sw.show()
self.textview.show()
self.pvbox.pack_start(self.sw)
self.textbuffer.set_text('')
self.send_button = gtk.Button('send')
self.send_button.set_size_request(400, 30)
self.send_button.connect('clicked', self.mailcontent)
self.pvbox.pack_end(self.send_button, False, False, 0)
self.send_button.show()
self.vpaned.show()
self.pvbox.show()
self.hbox.show()
def build_gui(self, container):
# Paned container is just to provide a way to size the graph
# to a reasonable size
box = gtk.VPaned()
container.pack_start(box, expand=True, fill=True)
# Make the histogram plot
vbox = gtk.VBox()
self.msgFont = pango.FontDescription("Monospace 10")
tw = gtk.TextView()
tw.set_wrap_mode(gtk.WRAP_NONE)
tw.set_left_margin(4)
tw.set_right_margin(4)
tw.set_editable(False)
tw.modify_font(self.msgFont)
self.tw = tw
fr = gtk.Frame(" Pixel Values ")
fr.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
fr.set_label_align(0.1, 0.5)
fr.add(tw)
fr.show_all()
vbox.pack_start(fr, padding=4, fill=True, expand=False)
box.pack1(vbox, resize=True, shrink=True)
hbox = gtk.HBox(spacing=4)
combobox = GtkHelp.combo_box_new_text()
index = 0
for i in self.sizes:
j = 1 + i * 2
name = "%dx%d" % (j, j)
combobox.insert_text(index, name)
index += 1
index = self.sizes.index(self.pixtbl_radius)
combobox.set_active(index)
combobox.sconnect('changed', self.set_cutout_size)
self.w.tooltips.set_tip(combobox, "Select size of pixel table")
hbox.pack_start(combobox, fill=False, expand=False)
# control for selecting a mark
combobox = GtkHelp.combo_box_new_text()
for tag in self.marks:
combobox.append_text(tag)
if self.mark_selected == None:
combobox.set_active(0)
else:
combobox.show_text(self.mark_selected)
combobox.sconnect("changed", self.mark_select_cb)
self.w.marks = combobox
self.w.tooltips.set_tip(combobox, "Select a mark")
hbox.pack_start(combobox, fill=False, expand=False)
btn = gtk.Button("Delete")
btn.connect('clicked', lambda w: self.clear_mark_cb())
self.w.tooltips.set_tip(btn, "Delete selected mark")
hbox.pack_start(btn, fill=False, expand=False)
btn = gtk.Button("Delete All")
btn.connect('clicked', lambda w: self.clear_all())
self.w.tooltips.set_tip(btn, "Clear all marks")
hbox.pack_start(btn, fill=False, expand=False)
btn = GtkHelp.CheckButton("Pan to mark")
btn.set_active(self.pan2mark)
btn.sconnect('toggled', self.pan2mark_cb)
self.w.tooltips.set_tip(btn, "Pan follows selected mark")
hbox.pack_start(btn, fill=False, expand=False)
vbox.pack_start(hbox, fill=True, expand=False)
btns = gtk.HButtonBox()
btns.set_layout(gtk.BUTTONBOX_START)
btns.set_spacing(3)
btns.set_child_size(15, -1)
btn = gtk.Button("Close")
btn.connect('clicked', lambda w: self.close())
btns.add(btn)
vbox.pack_start(btns, padding=4, fill=True, expand=False)
box.pack2(gtk.Label(), resize=True, shrink=True)
def __init__(self, block):
"""
Properties dialog constructor.
Args:
block: a block instance
"""
self._hash = 0
gtk.Dialog.__init__(self,
title='Properties: %s' % block.get_name(),
buttons=(gtk.STOCK_OK, gtk.RESPONSE_ACCEPT,
gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_APPLY, gtk.RESPONSE_APPLY))
self.set_response_sensitive(gtk.RESPONSE_APPLY, False)
self.set_size_request(MIN_DIALOG_WIDTH, MIN_DIALOG_HEIGHT)
self._block = block
vpaned = gtk.VPaned()
self.vbox.pack_start(vpaned)
# Notebook to hold param boxes
notebook = gtk.Notebook()
notebook.set_show_border(False)
notebook.set_scrollable(True) # scroll arrows for page tabs
notebook.set_tab_pos(gtk.POS_TOP)
vpaned.pack1(notebook, True)
# Params boxes for block parameters
self._params_boxes = list()
for tab in block.get_param_tab_labels():
label = gtk.Label()
vbox = gtk.VBox()
scroll_box = gtk.ScrolledWindow()
scroll_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll_box.add_with_viewport(vbox)
notebook.append_page(scroll_box, label)
self._params_boxes.append((tab, label, vbox))
# Docs for the block
self._docs_text_display = doc_view = SimpleTextDisplay()
doc_view.get_buffer().create_tag('b', weight=pango.WEIGHT_BOLD)
self._docs_box = gtk.ScrolledWindow()
self._docs_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._docs_box.add_with_viewport(self._docs_text_display)
notebook.append_page(self._docs_box, gtk.Label("Documentation"))
# Generated code for the block
if Actions.TOGGLE_SHOW_CODE_PREVIEW_TAB.get_active():
self._code_text_display = code_view = SimpleTextDisplay()
code_view.set_wrap_mode(gtk.WRAP_NONE)
code_view.get_buffer().create_tag('b', weight=pango.WEIGHT_BOLD)
code_view.modify_font(
pango.FontDescription('monospace %d' % FONT_SIZE))
code_box = gtk.ScrolledWindow()
code_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
code_box.add_with_viewport(self._code_text_display)
notebook.append_page(code_box, gtk.Label("Generated Code"))
else:
self._code_text_display = None
# Error Messages for the block
self._error_messages_text_display = SimpleTextDisplay()
self._error_box = gtk.ScrolledWindow()
self._error_box.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self._error_box.add_with_viewport(self._error_messages_text_display)
vpaned.pack2(self._error_box)
vpaned.set_position(int(0.65 * MIN_DIALOG_HEIGHT))
# Connect events
self.connect('key-press-event', self._handle_key_press)
self.connect('show', self.update_gui)
self.connect('response', self._handle_response)
self.show_all() # show all (performs initial gui update)
def __createGUI(self):
"""
Assembles the widgets together onto the window
"""
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title(programName)
self.window.connect("destroy", self.destroy)
self.window.connect("delete_event", self.delete_event)
self.window.connect("key-press-event", self.keyPress)
self.uimanager = gtk.UIManager()
accelGroup = self.uimanager.get_accel_group()
self.window.add_accel_group(accelGroup)
actionGroup = gtk.ActionGroup("ActionGroup")
self.paletteManager = None
# File menu
actionGroup.add_actions([
("New", gtk.STOCK_NEW, "_New", "<Control>N", "Create a new file",
self.file_new),
("Open", gtk.STOCK_OPEN, "_Open", "<Control>O", "Open a saved map",
self.file_open),
("Save", gtk.STOCK_SAVE, "_Save", "<Control>S",
"Save the current file", self.file_save),
("SaveAs", gtk.STOCK_SAVE_AS, "Save _As...", "<Control><Shift>S",
"Save the current file under a different name", self.file_saveAs),
("Properties", gtk.STOCK_PROPERTIES, "Properties", "<Alt>Return",
"Modify the properties of the map", self.file_properties),
("Close", gtk.STOCK_CLOSE, "_Close", "<Control>W",
"Close the current file", self.file_close),
("Quit", gtk.STOCK_QUIT, "_Quit", "<Control>Q", "Quit the program",
self.file_quit),
("File", None, "_File"),
("Edit", None, "_Edit"),
("View", None, "_View"),
("Help", None, "_Help"),
])
# Edit menu
actionGroup.add_actions([
("Resize", None, "R_esize", None, "Resize the map",
self.edit_resize),
("Preferences", gtk.STOCK_PREFERENCES, "_Preferences", None,
"Application Preferences", self.edit_preferences),
("Undo", gtk.STOCK_UNDO, "_Undo", "<Control>Z",
"Undo the last change", self.edit_undo),
("Redo", gtk.STOCK_REDO, "_Redo", "<Control>Y",
"Redo the last change", self.edit_redo),
("Background", None, "_Background", "<Control>B",
"Change background information for the map", self.edit_background)
])
# View menu
actionGroup.add_actions([
("ZoomIn", gtk.STOCK_ZOOM_IN, "Zoom _In", None, "Zoom In",
self.view_zoomIn),
("ZoomOut", gtk.STOCK_ZOOM_OUT, "Zoom _Out", None, "Zoom Out",
self.view_zoomOut),
("ZoomNormal", gtk.STOCK_ZOOM_100, "_Normal Size", "<Control>0",
"Normal Size", self.view_zoomNormal)
])
# Help menu
actionGroup.add_actions([
("About", gtk.STOCK_ABOUT, "_About", None,
"Information about the program.", self.help_about)
])
# Layer view
actionGroup.add_actions([
("addLayer", gtk.STOCK_NEW, None, None,
"Add a new layer to the map", self.addLayer),
("removeLayer", gtk.STOCK_DELETE, None, None,
"Remove the current layer from the map", self.removeLayer),
("raiseLayer", gtk.STOCK_GO_UP, None, None,
"Raise the current layer", self.raiseLayer),
("lowerLayer", gtk.STOCK_GO_DOWN, None, None,
"Lower the current layer", self.lowerLayer)
])
actionGroup.add_toggle_actions([
("ToggleGridMap", None, "Show Grid on _Map", "<Control>G",
"Show a grid overlaid on the map", self.view_toggleGridMap),
("ToggleGridPalette", None, "Show Grid on _Palette",
"<Control><Shift>G", "Show a grid overlaid on the tile palette",
self.view_toggleGridPalette),
("ToggleToolbar", None, "Show _Toolbar", None, "Show the toolbar",
self.view_toggleToolbar)
])
# Side toolbar
actionGroup.add_radio_actions(
[("TileDraw", None, None, "<Control>T", "Draw tiles on the map",
editortools.TILE_DRAW_ID),
("TileDelete", None, None, "<Contorol><Shift>T",
"Remove tiles " + "from the map", editortools.TILE_DELETE_ID),
("PhysicsSelect", None, None, "<Control>P",
"Select and edit shapes", editortools.PHYSICS_SELECT_ID),
("PolygonDraw", None, None, "<Control>P",
"Draw polygons" + " on the map", editortools.POLYGON_DRAW_ID),
("CircleDraw", None, None, "<Control>C",
"Draw circles" + " on the map", editortools.CIRCLE_DRAW_ID),
("LightDraw", None, None, None, "Place lights on the map",
editortools.LIGHT_DRAW_ID)], editortools.TILE_DRAW_ID,
self.toolSelect)
self.uimanager.insert_action_group(actionGroup, 0)
self.uimanager.add_ui_from_string(uiString)
self.widgets = [
"/MenuBar/File/Properties", "/MenuBar/File/Save",
"/MenuBar/File/SaveAs", "/MenuBar/File/Close",
"/MenuBar/Edit/Undo", "/MenuBar/Edit/Redo", "/MenuBar/Edit/Resize",
"/MenuBar/Edit/Background", "/MenuBar/View/ToggleGridMap",
"/MenuBar/View/ToggleGridPalette", "/MenuBar/View/ZoomIn",
"/MenuBar/View/ZoomOut", "/MenuBar/View/ZoomNormal",
"/MainBar/Save", "/MainBar/SaveAs", "/MainBar/ZoomIn",
"/MainBar/ZoomOut", "/MainBar/ZoomNormal", "/MainBar/Undo",
"/MainBar/Redo", "/MapTools", "/Layers"
]
# Set the check box correctly
self.uimanager.get_widget("/MenuBar/View/ToggleToolbar").set_active(
True)
self.uimanager.get_widget(
"/MenuBar/View/ToggleGridPalette").set_active(True)
vbox = gtk.VBox(False, 0)
self.window.add(vbox)
vPaned = gtk.VPaned()
self.paletteManager = tilepalette.PaletteManager(self.getController())
vPaned.pack1(self.paletteManager.getWidget(), True, False)
vPaned.pack2(self.createTreeView(), True, False)
vPaned.set_size_request(200, -1)
self.mapBox = gtk.HBox(False, 0)
self.mapBox.pack_start(self.__createToolbar(), False, False, 0)
hpaned = gtk.HPaned()
hpaned.pack1(self.mapBox, True, False)
hpaned.pack2(vPaned, False, False)
vbox.pack_start(self.uimanager.get_widget("/MenuBar"), False, False, 0)
vbox.pack_start(self.uimanager.get_widget("/MainBar"), False, False, 0)
self.statusBar = gtk.Statusbar()
id = self.statusBar.get_context_id("Main Window")
self.statusBar.push(
id,
"Open an existing file (Control+O) or create a new one (Control+N)"
)
vbox.pack_end(self.statusBar, False, False, 0)
vbox.pack_end(hpaned, True, True, 2)
self.__setWidgetsInsensitive()
self.window.set_size_request(900, 540)
self.setTitle()
self.window.show_all()
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(
self,
name="FE Mesh",
ordering=200,
tip="Create a Finite Element Mesh from a Skeleton.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
# Centered box of buttons
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
bbox = gtk.HBox(homogeneous=1, spacing=3)
align.add(bbox)
self.newbutton = gtkutils.StockButton(gtk.STOCK_NEW, "New...")
gtklogger.setWidgetName(self.newbutton, 'New')
gtklogger.connect(self.newbutton, 'clicked', self.newCB)
tooltips.set_tooltip_text(
self.newbutton, "Create a new mesh from the current skeleton.")
bbox.pack_start(self.newbutton, expand=0, fill=1)
self.renamebutton = gtkutils.StockButton(gtk.STOCK_EDIT, "Rename...")
gtklogger.setWidgetName(self.renamebutton, 'Rename')
gtklogger.connect(self.renamebutton, 'clicked', self.renameCB)
tooltips.set_tooltip_text(self.renamebutton,
"Rename the current mesh.")
bbox.pack_start(self.renamebutton, expand=0, fill=1)
self.copybutton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.copybutton, 'Copy')
gtklogger.connect(self.copybutton, 'clicked', self.copyCB)
tooltips.set_tooltip_text(self.copybutton, "Copy the current mesh.")
bbox.pack_start(self.copybutton, expand=0, fill=1)
self.deletebutton = gtkutils.StockButton(gtk.STOCK_DELETE, "Delete")
gtklogger.setWidgetName(self.deletebutton, 'Delete')
gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB)
tooltips.set_tooltip_text(self.deletebutton,
"Delete the current mesh.")
bbox.pack_start(self.deletebutton, expand=0, fill=1)
self.savebutton = gtkutils.StockButton(gtk.STOCK_SAVE, "Save...")
gtklogger.setWidgetName(self.savebutton, 'Save')
gtklogger.connect(self.savebutton, 'clicked', self.saveCB)
tooltips.set_tooltip_text(self.savebutton,
"Save the current mesh to a file.")
bbox.pack_start(self.savebutton, expand=0, fill=1)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
leftbox = gtk.VPaned()
mainpane.pack1(leftbox, resize=1, shrink=0)
infoframe = gtk.Frame('Mesh Information')
infoframe.set_shadow_type(gtk.SHADOW_IN)
leftbox.pack1(infoframe, resize=1, shrink=1)
scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(scroll, "MeshInfo")
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
infoframe.add(scroll)
self.infoarea = fixedwidthtext.FixedWidthTextView()
gtklogger.setWidgetName(self.infoarea, 'info')
self.infoarea.set_cursor_visible(False)
self.infoarea.set_editable(False)
scroll.add(self.infoarea)
###
## Subproblem creation, deletion, etc.
#subprobframe = gtk.Frame('Subproblems')
#gtklogger.setWidgetName(subprobframe, 'Subproblems')
#subprobframe.set_shadow_type(gtk.SHADOW_IN)
#leftbox.pack2(subprobframe, resize=1, shrink=1)
#subpbox = gtk.VBox()
#subprobframe.add(subpbox)
#self.subpchooser = chooser.ScrolledChooserListWidget(
#callback=self.subpchooserCB,
#dbcallback=self.subprobEditCB,
#name="subprobChooser")
#subpbox.pack_start(self.subpchooser.gtk, expand=1, fill=1)
#subpbuttons1 = gtk.HBox(homogeneous=True, spacing=2)
#subpbuttons2 = gtk.HBox(homogeneous=True, spacing=2)
#subpbox.pack_start(subpbuttons1, expand=0, fill=0)
#subpbox.pack_start(subpbuttons2, expand=0, fill=0)
# Subproblem creation, deletion, etc.
subprobframe = gtk.Frame('Subproblems')
gtklogger.setWidgetName(subprobframe, 'Subproblems')
subprobframe.set_shadow_type(gtk.SHADOW_IN)
leftbox.pack2(subprobframe, resize=1, shrink=1)
subpbox = gtk.VBox()
subprobframe.add(subpbox)
innerframe = gtk.Frame()
innerframe.set_shadow_type(gtk.SHADOW_IN)
subpbox.pack_start(innerframe, expand=1, fill=1)
self.subpScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.subpScroll, "SubproblemScroll")
self.subpScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
innerframe.add(self.subpScroll)
self.subprobList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.subpListView = gtk.TreeView(self.subprobList)
gtklogger.setWidgetName(self.subpListView, "SubproblemList")
self.subpScroll.add(self.subpListView)
gtklogger.adoptGObject(self.subprobList,
self.subpListView,
access_method=self.subpListView.get_model)
# Catch selection changes
gtklogger.adoptGObject(self.subpListView.get_selection(),
self.subpListView,
access_method=self.subpListView.get_selection)
self.subpselsig = gtklogger.connect(self.subpListView.get_selection(),
'changed', self.subpSelectCB)
# Catch double clicks or returns
gtklogger.connect(self.subpListView, 'row-activated',
self.subprobEditCB)
# Subproblem name in the column 1
namecell = gtk.CellRendererText()
namecol = gtk.TreeViewColumn("Subproblem")
namecol.set_resizable(True)
namecol.pack_start(namecell, expand=True)
namecol.set_cell_data_func(namecell, self.renderSubproblemName)
self.subpListView.append_column(namecol)
# Subproblem consistency in the column 2
consistencycell = gtk.CellRendererText()
consistencycol = gtk.TreeViewColumn("Consistent?")
consistencycol.set_resizable(True)
consistencycol.pack_start(consistencycell, expand=True)
consistencycol.set_cell_data_func(consistencycell,
self.renderSubproblemConsistency)
self.subpListView.append_column(consistencycol)
# Subproblem type in the column 3
typecell = gtk.CellRendererText()
typecol = gtk.TreeViewColumn("Type")
typecol.set_resizable(True)
typecol.pack_start(typecell, expand=True)
typecol.set_cell_data_func(typecell, self.renderSubproblemType)
self.subpListView.append_column(typecol)
# Buttons at the bottom of the subproblem pane
subpbuttons1 = gtk.HBox(homogeneous=True, spacing=2)
subpbuttons2 = gtk.HBox(homogeneous=True, spacing=2)
subpbox.pack_start(subpbuttons1, expand=0, fill=0)
subpbox.pack_start(subpbuttons2, expand=0, fill=0)
###
self.subprobNew = gtkutils.StockButton(gtk.STOCK_NEW, "New...")
gtklogger.setWidgetName(self.subprobNew, "New")
gtklogger.connect(self.subprobNew, "clicked", self.subprobNewCB)
tooltips.set_tooltip_text(self.subprobNew, "Create a new subproblem.")
subpbuttons1.pack_start(self.subprobNew, expand=1, fill=1)
self.subprobRename = gtk.Button("Rename...")
gtklogger.setWidgetName(self.subprobRename, "Rename")
gtklogger.connect(self.subprobRename, "clicked", self.subprobRenameCB)
tooltips.set_tooltip_text(self.subprobRename,
"Rename the selected subproblem")
subpbuttons1.pack_start(self.subprobRename, expand=1, fill=1)
self.subprobEdit = gtkutils.StockButton(gtk.STOCK_EDIT, "Edit...")
gtklogger.setWidgetName(self.subprobEdit, "Edit")
gtklogger.connect(self.subprobEdit, 'clicked', self.subprobEditCB)
tooltips.set_tooltip_text(self.subprobEdit,
"Edit the selected subproblem.")
subpbuttons1.pack_start(self.subprobEdit, expand=1, fill=1)
self.subprobCopy = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.subprobCopy, "Copy")
gtklogger.connect(self.subprobCopy, "clicked", self.subprobCopyCB)
tooltips.set_tooltip_text(self.subprobCopy,
"Copy the selected subproblem.")
subpbuttons2.pack_start(self.subprobCopy, expand=1, fill=1)
## subpbuttons2.pack_start(gtk.HBox(), expand=1, fill=1) # filler
self.subprobInfo = gtk.Button("Info")
gtklogger.setWidgetName(self.subprobInfo, "Info")
gtklogger.connect(self.subprobInfo, 'clicked', self.subprobInfoCB)
tooltips.set_tooltip_text(
self.subprobInfo,
"Print information about the selected subproblem")
subpbuttons2.pack_start(self.subprobInfo, expand=1, fill=1)
self.subprobDelete = gtkutils.StockButton(gtk.STOCK_DELETE, "Delete")
gtklogger.setWidgetName(self.subprobDelete, "Delete")
gtklogger.connect(self.subprobDelete, "clicked", self.subprobDeleteCB)
tooltips.set_tooltip_text(self.subprobDelete,
"Delete the selected subproblem.")
subpbuttons2.pack_start(self.subprobDelete, expand=1, fill=1)
# Right hand side for element operations
elementopsframe = gtk.Frame(label="Mesh Operations")
gtklogger.setWidgetName(elementopsframe, 'ElementOps')
elementopsframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(elementopsframe, resize=0, shrink=0)
elementopsbox = gtk.VBox(spacing=3)
elementopsframe.add(elementopsbox)
self.elementops = regclassfactory.RegisteredClassFactory(
meshmod.MeshModification.registry,
title="Method:",
callback=self.elementopsCB,
expand=0,
fill=0,
scope=self,
name="Method")
elementopsbox.pack_start(self.elementops.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.elementops.set,
self.sensitizeHistory,
setCBkwargs={'interactive': 1})
# Prev, OK, Next
hbox = gtk.HBox()
elementopsbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevbutton = gtkutils.prevButton()
gtklogger.connect(self.prevbutton, 'clicked', self.prevCB)
tooltips.set_tooltip_text(
self.prevbutton, "Recall the previous mesh element operation.")
hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
gtklogger.setWidgetName(self.okbutton, 'OK')
gtklogger.connect(self.okbutton, 'clicked', self.okCB)
tooltips.set_tooltip_text(self.okbutton,
'Perform the mesh operation defined above.')
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=5)
self.nextbutton = gtkutils.nextButton()
gtklogger.connect(self.nextbutton, 'clicked', self.nextCB)
tooltips.set_tooltip_text(self.nextbutton,
'Recall the next mesh element operation.')
hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
self.built = True
# lastStatus is used to prevent update_info() from being
# called when a nominal status change hasn't really changed
# anything.
self.lastStatus = None
switchboard.requestCallbackMain("Mesh modified", self.recordModifier)
switchboard.requestCallbackMain("mesh changed", self.meshchangeCB)
switchboard.requestCallbackMain(("new who", "Microstructure"),
self.newMSorSkeleton)
switchboard.requestCallbackMain(("new who", "Skeleton"),
self.newMSorSkeleton)
switchboard.requestCallbackMain(("new who", "Mesh"), self.newMesh)
switchboard.requestCallbackMain(("new who", "SubProblem"),
self.newSubProblem)
switchboard.requestCallbackMain(("rename who", "SubProblem"),
self.renamedSubProblem)
switchboard.requestCallbackMain(("remove who", "SubProblem"),
self.removeSubProblem)
switchboard.requestCallbackMain(self.meshwidget, self.meshwidgetCB)
switchboard.requestCallbackMain("equation activated", self.equationCB)
switchboard.requestCallbackMain("mesh status changed",
self.statusChanged)
# switchboard.requestCallbackMain("mesh boundaries changed",
# self.newMeshBoundaries)
switchboard.requestCallbackMain(('validity', self.elementops),
self.validityChangeCB)
def __init__(self, lc):
self.lc = lc
self.stdout_maxlines = 2000
self.config_filename = None
self.next_cmds_update_time = 0
# create sheriff and subscribe to events
self.sheriff = sheriff.Sheriff(self.lc)
self.sheriff.connect("command-added", self._on_sheriff_command_added)
self.sheriff.connect("command-removed",
self._on_sheriff_command_removed)
self.sheriff.connect("command-status-changed",
self._on_sheriff_command_status_changed)
self.sheriff.connect("command-group-changed",
self._on_sheriff_command_group_changed)
gobject.timeout_add(1000, self._maybe_send_orders)
self.group_row_references = {}
self.lc.subscribe("PMD_PRINTF", self.on_pmsd_printf)
self.lc.subscribe("PMD_ORDERS", self.on_pmsd_orders)
# regexes
self.warn_regex = re.compile("warning", re.IGNORECASE)
self.summary_regex = re.compile("summary", re.IGNORECASE)
# setup GUI
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_default_size(800, 600)
self.window.connect("delete-event", gtk.main_quit)
self.window.connect("destroy-event", gtk.main_quit)
vbox = gtk.VBox()
self.window.add(vbox)
# keyboard accelerators. This probably isn't the right way to do it...
self.accel_group = gtk.AccelGroup()
self.accel_group.connect_group(ord("n"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, lambda *a: None)
self.accel_group.connect_group(ord("s"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, lambda *a: None)
self.accel_group.connect_group(ord("t"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, lambda *a: None)
self.accel_group.connect_group(ord("e"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, lambda *a: None)
self.accel_group.connect_group(ord("q"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, gtk.main_quit)
self.accel_group.connect_group(ord("o"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE, lambda *a: None)
self.accel_group.connect_group(
ord("a"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE,
lambda *a: self.cmds_tv.get_selection().select_all())
self.accel_group.connect_group(
ord("d"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE,
lambda *a: self.cmds_tv.get_selection().unselect_all())
# self.accel_group.connect_group (ord("a"), gtk.gdk.CONTROL_MASK,
# gtk.ACCEL_VISIBLE, self._do_save_config_dialog)
self.accel_group.connect_group(gtk.gdk.keyval_from_name("Delete"), 0,
gtk.ACCEL_VISIBLE,
self._remove_selected_commands)
self.window.add_accel_group(self.accel_group)
# setup the menu bar
menu_bar = gtk.MenuBar()
vbox.pack_start(menu_bar, False, False, 0)
file_mi = gtk.MenuItem("_File")
options_mi = gtk.MenuItem("_Options")
commands_mi = gtk.MenuItem("_Commands")
view_mi = gtk.MenuItem("_View")
# file menu
file_menu = gtk.Menu()
file_mi.set_submenu(file_menu)
self.load_cfg_mi = gtk.ImageMenuItem(gtk.STOCK_OPEN)
self.load_cfg_mi.add_accelerator("activate", self.accel_group,
ord("o"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.save_cfg_mi = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS)
quit_mi = gtk.ImageMenuItem(gtk.STOCK_QUIT)
quit_mi.add_accelerator("activate", self.accel_group, ord("q"),
gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE)
file_menu.append(self.load_cfg_mi)
file_menu.append(self.save_cfg_mi)
file_menu.append(quit_mi)
self.load_cfg_mi.connect("activate", self._do_load_config_dialog)
self.save_cfg_mi.connect("activate", self._do_save_config_dialog)
quit_mi.connect("activate", gtk.main_quit)
# commands menu
commands_menu = gtk.Menu()
commands_mi.set_submenu(commands_menu)
self.start_cmd_mi = gtk.MenuItem("_Start")
self.start_cmd_mi.add_accelerator("activate", self.accel_group,
ord("s"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.start_cmd_mi.connect("activate", self._start_selected_commands)
self.start_cmd_mi.set_sensitive(False)
commands_menu.append(self.start_cmd_mi)
self.stop_cmd_mi = gtk.MenuItem("S_top")
self.stop_cmd_mi.add_accelerator("activate", self.accel_group,
ord("t"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.stop_cmd_mi.connect("activate", self._stop_selected_commands)
self.stop_cmd_mi.set_sensitive(False)
commands_menu.append(self.stop_cmd_mi)
self.restart_cmd_mi = gtk.MenuItem("R_estart")
self.restart_cmd_mi.add_accelerator("activate", self.accel_group,
ord("e"), gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.restart_cmd_mi.connect("activate",
self._restart_selected_commands)
self.restart_cmd_mi.set_sensitive(False)
commands_menu.append(self.restart_cmd_mi)
self.remove_cmd_mi = gtk.MenuItem("_Remove")
self.remove_cmd_mi.add_accelerator("activate", self.accel_group,
gtk.gdk.keyval_from_name("Delete"),
0, gtk.ACCEL_VISIBLE)
self.remove_cmd_mi.connect("activate", self._remove_selected_commands)
self.remove_cmd_mi.set_sensitive(False)
commands_menu.append(self.remove_cmd_mi)
commands_menu.append(gtk.SeparatorMenuItem())
self.new_cmd_mi = gtk.MenuItem("_New command")
self.new_cmd_mi.add_accelerator("activate", self.accel_group, ord("n"),
gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
self.new_cmd_mi.connect("activate", self._do_add_command_dialog)
commands_menu.append(self.new_cmd_mi)
# options menu
options_menu = gtk.Menu()
options_mi.set_submenu(options_menu)
self.is_observer_cmi = gtk.CheckMenuItem("_Observer")
self.is_observer_cmi.connect("activate", self.on_observer_mi_activate)
options_menu.append(self.is_observer_cmi)
# view menu
view_menu = gtk.Menu()
view_mi.set_submenu(view_menu)
menu_bar.append(file_mi)
menu_bar.append(options_mi)
menu_bar.append(commands_mi)
menu_bar.append(view_mi)
vpane = gtk.VPaned()
vbox.pack_start(vpane, True, True, 0)
# setup the command treeview
hpane = gtk.HPaned()
vpane.add1(hpane)
self.cmds_ts = gtk.TreeStore(
gobject.TYPE_PYOBJECT,
gobject.TYPE_STRING, # command name
gobject.TYPE_STRING, # host name
gobject.TYPE_STRING, # status actual
gobject.TYPE_STRING, # CPU usage
gobject.TYPE_INT, # memory vsize
gobject.TYPE_STRING # summary
)
self.cmds_tv = gtk.TreeView(self.cmds_ts)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
hpane.pack1(sw, resize=True)
sw.add(self.cmds_tv)
cmds_tr = gtk.CellRendererText()
cmds_tr.set_property("ellipsize", pango.ELLIPSIZE_END)
plain_tr = gtk.CellRendererText()
status_tr = gtk.CellRendererText()
cols = []
col = gtk.TreeViewColumn("Command", cmds_tr, text=1)
col.set_sort_column_id(1)
cols.append(col)
col = gtk.TreeViewColumn("Host", plain_tr, text=2)
col.set_sort_column_id(2)
cols.append(col)
col = gtk.TreeViewColumn("Status", status_tr, text=3)
col.set_sort_column_id(3)
col.set_cell_data_func(status_tr, self._status_cell_data_func)
cols.append(col)
col = gtk.TreeViewColumn("CPU %", plain_tr, text=4)
col.set_sort_column_id(4)
cols.append(col)
col = gtk.TreeViewColumn("Mem (kB)", plain_tr, text=5)
col.set_sort_column_id(5)
cols.append(col)
col = gtk.TreeViewColumn("Summary", plain_tr, text=6)
col.set_sort_column_id(6)
col.set_expand(True)
cols.append(col)
for col in cols:
col.set_resizable(True)
self.cmds_tv.append_column(col)
name = col.get_title()
col_cmi = gtk.CheckMenuItem(name)
col_cmi.set_active(True)
col_cmi.connect("activate",
lambda cmi, col: col.set_visible(cmi.get_active()),
col)
view_menu.append(col_cmi)
cmds_sel = self.cmds_tv.get_selection()
cmds_sel.set_mode(gtk.SELECTION_MULTIPLE)
cmds_sel.connect("changed", self.on_cmds_selection_changed)
gobject.timeout_add(1000,
lambda *s: self._repopulate_cmds_tv() or True)
self.cmds_tv.add_events (gtk.gdk.KEY_PRESS_MASK | \
gtk.gdk.BUTTON_PRESS | gtk.gdk._2BUTTON_PRESS)
self.cmds_tv.connect("key-press-event",
self._on_cmds_tv_key_press_event)
self.cmds_tv.connect("button-press-event",
self._on_cmds_tv_button_press_event)
self.cmds_tv.connect("row-activated", self._on_cmds_tv_row_activated)
# commands treeview context menu
self.cmd_ctxt_menu = gtk.Menu()
self.start_cmd_ctxt_mi = gtk.MenuItem("_Start")
self.cmd_ctxt_menu.append(self.start_cmd_ctxt_mi)
self.start_cmd_ctxt_mi.connect("activate",
self._start_selected_commands)
self.stop_cmd_ctxt_mi = gtk.MenuItem("_Stop")
self.cmd_ctxt_menu.append(self.stop_cmd_ctxt_mi)
self.stop_cmd_ctxt_mi.connect("activate", self._stop_selected_commands)
self.restart_cmd_ctxt_mi = gtk.MenuItem("R_estart")
self.cmd_ctxt_menu.append(self.restart_cmd_ctxt_mi)
self.restart_cmd_ctxt_mi.connect("activate",
self._restart_selected_commands)
self.remove_cmd_ctxt_mi = gtk.MenuItem("_Remove")
self.cmd_ctxt_menu.append(self.remove_cmd_ctxt_mi)
self.remove_cmd_ctxt_mi.connect("activate",
self._remove_selected_commands)
self.change_deputy_ctxt_mi = gtk.MenuItem("_Change Host")
self.cmd_ctxt_menu.append(self.change_deputy_ctxt_mi)
self.change_deputy_ctxt_mi.show()
self.cmd_ctxt_menu.append(gtk.SeparatorMenuItem())
self.new_cmd_ctxt_mi = gtk.MenuItem("_New Command")
self.cmd_ctxt_menu.append(self.new_cmd_ctxt_mi)
self.new_cmd_ctxt_mi.connect("activate", self._do_add_command_dialog)
self.cmd_ctxt_menu.show_all()
# # drag and drop command rows for grouping
# dnd_targets = [ ('PROCMAN_CMD_ROW',
# gtk.TARGET_SAME_APP | gtk.TARGET_SAME_WIDGET, 0) ]
# self.cmds_tv.enable_model_drag_source (gtk.gdk.BUTTON1_MASK,
# dnd_targets, gtk.gdk.ACTION_MOVE)
# self.cmds_tv.enable_model_drag_dest (dnd_targets,
# gtk.gdk.ACTION_MOVE)
# hosts treeview
self.hosts_ts = gtk.ListStore(
gobject.TYPE_PYOBJECT,
gobject.TYPE_STRING, # deputy name
gobject.TYPE_STRING, # last update time
gobject.TYPE_STRING, # load
gobject.TYPE_STRING, # jitter
gobject.TYPE_STRING, # skew
)
self.hosts_tv = gtk.TreeView(self.hosts_ts)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
hpane.pack2(sw, resize=False)
sw.add(self.hosts_tv)
col = gtk.TreeViewColumn("Host", plain_tr, text=1)
col.set_sort_column_id(1)
col.set_resizable(True)
self.hosts_tv.append_column(col)
col = gtk.TreeViewColumn("Last update", plain_tr, text=2)
# col.set_sort_column_id (2) # XXX this triggers really weird bugs...
col.set_resizable(True)
self.hosts_tv.append_column(col)
col = gtk.TreeViewColumn("Load", plain_tr, text=3)
col.set_resizable(True)
self.hosts_tv.append_column(col)
col = gtk.TreeViewColumn("Clock Skew (ms)", plain_tr, text=4)
col.set_resizable(True)
self.hosts_tv.append_column(col)
col = gtk.TreeViewColumn("Jitter (ms)", plain_tr, text=5)
col.set_resizable(True)
self.hosts_tv.append_column(col)
gobject.timeout_add(1000,
lambda *s: self._repopulate_hosts_tv() or True)
hpane.set_position(500)
# stdout textview
self.stdout_textview = gtk.TextView()
self.stdout_textview.set_property("editable", False)
self.sheriff_tb = self.stdout_textview.get_buffer()
sw = gtk.ScrolledWindow()
sw.add(self.stdout_textview)
vpane.add2(sw)
vpane.set_position(300)
stdout_adj = sw.get_vadjustment()
stdout_adj.set_data("scrolled-to-end", 1)
stdout_adj.connect("changed", self.on_adj_changed)
stdout_adj.connect("value-changed", self.on_adj_value_changed)
font_desc = pango.FontDescription("Monospace")
self.stdout_textview.modify_font(font_desc)
# stdout rate limit maintenance events
gobject.timeout_add(500, self._stdout_rate_limit_upkeep)
# status bar
self.statusbar = gtk.Statusbar()
vbox.pack_start(self.statusbar, False, False, 0)
vbox.show_all()
self.window.show()
def __init__(self, session, cid, update_win, tab_label, members=None):
'''constructor'''
gtk.VBox.__init__(self)
gui.Conversation.__init__(self, session, cid, update_win, members)
self.set_border_width(2)
self.tab_label = tab_label
self._header_visible = session.config.b_show_header
self._image_visible = session.config.b_show_info
self._toolbar_visible = session.config.b_show_toolbar
self.panel = gtk.VPaned()
self.show_avatar_in_taskbar = self.session.config.get_or_set(
'b_show_avatar_in_taskbar', True)
Header = extension.get_default('conversation header')
OutputText = extension.get_default('conversation output')
InputText = extension.get_default('conversation input')
ContactInfo = extension.get_default('conversation info')
ConversationToolbar = extension.get_default('conversation toolbar')
TransfersBar = extension.get_default('filetransfer pool')
CallWidget = extension.get_default('call widget')
dialog = extension.get_default('dialog')
Avatar = extension.get_default('avatar')
avatar_size = self.session.config.get_or_set('i_conv_avatar_size', 64)
self.avatarBox = gtk.EventBox()
self.avatarBox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.avatarBox.connect('button-press-event', self._on_avatar_click)
self.avatar = Avatar(cellDimention=avatar_size)
self.avatarBox.add(self.avatar)
self.avatarBox.set_tooltip_text(_('Click here to set your avatar'))
self.avatarBox.set_border_width(4)
self.his_avatarBox = gtk.EventBox()
self.his_avatarBox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.his_avatarBox.connect('button-press-event',
self._on_his_avatar_click)
self.his_avatar = Avatar(cellDimention=avatar_size)
self.his_avatarBox.add(self.his_avatar)
self.his_avatarBox.set_tooltip_text(_('Click to see informations'))
self.his_avatarBox.set_border_width(4)
self.header = Header(session, members)
toolbar_handler = gui.base.ConversationToolbarHandler(
self.session, dialog, gui.theme, self)
self.toolbar = ConversationToolbar(toolbar_handler)
self.toolbar.set_property('can-focus', False)
self.output = OutputText(self.session.config)
self.output.set_size_request(-1, 30)
self.input = InputText(self.session.config, self._on_send_message,
self.cycle_history)
self.output.set_size_request(-1, 25)
self.input.set_size_request(-1, 25)
self.info = ContactInfo()
self.transfers_bar = TransfersBar(self.session)
self.call_widget = CallWidget(self.session)
frame_input = gtk.Frame()
frame_input.set_shadow_type(gtk.SHADOW_IN)
input_box = gtk.VBox()
input_box.pack_start(self.toolbar, False)
input_box.pack_start(self.input, True, True)
frame_input.add(input_box)
self.panel.pack1(self.output, True, False)
self.panel.pack2(frame_input, False, False)
self.panel_signal_id = self.panel.connect_after(
'expose-event', self.update_panel_position)
self.panel.connect('button-release-event', self.on_input_panel_resize)
self.hbox = gtk.HBox()
if self.session.config.get_or_set('b_avatar_on_left', False):
self.hbox.pack_start(self.info, False)
self.hbox.pack_start(self.panel, True, True)
else:
self.hbox.pack_start(self.panel, True, True)
self.hbox.pack_start(self.info, False)
self.pack_start(self.header, False)
self.pack_start(self.hbox, True, True)
self.pack_start(self.transfers_bar, False)
if len(self.members) == 0:
self.header.information = ('connecting', 'creating conversation')
last_avatar = self.session.config.last_avatar
if self.session.config_dir.file_readable(last_avatar):
my_picture = last_avatar
else:
my_picture = gui.theme.user
his_picture = gui.theme.user
if members:
account = members[0]
contact = self.session.contacts.get(account)
if contact and contact.picture:
his_picture = contact.picture
self.output.clear(account, contact.nick, contact.display_name,
his_picture, my_picture)
self.info.first = self.his_avatarBox
self.his_avatar.set_from_file(his_picture)
self.info.last = self.avatarBox
self.avatar.set_from_file(my_picture)
self._load_style()
self.session.config.subscribe(self._on_avatarsize_changed,
'i_conv_avatar_size')
self.session.config.subscribe(self._on_show_toolbar_changed,
'b_show_toolbar')
self.session.config.subscribe(self._on_show_header_changed,
'b_show_header')
self.session.config.subscribe(self._on_show_info_changed,
'b_show_info')
self.session.config.subscribe(self._on_show_avatar_onleft,
'b_avatar_on_left')
self.session.config.subscribe(self._on_icon_size_change,
'b_toolbar_small')
self.session.signals.picture_change_succeed.subscribe(
self.on_picture_change_succeed)
self.session.signals.contact_attr_changed.subscribe(
self.on_contact_attr_changed_succeed)
self.session.signals.filetransfer_invitation.subscribe(
self.on_filetransfer_invitation)
self.session.signals.filetransfer_accepted.subscribe(
self.on_filetransfer_accepted)
self.session.signals.filetransfer_progress.subscribe(
self.on_filetransfer_progress)
self.session.signals.filetransfer_completed.subscribe(
self.on_filetransfer_completed)
self.session.signals.filetransfer_rejected.subscribe(
self.on_filetransfer_rejected)
self.session.signals.call_invitation.subscribe(self.on_call_invitation)
self.tab_index = -1 # used to select an existing conversation
self.index = 0 # used for the rotate picture function
self.rotate_started = False
self.timer = 0
if self.group_chat:
self.rotate_started = True #to prevents more than one timeout_add
self.timer = glib.timeout_add_seconds(5, self.rotate_picture)
def create_main_window(self):
"""Creates the main window with all it's widgets"""
# Creamos una ventana
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# Título de la ventana
self.window.set_title("Naufrago!")
# Establecemos el manejador para delete_event
self.window.connect("delete_event", self.delete_event)
self.window.set_border_width(5) # Grosor del borde de la ventana
self.window.set_size_request(600, 300) # Dimensionamiento de la ventana
# Creación del VBox.
self.vbox = gtk.VBox(False, 0)
# Creación del menubar
self.create_ui(self.window)
self.vbox.pack_start(self.ui.get_widget('/Menubar'), expand=False)
# Creación del HPaned.
self.hpaned = gtk.HPaned()
# Creación del Tree izquierdo para los feeds
self.treestore = self.populate_feeds() # Propaga los feeds del usuario
# Create the TreeView using treestore
self.treeview = gtk.TreeView(self.treestore)
# Right mouse button tree menu.
self.treeview.connect("button_press_event", self.button_press_event)
self.treeselection = self.treeview.get_selection()
###self.treeselection.set_select_function(self.row_selection_change, self.treestore, True)
self.treeselection.connect("changed", self.row_selection)
self.tvcolumn = gtk.TreeViewColumn('Feeds')
# Add tvcolumn to treeview
self.treeview.append_column(self.tvcolumn)
# CellRenderers para Iconos y Texto
self.cellpb = gtk.CellRendererPixbuf()
self.cell = gtk.CellRendererText()
# Añadimos las cells a la tvcolumn
self.tvcolumn.pack_start(self.cellpb, False)
self.tvcolumn.pack_start(self.cell, True)
if gtk.gtk_version[1] < 2:
self.tvcolumn.set_cell_data_func(self.cellpb, self.make_pb)
else:
self.tvcolumn.set_attributes(self.cellpb, stock_id=1)
self.tvcolumn.set_attributes(self.cell, text=0)
# Allow sorting on the column
self.tvcolumn.set_sort_column_id(0)
# Allow drag and drop reordering of rows
self.treeview.set_reorderable(True)
self.treeview_setup_dnd(self.treeview)
self.hpaned.add1(self.treeview)
# Creación del VPaned
self.vpaned = gtk.VPaned()
# Creación de los 2 elementos restantes: la lista/tabla y el browser.
self.button1 = gtk.Button("Button 1")
self.button2 = gtk.Button("Button 2")
self.vpaned.add1(self.button1)
self.vpaned.add2(self.button2)
self.hpaned.add2(self.vpaned)
self.vbox.pack_start(self.hpaned, True, True, 0)
self.window.add(self.vbox)
self.window.show_all()
def run(self):
warnings.simplefilter("ignore")
self._pipe_name = '/tmp/webapp.pipe'
self._view = view = webkit.WebView()
view.connect('navigation-policy-decision-requested',
self._nav_req_handler)
view.connect('close-web-view', self._close)
view.connect('onload-event', self._onload)
language = self._get_browser_lang()
view.execute_script("window.navigator.userLanguage = '%s'" % language)
if self._inspector:
view.get_settings().set_property("enable-developer-extras", True)
if hasattr(self.__class__, "_focus_in"):
view.connect('focus-in-event', self._focus_in)
if hasattr(self.__class__, "_focus_out"):
view.connect('focus-out-event', self._focus_out)
if hasattr(self.__class__, "_download"):
view.connect('download-requested', self._download)
splitter = gtk.VPaned()
sw = gtk.ScrolledWindow()
sw.add(view)
splitter.add1(sw)
inspector = view.get_web_inspector()
inspector.connect("inspect-web-view", self._activate_inspector,
splitter)
self._win = win = gtk.Window(gtk.WINDOW_TOPLEVEL)
win.set_title(self._title)
win.connect("destroy", gtk.main_quit)
if self._app_icon is not None:
if os.path.exists(self._app_icon):
win.set_icon_from_file(self._app_icon)
else:
win.set_icon_name(self._app_icon)
if self._taskbar is False:
gtk.Window.set_skip_taskbar_hint(win, True)
win.add(splitter)
win.realize()
win.show_all()
gdk_window_settings(win.window, self._x, self._y, self._width,
self._height, self._decoration, self._maximized,
self._centered)
if self._disable_minimize:
win.connect("window-state-event", self._unminimise_if_minimised)
view.open(self._index)
# Start a thread that injects Javascript code coming from a filesystem pipe.
if self._pipe == True:
atexit.register(atexit_pipe_cleanup, self._pipe_name)
thread.start_new_thread(thr_inject_javascript,
(self._view, self._pipe_name))
gtk.main()
def __init__(self, instance, effect_properties_handling, clip_properties):
gtk.HBox.__init__(self)
#self.set_expanded(True)
self.selected_effects = []
self.timeline_objects = []
self._factory = None
self.app = instance
self.effectsHandler = self.app.effects
self._effect_config_ui = None
self.pipeline = None
self.effect_props_handling = effect_properties_handling
self.clip_properties = clip_properties
self._info_bar = None
self._config_ui_h_pos = None
self._timeline = None
self._vcontent = gtk.VPaned()
self.add(self._vcontent)
self._table = gtk.Table(3, 1, False)
self._toolbar = gtk.Toolbar()
self._removeEffectBt = gtk.ToolButton("gtk-delete")
self._removeEffectBt.set_label(_("Remove effect"))
self._removeEffectBt.set_use_underline(True)
self._removeEffectBt.set_is_important(True)
self._removeEffectBt.set_sensitive(False)
self._toolbar.insert(self._removeEffectBt, 0)
self._table.attach(self._toolbar, 0, 1, 0, 1, yoptions=gtk.FILL)
self.storemodel = gtk.ListStore(bool, str, str, str, object)
#Treeview
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# TreeView
# Displays name, description
self.treeview = gtk.TreeView(self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.set_property("rules_hint", True)
self.treeview.set_property("has_tooltip", True)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_SINGLE)
activatedcell = gtk.CellRendererToggle()
activatedcell.props.xpad = PADDING
activatedcol = self.treeview.insert_column_with_attributes(
-1, _("Activated"), activatedcell, active=COL_ACTIVATED)
activatedcell.connect("toggled", self._effectActiveToggleCb)
typecol = gtk.TreeViewColumn(_("Type"))
typecol.set_sort_column_id(COL_TYPE)
self.treeview.append_column(typecol)
typecol.set_spacing(SPACING)
typecol.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
typecol.set_min_width(50)
typecell = gtk.CellRendererText()
typecell.props.xpad = PADDING
typecell.set_property("ellipsize", pango.ELLIPSIZE_END)
typecol.pack_start(typecell)
typecol.add_attribute(typecell, "text", COL_TYPE)
namecol = gtk.TreeViewColumn(_("Effect name"))
namecol.set_sort_column_id(COL_NAME_TEXT)
self.treeview.append_column(namecol)
namecol.set_spacing(SPACING)
namecell = gtk.CellRendererText()
namecell.props.xpad = PADDING
namecell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(namecell)
namecol.add_attribute(namecell, "text", COL_NAME_TEXT)
self.treeview.drag_dest_set(gtk.DEST_DEFAULT_MOTION,
[dnd.EFFECT_TUPLE], gtk.gdk.ACTION_COPY)
self.selection = self.treeview.get_selection()
self.selection.connect("changed", self._treeviewSelectionChangedCb)
self._removeEffectBt.connect("clicked", self._removeEffectClicked)
self.connect("drag-data-received", self._dragDataReceivedCb)
self.treeview.connect("drag-leave", self._dragLeaveCb)
self.treeview.connect("drag-drop", self._dragDropCb)
self.treeview.connect("drag-motion", self._dragMotionCb)
self.treeview.connect("query-tooltip", self._treeViewQueryTooltipCb)
self._vcontent.connect("notify", self._vcontentNotifyCb)
self.treeview.set_headers_clickable(False)
self.app.connect("new-project-loaded", self._newProjectLoadedCb)
#self.connect('notify::expanded', self._expandedCb)
self._table.attach(self.treeview_scrollwin, 0, 1, 2, 3)
self._vcontent.pack1(self._table, resize=True, shrink=False)
self._showInfoBar()
self._vcontent.show()
