def __init__(self, controls):
gtk.Frame.__init__(self)
FControl.__init__(self, controls)
self.album_label = gtk.Label()
self.album_label.set_line_wrap(True)
self.album_label.set_markup("<b></b>")
self.set_label_widget(self.album_label)
self.empty = TextArea()
self.best_songs = SimpleTreeControl(_("Best Songs"), controls)
self.best_songs.line_title = EventLabel(self.best_songs.get_title(), func=self.show_current, arg=self.best_songs, func1=self.show_best_songs)
self.artists = SimpleTreeControl(_("Similar Artists"), controls)
self.artists.line_title = EventLabel(self.artists.get_title(), func=self.show_current, arg=self.artists, func1=self.show_similar_artists)
self.tracks = SimpleTreeControl(_("Similar Songs"), controls)
self.tracks.line_title = EventLabel(self.tracks.get_title(), func=self.show_current, arg=self.tracks, func1=self.show_similar_tracks)
self.tags = SimpleTreeControl(_("Similar Tags"), controls)
self.tags.line_title = EventLabel(self.tags.get_title(), func=self.show_current, arg=self.tags, func1=self.show_similar_tags)
self.lyrics = TextArea()
lyric_title = _("Lyrics")
self.lyrics.set_text("", lyric_title)
self.lyrics.line_title = EventLabel(lyric_title, func=self.show_current, arg=self.lyrics, func1=self.show_similar_lyrics)
"""wiki"""
wBox = gtk.VBox()
wiki_title = _("About Artist")
self.wiki = TextArea()
wBox.line_title = EventLabel(wiki_title, func=self.show_current, arg=wBox, func1=self.show_wiki_info)
self.last_fm_label = gtk.LinkButton("http://www.last.fm", "last.fm")
self.wiki_label = gtk.LinkButton("http://www.wikipedia.org", "wikipedia")
self.wiki = TextArea()
self.wiki.set_text("", wiki_title)
wBox.pack_start(HBoxDecorator(self.last_fm_label, self.wiki_label), False, False)
wBox.pack_start(self.wiki, True, True)
wBox.scroll = wBox
self.vpaned_small = gtk.VBox(False, 0)
"""image and similar artists"""
ibox = gtk.HBox(False, 0)
self.image = ImageBase(ICON_BLANK_DISK, FC().info_panel_image_size)
lbox = gtk.VBox(False, 0)
self.left_widget = [wBox, self.artists, self.tracks, self.tags, self.lyrics, self.best_songs]
for l_widget in self.left_widget:
lbox.pack_start(l_widget.line_title)
ibox.pack_start(self.image, False, False)
ibox.pack_start(lbox, True, True)
"""image and similar artists"""
sbox = gtk.VBox(False, 0)
for l_widget in self.left_widget:
sbox.pack_start(l_widget.scroll, True, True)
sbox.pack_end(self.empty.scroll, True, True)
self.vpaned_small.pack_start(ibox, False, False)
self.vpaned_small.pack_start(sbox, True, True)
self.add(self.vpaned_small)
self.hide_all()
self.bean = None
self.info_cache = InfoCache()
def run_hyperlink_dialog(stock_id=None,
text="",
title=None,
search_func=lambda i: False):
"""Run a dialog with inserted hyperlinks."""
parent_window = get_dialog_parent()
dialog = gtk.Window()
dialog.set_transient_for(parent_window)
dialog.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
dialog.set_title(title)
dialog.set_modal(False)
top_vbox = gtk.VBox()
top_vbox.show()
main_hbox = gtk.HBox(spacing=DIALOG_PADDING)
main_hbox.show()
# Insert the image
image_vbox = gtk.VBox()
image_vbox.show()
image = gtk.image_new_from_stock(stock_id, size=gtk.ICON_SIZE_DIALOG)
image.show()
image_vbox.pack_start(image,
expand=False,
fill=False,
padding=DIALOG_PADDING)
main_hbox.pack_start(image_vbox,
expand=False,
fill=False,
padding=DIALOG_PADDING)
# Apply the text
message_vbox = gtk.VBox()
message_vbox.show()
label = rose.gtk.util.get_hyperlink_label(text, search_func)
message_vbox.pack_start(label,
expand=True,
fill=True,
padding=DIALOG_PADDING)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_border_width(DIALOG_PADDING)
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
scrolled_window.add_with_viewport(message_vbox)
scrolled_window.child.set_shadow_type(gtk.SHADOW_NONE)
scrolled_window.show()
vbox = gtk.VBox()
vbox.pack_start(scrolled_window, expand=True, fill=True)
vbox.show()
main_hbox.pack_start(vbox, expand=True, fill=True)
top_vbox.pack_start(main_hbox, expand=True, fill=True)
# Insert the button
button_box = gtk.HBox(spacing=DIALOG_PADDING)
button_box.show()
button = rose.gtk.util.CustomButton(label=DIALOG_BUTTON_CLOSE,
size=gtk.ICON_SIZE_LARGE_TOOLBAR,
stock_id=gtk.STOCK_CLOSE)
button.connect("clicked", lambda b: dialog.destroy())
button_box.pack_end(button,
expand=False,
fill=False,
padding=DIALOG_PADDING)
top_vbox.pack_end(button_box,
expand=False,
fill=False,
padding=DIALOG_PADDING)
dialog.add(top_vbox)
if "\n" in text:
label.set_line_wrap(False)
dialog.set_resizable(True)
# make sure the dialog size doesn't exceed the maximum - if so change it
max_size = rose.config_editor.SIZE_MACRO_DIALOG_MAX
my_size = dialog.size_request()
new_size = [-1, -1]
for i in [0, 1]:
new_size[i] = min([my_size[i], max_size[i]])
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
dialog.set_default_size(*new_size)
dialog.show()
label.set_selectable(True)
button.grab_focus()
def __init__(self):
debug.mainthreadTest()
self.menu_name = "MessageWindow_%d" % MessageWindow.count
self.title = "%s Messages %d" % (subWindow.oofname(),
MessageWindow.count)
self.windows_menu_name = "Message_%d" % MessageWindow.count
subWindow.SubWindow.__init__(self,
title=self.title,
menu=self.menu_name)
# We are locally responsible for the windows submenu items.
self.gtk.connect("destroy", self.destroy)
# raise_window function is provided by the SubWindow class.
OOF.Windows.Messages.addItem(
oofmenu.OOFMenuItem(self.windows_menu_name,
help="Raise Message window %d." %
MessageWindow.count,
cli_only=0,
no_log=1,
gui_callback=self.raise_window))
MessageWindow.count += 1
allMessageWindows.add(self)
# Control box, with buttons. These could be menu items.
controlbox = gtk.Frame()
controlbox.set_shadow_type(gtk.SHADOW_OUT)
self.mainbox.pack_start(controlbox, expand=0, fill=0)
controlinnards = gtk.VBox()
controlbox.add(controlinnards)
buttonbox = gtk.HBox()
controlinnards.pack_start(buttonbox, expand=0, padding=2)
savebutton = gtkutils.StockButton(gtk.STOCK_SAVE, "Save...")
tooltips.set_tooltip_text(
savebutton, "Save the contents of this window to a file.")
buttonbox.pack_start(savebutton, expand=0, fill=0, padding=2)
gtklogger.setWidgetName(savebutton, "Save")
gtklogger.connect(savebutton, 'clicked', self.saveButtonCB)
self.button_dict = {}
self.signal_dict = {}
for m in reporter.messageclasses:
button = gtk.CheckButton(m)
gtklogger.setWidgetName(button, m)
buttonbox.pack_end(button, fill=0, expand=0, padding=2)
self.signal_dict[m] = gtklogger.connect(button, "clicked",
self.button_click)
self.button_dict[m] = button
tooltips.set_tooltip_text(
button, "Show or hide " + reporter.messagedescriptions[m])
messagepane = gtk.ScrolledWindow()
## The ScrolledWindow's scrollbars are *not* logged in the
## gui, because blocking the adjustment "changed" signals in
## the write_message function, below, doesn't work to suppress
## logging. This means that programmatic changes to the
## scrollbars are logged along with user changes, which fills
## up the log file with extraneous lines.
messagepane.set_border_width(4)
messagepane.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.mainbox.add(messagepane)
self.messages = gtk.TextView()
gtklogger.setWidgetName(self.messages, "Text")
self.messages.set_editable(False)
self.messages.set_cursor_visible(False)
self.messages.set_wrap_mode(gtk.WRAP_WORD)
self.changeFont(mainmenuGUI.getFixedFont())
self.gtk.set_default_size(90 * gtkutils.widgetCharSize(self.messages),
200)
# Get two marks to be used for automatic scrolling
bfr = self.messages.get_buffer()
enditer = bfr.get_end_iter()
self.endmark = bfr.create_mark(None, enditer, False)
self.midmark = bfr.create_mark(None, enditer, False)
messagepane.add(self.messages)
self.state_dict = {}
for m in reporter.messageclasses:
self.state_dict[m] = 1
self.sbcbs = [
switchboard.requestCallbackMain("write message",
self.write_message),
switchboard.requestCallbackMain("change fixed font",
self.changeFont)
]
self.draw()
def hBoxIt3(self, homogeneous, spacing, whatToBox, pad):
new_hbox = gtk.HBox(homogeneous, spacing)
new_hbox.pack_start(whatToBox, expand=False, fill=False, padding=pad)
return new_hbox
def labelIt(self, label, object):
new_label = gtk.Label(label)
new_box = gtk.HBox(True, 10)
new_box.pack_start(new_label, expand=False, fill=False, padding=0)
new_box.pack_start(object, expand=False, fill=False, padding=0)
return new_box
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 __init__(self):
oofGUI.MainPage.__init__(
self,
name="Boundary Conditions",
ordering=230,
tip=
"Set field and flux boundary conditions on the mesh's boundaries.")
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,
callback=self.meshCB,
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)
switchboard.requestCallbackMain(self.meshwidget, self.meshwidgetCB)
bcbuildframe = gtk.Frame()
gtklogger.setWidgetName(bcbuildframe, 'Condition')
bcbuildframe.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(bcbuildframe, expand=1, fill=1)
bcbuildbox = gtk.VBox(spacing=2)
bcbuildframe.add(bcbuildbox)
# Buttons for creating, editing and removing boundary conditions
align = gtk.Alignment(xalign=0.5)
bcbuildbox.pack_start(align, expand=0, fill=0, padding=3)
bcbuttons = gtk.HBox(homogeneous=1, spacing=3)
align.add(bcbuttons)
self.bcNew = gtk.Button("New...")
gtklogger.setWidgetName(self.bcNew, 'New')
gtklogger.connect(self.bcNew, "clicked", self.bcNew_CB)
tooltips.set_tooltip_text(
self.bcNew, "Create a new boundary condition in the current mesh.")
bcbuttons.pack_start(self.bcNew, expand=1, fill=1)
self.bcRename = gtk.Button("Rename...")
gtklogger.setWidgetName(self.bcRename, 'Rename')
gtklogger.connect(self.bcRename, 'clicked', self.bcRename_CB)
tooltips.set_tooltip_text(self.bcRename,
"Rename the selected boundary condition.")
bcbuttons.pack_start(self.bcRename, expand=1, fill=1)
self.bcEdit = gtk.Button("Edit...")
gtklogger.setWidgetName(self.bcEdit, 'Edit')
gtklogger.connect(self.bcEdit, 'clicked', self.bcEdit_CB)
tooltips.set_tooltip_text(self.bcEdit,
"Edit the selected boundary condition.")
bcbuttons.pack_start(self.bcEdit, expand=1, fill=1)
self.bcCopy = gtk.Button("Copy...")
gtklogger.setWidgetName(self.bcCopy, 'Copy')
gtklogger.connect(self.bcCopy, 'clicked', self.bcCopy_CB)
tooltips.set_tooltip_text(
self.bcCopy,
"Copy the selected boundary condition to another mesh.")
bcbuttons.pack_start(self.bcCopy, expand=1, fill=1)
self.bcCopyAll = gtk.Button("Copy All...")
gtklogger.setWidgetName(self.bcCopyAll, 'CopyAll')
gtklogger.connect(self.bcCopyAll, 'clicked', self.bcCopyAll_CB)
tooltips.set_tooltip_text(
self.bcCopyAll,
"Copy all the boundary conditions to another mesh.")
bcbuttons.pack_start(self.bcCopyAll, expand=1, fill=1)
self.bcDel = gtk.Button("Delete")
gtklogger.setWidgetName(self.bcDel, 'Delete')
gtklogger.connect(self.bcDel, "clicked", self.bcDel_CB)
tooltips.set_tooltip_text(self.bcDel,
"Remove the selected boundary condition.")
bcbuttons.pack_start(self.bcDel, expand=1, fill=1)
# List of boundary conditions
bcscroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(bcscroll, "BCScroll")
bcbuildbox.pack_start(bcscroll, expand=1, fill=1)
bcscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.bclist = BCList(self)
bcscroll.add(self.bclist.gtk)
self.bclist.update(None)
switchboard.requestCallbackMain(("new who", "Microstructure"),
self.newMSorSkeleton)
switchboard.requestCallbackMain(("new who", "Skeleton"),
self.newMSorSkeleton)
# Callbacks for when the mesh changes state internally.
switchboard.requestCallbackMain("boundary conditions changed",
self.newBCs)
switchboard.requestCallbackMain("boundary conditions toggled",
self.toggleBCs)
switchboard.requestCallbackMain("field defined", self.fieldDefined)
switchboard.requestCallbackMain("equation activated",
self.eqnActivated)
switchboard.requestCallbackMain("made reservation",
self.reservationChanged)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationChanged)
switchboard.requestCallbackMain("mesh boundaries changed",
self.newMeshBoundaries)
switchboard.requestCallbackMain("mesh status changed",
self.statusChanged)
def __init_window(self):
# Start pyGTK setup
self.window = gtk.Window()
self.window.set_title(_("Openbox Logout"))
self.window.connect("destroy", self.quit)
self.window.connect("key-press-event", self.on_keypress)
self.window.connect("window-state-event", self.on_window_state_change)
if not self.window.is_composited():
self.logger.debug("No compositing, enabling rendered effects")
# Window isn't composited, enable rendered effects
self.rendered_effects = True
else:
# Link in Cairo rendering events
self.window.connect('expose-event', self.on_expose)
self.window.connect('screen-changed', self.on_screen_changed)
self.on_screen_changed(self.window)
self.rendered_effects = False
self.window.set_size_request(620, 200)
self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("black"))
self.window.set_decorated(False)
self.window.set_position(gtk.WIN_POS_CENTER)
# Check monitor
screen = gtk.gdk.screen_get_default()
if screen.get_n_monitors() < self.monitor:
self.monitor = screen.get_n_monitors()
geometry = screen.get_monitor_geometry(self.monitor)
width = geometry.width
height = geometry.height
x = geometry.x
y = geometry.y
# Create the main panel box
self.mainpanel = gtk.HBox()
# Create the button box
self.buttonpanel = gtk.HButtonBox()
self.buttonpanel.set_spacing(10)
# Pack in the button box into the panel box, with two padder boxes
self.mainpanel.pack_start(gtk.VBox())
self.mainpanel.pack_start(self.buttonpanel, False, False)
self.mainpanel.pack_start(gtk.VBox())
# Add the main panel to the window
self.window.add(self.mainpanel)
for button in self.button_list:
self.__add_button(button, self.buttonpanel)
if self.rendered_effects == True:
self.logger.debug("Stepping though render path")
w = gtk.gdk.get_default_root_window()
pb = gtk.gdk.Pixbuf(gtk.gdk.COLORSPACE_RGB, False, 8, width,
height)
pb = pb.get_from_drawable(w, w.get_colormap(), x, y, 0, 0, width,
height)
self.logger.debug("Rendering Fade")
# Convert Pixbuf to PIL Image
wh = (pb.get_width(), pb.get_height())
pilimg = Image.fromstring("RGB", wh, pb.get_pixels())
pilimg = pilimg.point(lambda p: (p * self.opacity) / 255)
# "Convert" the PIL to Pixbuf via PixbufLoader
buf = StringIO.StringIO()
pilimg.save(buf, "ppm")
del pilimg
loader = gtk.gdk.PixbufLoader("pnm")
loader.write(buf.getvalue())
pixbuf = loader.get_pixbuf()
# Cleanup IO
buf.close()
loader.close()
pixmap, mask = pixbuf.render_pixmap_and_mask()
# width, height = pixmap.get_size()
else:
pixmap = None
self.window.set_app_paintable(True)
self.window.resize(width, height)
self.window.realize()
if pixmap:
self.window.window.set_back_pixmap(pixmap, False)
self.window.move(x, y)
buttons['MachUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
buttons['ReDown'] = gtk.ToolButton(gtk.STOCK_GO_BACK)
buttons['ReDisp'] = gtk.Button("")
buttons['ReUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
buttons['NEDown'] = gtk.ToolButton(gtk.STOCK_GO_BACK)
buttons['NEDisp'] = gtk.Button("")
buttons['NEUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
fig = Figure()
canvas = FigureCanvas(fig) # a gtk.DrawingArea
nav = NavigationToolbar(canvas, win)
nav.set_size_request(250, 35)
sep = [gtk.SeparatorToolItem() for i in range(10)]
toolbar = gtk.HBox(False, 2)
toolbar.pack_start(buttons['New'], False, False, 0)
toolbar.pack_start(buttons['Open'], False, False, 0)
toolbar.pack_start(buttons['Save'], False, False, 0)
toolbar.pack_start(sep[0], False, False, 0)
toolbar.pack_start(nav, False, False, 0)
toolbar.pack_start(sep[1], False, False, 0)
toolbar.pack_start(combobox, False, False, 0)
toolbar.pack_start(sep[2], False, False, 0)
toolbar.pack_start(buttons['ReMesh'], False, False, 0)
toolbar.pack_start(sep[3], False, False, 0)
toolbar.pack_start(buttons['MachDown'], False, False, 0)
toolbar.pack_start(buttons['MachDisp'], False, False, 0)
toolbar.pack_start(buttons['MachUp'], False, False, 0)
toolbar.pack_start(sep[4], False, False, 0)
toolbar.pack_start(buttons['ReDown'], False, False, 0)
def setup_ui(self):
"""Creates the actual UI."""
# create a floating toplevel window and set some title and border
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG)
self.window.set_title(self.app_name)
self.window.set_border_width(8)
# connect delete and destroy events
self.window.connect("destroy", self.destroy)
self.window.connect("delete-event", self.destroy)
# This is our main container, vertically ordered.
self.box_container = gtk.VBox(False, 5)
self.box_container.show()
self.notebook = gtk.Notebook()
self.page_latex = gtk.HBox(False, 5)
self.page_latex.set_border_width(8)
self.page_latex.show()
self.page_log = gtk.HBox(False, 5)
self.page_log.set_border_width(8)
self.page_log.show()
self.page_settings = gtk.HBox(False, 5)
self.page_settings.set_border_width(8)
self.page_settings.show()
self.page_help = gtk.VBox(False, 5)
self.page_help.set_border_width(8)
self.page_help.show()
self.notebook.append_page(self.page_latex, gtk.Label("LaTeX"))
self.notebook.append_page(self.page_log, gtk.Label("Log"))
self.notebook.append_page(self.page_settings, gtk.Label("Settings"))
self.notebook.append_page(self.page_help, gtk.Label("Help"))
self.notebook.show()
# First component: The input text view for the LaTeX code.
# It lives in a ScrolledWindow so we can get some scrollbars when the
# text is too long.
self.text = gtk.TextView(self.syntax_buffer)
self.text.get_buffer().set_text(self.src)
self.text.show()
self.text_container = gtk.ScrolledWindow()
self.text_container.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.text_container.set_shadow_type(gtk.SHADOW_IN)
self.text_container.add(self.text)
self.text_container.set_size_request(400, 200)
self.text_container.show()
self.page_latex.pack_start(self.text_container)
# Second component: The log view
self.log_view = gtk.TextView()
self.log_view.show()
self.log_container = gtk.ScrolledWindow()
self.log_container.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.log_container.set_shadow_type(gtk.SHADOW_IN)
self.log_container.add(self.log_view)
self.log_container.set_size_request(400, 200)
self.log_container.show()
self.page_log.pack_start(self.log_container)
# third component: settings
self.settings_container = gtk.Table(2,2)
self.settings_container.set_row_spacings(8)
self.settings_container.show()
self.label_preamble = gtk.Label("Preamble")
self.label_preamble.set_alignment(0, 0.5)
self.label_preamble.show()
self.preamble = gtk.FileChooserButton("...")
if 'preamble' in self.settings and os.path.exists(self.settings['preamble']):
self.preamble.set_filename(self.settings['preamble'])
self.preamble.set_action(gtk.FILE_CHOOSER_ACTION_OPEN)
self.preamble.show()
self.settings_container.attach(self.label_preamble, yoptions=gtk.SHRINK,
left_attach=0, right_attach=1, top_attach=0, bottom_attach=1)
self.settings_container.attach(self.preamble, yoptions=gtk.SHRINK,
left_attach=1, right_attach=2, top_attach=0, bottom_attach=1)
self.label_scale = gtk.Label("Scale")
self.label_scale.set_alignment(0, 0.5)
self.label_scale.show()
self.scale_adjustment = gtk.Adjustment(value=1.0, lower=0, upper=100,
step_incr=0.1)
self.scale = gtk.SpinButton(adjustment=self.scale_adjustment, digits=1)
if 'scale' in self.settings:
self.scale.set_value(float(self.settings['scale']))
self.scale.show()
self.settings_container.attach(self.label_scale, yoptions=gtk.SHRINK,
left_attach=0, right_attach=1, top_attach=1, bottom_attach=2)
self.settings_container.attach(self.scale, yoptions=gtk.SHRINK,
left_attach=1, right_attach=2, top_attach=1, bottom_attach=2)
self.page_settings.pack_start(self.settings_container)
# help tab
self.help_label = gtk.Label()
self.help_label.set_markup(Ui.help_text)
self.help_label.set_line_wrap(True)
self.help_label.show()
self.about_label = gtk.Label()
self.about_label.set_markup(Ui.about_text)
self.about_label.set_line_wrap(True)
self.about_label.show()
self.separator_help = gtk.HSeparator()
self.separator_help.show()
self.page_help.pack_start(self.help_label)
self.page_help.pack_start(self.separator_help)
self.page_help.pack_start(self.about_label)
self.box_container.pack_start(self.notebook, True, True)
# separator between buttonbar and notebook
self.separator_buttons = gtk.HSeparator()
self.separator_buttons.show()
self.box_container.pack_start(self.separator_buttons, False, False)
# the button bar
self.box_buttons = gtk.HButtonBox()
self.box_buttons.set_layout(gtk.BUTTONBOX_END)
self.box_buttons.show()
self.button_render = gtk.Button(stock=gtk.STOCK_APPLY)
self.button_cancel = gtk.Button(stock=gtk.STOCK_CLOSE)
self.button_render.set_flags(gtk.CAN_DEFAULT)
self.button_render.connect("clicked", self.render, None)
self.button_cancel.connect("clicked", self.cancel, None)
self.button_render.show()
self.button_cancel.show()
self.box_buttons.pack_end(self.button_cancel)
self.box_buttons.pack_end(self.button_render)
self.box_container.pack_start(self.box_buttons, False, False)
self.window.add(self.box_container)
self.window.set_default(self.button_render)
self.window.show()
def ui_init(self):
self._fullscreen = False
self._showing_info = False
# FIXME: if _thumb_tray becomes some kind of button group, we wouldn't
# have to track which recd is active
self._active_recd = None
self.connect_after('key-press-event', self._key_pressed)
self._active_toolbar_idx = 0
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
self._toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(self._toolbar_box)
self._toolbar = self.get_toolbar_box().toolbar
tool_group = None
if self.model.get_has_camera():
self._photo_button = RadioToolButton()
self._photo_button.props.group = tool_group
tool_group = self._photo_button
self._photo_button.props.icon_name = 'camera-external'
self._photo_button.props.label = _('Photo')
self._photo_button.mode = constants.MODE_PHOTO
self._photo_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._photo_button, -1)
self._video_button = RadioToolButton()
self._video_button.props.group = tool_group
self._video_button.props.icon_name = 'media-video'
self._video_button.props.label = _('Video')
self._video_button.mode = constants.MODE_VIDEO
self._video_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._video_button, -1)
else:
self._photo_button = None
self._video_button = None
self._audio_button = RadioToolButton()
self._audio_button.props.group = tool_group
self._audio_button.props.icon_name = 'media-audio'
self._audio_button.props.label = _('Audio')
self._audio_button.mode = constants.MODE_AUDIO
self._audio_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._audio_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self._toolbar_controls = RecordControl(self._toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._toolbar.insert(separator, -1)
self._toolbar.insert(StopButton(self), -1)
self.get_toolbar_box().show_all()
main_box = gtk.VBox()
self.set_canvas(main_box)
main_box.get_parent().modify_bg(gtk.STATE_NORMAL, COLOR_BLACK)
main_box.show()
self._media_view = MediaView()
self._media_view.connect('media-clicked', self._media_view_media_clicked)
self._media_view.connect('pip-clicked', self._media_view_pip_clicked)
self._media_view.connect('info-clicked', self._media_view_info_clicked)
self._media_view.connect('full-clicked', self._media_view_full_clicked)
self._media_view.connect('tags-changed', self._media_view_tags_changed)
self._media_view.show()
self._controls_hbox = gtk.HBox()
self._controls_hbox.show()
self._shutter_button = ShutterButton()
self._shutter_button.connect("clicked", self._shutter_clicked)
self._controls_hbox.pack_start(self._shutter_button, expand=True, fill=False)
self._countdown_image = CountdownImage()
self._controls_hbox.pack_start(self._countdown_image, expand=True, fill=False)
self._play_button = PlayButton()
self._play_button.connect('clicked', self._play_pause_clicked)
self._controls_hbox.pack_start(self._play_button, expand=False)
self._playback_scale = PlaybackScale(self.model)
self._controls_hbox.pack_start(self._playback_scale, expand=True, fill=True)
self._progress = ProgressInfo()
self._controls_hbox.pack_start(self._progress, expand=True, fill=True)
self._title_label = gtk.Label()
self._title_label.set_markup("<b><span foreground='white'>"+_('Title:')+'</span></b>')
self._controls_hbox.pack_start(self._title_label, expand=False)
self._title_entry = gtk.Entry()
self._title_entry.modify_bg(gtk.STATE_INSENSITIVE, COLOR_BLACK)
self._title_entry.connect('changed', self._title_changed)
self._controls_hbox.pack_start(self._title_entry, expand=True, fill=True, padding=10)
self._record_container = RecordContainer(self._media_view, self._controls_hbox)
main_box.pack_start(self._record_container, expand=True, fill=True,
padding=6)
self._record_container.show()
self._thumb_tray = HTray()
self._thumb_tray.set_size_request(-1, 150)
main_box.pack_end(self._thumb_tray, expand=False)
self._thumb_tray.show_all()
def create_window(self):
self.window = gtk.Window()
title = "Log out " + getpass.getuser() + "? Choose an option:"
self.window.set_title(title)
self.window.set_border_width(5)
self.window.set_size_request(500, 80)
self.window.set_resizable(False)
self.window.set_keep_above(True)
self.window.stick
self.window.set_position(1)
self.window.connect("delete_event", gtk.main_quit)
windowicon = self.window.render_icon(gtk.STOCK_QUIT, gtk.ICON_SIZE_MENU)
self.window.set_icon(windowicon)
#Create HBox for buttons
self.button_box = gtk.HBox()
self.button_box.show()
#Cancel button
self.cancel = gtk.Button(stock = gtk.STOCK_CANCEL)
self.cancel.set_border_width(4)
self.cancel.connect("clicked", self.cancel_action)
self.button_box.pack_start(self.cancel)
self.cancel.show()
#Logout button
self.logout = gtk.Button("_Log out")
self.logout.set_border_width(4)
self.logout.connect("clicked", self.logout_action)
self.button_box.pack_start(self.logout)
self.logout.show()
#Suspend button
self.suspend = gtk.Button("_Suspend")
self.suspend.set_border_width(4)
self.suspend.connect("clicked", self.suspend_action)
self.button_box.pack_start(self.suspend)
self.suspend.show()
#Reboot button
self.reboot = gtk.Button("_Reboot")
self.reboot.set_border_width(4)
self.reboot.connect("clicked", self.reboot_action)
self.button_box.pack_start(self.reboot)
self.reboot.show()
#Shutdown button
self.shutdown = gtk.Button("_Power off")
self.shutdown.set_border_width(4)
self.shutdown.connect("clicked", self.shutdown_action)
self.button_box.pack_start(self.shutdown)
self.shutdown.show()
#Create HBox for status label
self.label_box = gtk.HBox()
self.label_box.show()
self.status = gtk.Label()
self.status.show()
self.label_box.pack_start(self.status)
#Create VBox and pack the above HBox's
self.vbox = gtk.VBox()
self.vbox.pack_start(self.button_box)
self.vbox.pack_start(self.label_box)
self.vbox.show()
self.window.add(self.vbox)
self.window.show()
def __init__(self):
self.root = os.getcwd()
self.filemodel = gtk.TreeStore(str, str, bool)
self.fileview = self.get_view('Files', self.filemodel, 'fileview')
self.colmodel = gtk.TreeStore(str, str, str)
self.colview = self.get_view('Collections', self.colmodel, 'colview')
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Kindelabra v%s" % VERSION)
self.window.set_default_size(1000, 700)
self.window.connect("destroy", gtk.main_quit)
self.accel_group = gtk.AccelGroup()
self.window.add_accel_group(self.accel_group)
vbox_main = gtk.VBox()
filechooserdiag = gtk.FileChooserDialog(
"Select your Kindle folder", self.window,
gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT))
filechooserdiag.set_current_folder(os.path.join(self.root, 'system'))
self.filechooser = gtk.FileChooserButton(filechooserdiag)
self.filechooser.connect("current-folder-changed", self.load)
file_toolbar = gtk.HBox()
file_toolbar.pack_start(self.filechooser, True, True, 2)
file_toolbar.pack_start(
self.get_button('gtk-refresh', 'Refresh files', self.refresh),
False, True, 2)
file_toolbar.pack_start(
self.get_button('gtk-open', 'Open collection file',
self.open_collection, "O"), False, True, 2)
file_toolbar.pack_start(gtk.VSeparator(), False, True, 2)
file_toolbar.pack_start(
self.get_button('gtk-save', 'Save collection file', self.save,
"S"), False, True, 2)
hbox_main = gtk.HBox()
filescroll = gtk.ScrolledWindow()
filescroll.add(self.fileview)
colscroll = gtk.ScrolledWindow()
colscroll.add(self.colview)
col_toolbar = gtk.VBox()
col_toolbar.pack_start(
self.get_button('gtk-new', 'Create new collection',
self.add_collection, "N"), False, True, 2)
col_toolbar.pack_start(
self.get_button('gtk-edit', 'Rename collection',
self.rename_collection, "E"), False, True, 2)
col_toolbar.pack_start(
self.get_button('gtk-remove', 'Delete collection',
self.del_collection), False, True, 2)
col_toolbar.pack_start(gtk.HSeparator(), False, True, 7)
col_toolbar.pack_start(
self.get_button('gtk-go-forward', 'Add book to collection',
self.add_file), False, True, 2)
col_toolbar.pack_start(
self.get_button('gtk-go-back', 'Remove book from collection',
self.del_file), False, True, 2)
col_toolbar.pack_start(gtk.HSeparator(), False, True, 7)
col_toolbar.pack_start(
self.get_button('gtk-revert-to-saved', 'Revert collections',
self.revert), False, True, 2)
hbox_main.add(filescroll)
hbox_main.pack_start(col_toolbar, False, False, 2)
hbox_main.add(colscroll)
self.statusbar = gtk.Statusbar()
vbox_main.pack_start(file_toolbar, False)
vbox_main.add(hbox_main)
vbox_main.pack_start(self.statusbar, False)
self.window.add(vbox_main)
self.window.show_all()
self.status("Select your Kindle's home folder")
gtk.main()
def __init__(self, notebookinfo=None, port=8080, public=True, **opts):
'''Constructor
@param notebookinfo: the notebook location
@param port: the http port to serve on
@param public: allow connections to the server from other
computers - if C{False} can only connect from localhost
@param opts: options for L{WWWInterface.__init__()}
'''
gtk.Window.__init__(self)
self.set_title('Zim - ' + _('Web Server')) # T: Window title
self.set_border_width(10)
self.interface_opts = opts
self.httpd = None
self._source_id = None
# Widgets
self.status_label = gtk.Label()
self.status_label.set_markup('<i>'+_('Server not started')+'</i>')
# T: Status in web server gui
self.start_button = IconButton('gtk-media-play')
self.start_button.connect('clicked', lambda o: self.start())
self.stop_button = IconButton('gtk-media-stop')
self.stop_button.connect('clicked', lambda o: self.stop())
self.stop_button.set_sensitive(False)
if gtk.gtk_version >= (2, 10) \
and gtk.pygtk_version >= (2, 10):
self.link_button = gtk.LinkButton('')
self.link_button.set_sensitive(False)
else:
self.link_button = None
self.notebookcombobox = NotebookComboBox(current=notebookinfo)
self.open_button = IconButton('gtk-index')
self.open_button.connect('clicked', lambda *a: NotebookDialog(self).run())
self.portentry = gtk.SpinButton()
self.portentry.set_numeric(True)
self.portentry.set_range(80, 10000)
self.portentry.set_increments(1, 80)
self.portentry.set_value(port)
self.public_checkbox = gtk.CheckButton(label=_('Allow public access'))
# T: Checkbox in web server gui
self.public_checkbox.set_active(public)
# Build the interface
vbox = gtk.VBox()
self.add(vbox)
hbox = gtk.HBox(spacing=12)
hbox.pack_start(self.start_button, False)
hbox.pack_start(self.stop_button, False)
hbox.pack_start(self.status_label, False)
vbox.add(hbox)
table = input_table_factory((
(_('Notebook'), self.notebookcombobox, self.open_button),
# T: Field in web server gui
(_('Port'), self.portentry),
# T: Field in web server gui for HTTP port (e.g. port 80)
self.public_checkbox
))
vbox.add(table)
if self.link_button:
hbox = gtk.HBox()
hbox.pack_end(self.link_button, False)
vbox.add(hbox)
def ofd(fname=None):
dialog = gtk.Dialog("pyedit: Open File", None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT))
dialog.set_default_response(gtk.RESPONSE_ACCEPT)
dialog.connect("key-press-event", area_key, dialog)
dialog.connect("key-release-event", area_key, dialog)
dialog.set_default_size(800, 600)
# Spacers
label1 = gtk.Label(" ")
label2 = gtk.Label(" ")
label3 = gtk.Label(" ")
label4 = gtk.Label(" ")
label5 = gtk.Label(" ")
label6 = gtk.Label(" ")
label7 = gtk.Label(" ")
label8 = gtk.Label(" ")
label10 = gtk.Label(" ")
dialog.label11 = gtk.Label(" ")
dialog.label12 = gtk.Label(" ")
dialog.pbox = gtk.HBox()
fill_path(dialog)
dialog.vbox.pack_start(label4, False)
dialog.vbox.pack_start(dialog.pbox, False)
dialog.vbox.pack_start(label10, False)
warnings.simplefilter("ignore")
dialog.entry = gtk.Entry()
warnings.simplefilter("default")
dialog.entry.set_activates_default(True)
dialog.entry.set_text(fname)
hbox2 = gtk.HBox()
hbox2.pack_start(label6, False)
hbox2.pack_start(dialog.entry)
hbox2.pack_start(label7, False)
dialog.vbox.pack_start(hbox2, False)
dialog.vbox.pack_start(label8, False)
dialog.ts = gtk.ListStore(str, str, str, str)
tview = create_ftree(dialog.ts)
scroll = gtk.ScrolledWindow()
tview.connect("row-activated", tree_sel, dialog)
tview.connect("cursor-changed", tree_sel_row, dialog)
dialog.tview = tview
scroll.add(tview)
frame2 = gtk.Frame()
frame2.add(scroll)
hbox3 = gtk.HBox()
hbox3.pack_start(label1, False)
hbox3.pack_start(frame2)
hbox3.pack_start(label2, False)
dialog.vbox.pack_start(hbox3)
dialog.vbox.pack_start(label3, False)
dialog.show_all()
populate(dialog)
dialog.set_focus(tview)
#dialog.set_focus(dialog.entry)
response = dialog.run()
if response == gtk.RESPONSE_ACCEPT:
res = os.path.realpath(dialog.entry.get_text())
else:
res = ""
#print "response", response, "res", res
dialog.destroy()
return res
def __init__(self, filename=None):
# initialise some variables:
self.ncfn = filename
self.pc = None
self.cfacs = None
self.proj = None
self.src_proj = None
self.lon1 = None
self.lon2 = None
self.lat1 = None
self.lat2 = None
###############
## GTK setup ##
###############
# create new window
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
######################
# setup window
######################
self.win.set_border_width(10)
self.win.set_default_size(600, 400)
self.win.set_title('SMC Gridded Data Plotter')
######################
# add the GTK canvas:
######################
self.fig = plt.Figure(figsize=(5, 4), dpi=100)
self.canvas = FigureCanvas(self.fig)
################
# Add menu bar #
################
menu_bar = gtk.MenuBar()
file_menu = gtk.Menu()
open_item = gtk.MenuItem("Open")
exit_item = gtk.MenuItem("Exit")
file_menu.append(open_item)
file_menu.append(exit_item)
open_item.connect("activate", self.load_event)
root_menu = gtk.MenuItem("File")
root_menu.set_submenu(file_menu)
menu_bar.append(root_menu)
###########
# Controls
##########
# buttons:
btnPlot = gtk.Button('Update Plot')
btnPrev = gtk.Button('Prev Time')
btnNext = gtk.Button('Next Time')
# Field combo box:
store = gtk.ListStore(str, str)
self.cbox_field = gtk.ComboBox(store)
cell = gtk.CellRendererText()
self.cbox_field.pack_start(cell, True)
self.cbox_field.add_attribute(cell, 'text', 1)
store.append(['hs', 'sig wave heihgt'])
# Times combo box:
store = gtk.ListStore(int, str)
self.cbox_times = gtk.ComboBox(store)
cell = gtk.CellRendererText()
self.cbox_times.pack_start(cell, True)
self.cbox_times.add_attribute(cell, 'text', 1)
#for i in range(1,61):
# store.append([i-1, 'T+%03d' % i])
# Domain combo box:
store = gtk.ListStore(str, float, float, float, float)
self.cbox_domains = gtk.ComboBox(store)
cell = gtk.CellRendererText()
self.cbox_domains.pack_start(cell, True)
self.cbox_domains.add_attribute(cell, 'text', 0)
store.append(
['Full Domain (could be slow)', -999.9, -999.9, -999.9, -999.9])
store.append(['UK', 35.0, 70.0, -15.0, 10.0])
store.append(['South West UK', 49.4, 51.5, -6.7, -1.6])
store.append(['Mediterranean', 29.5, 46.5, -6.0, 36.5])
store.append(['North Atlantic', 20.0, 70.0, -90, 30])
store.append(['West Pacific', -70.0, 70.0, 120, 200])
store.append(['East Pacific', -70.0, 70.0, -160, -68])
store.append(['Arabian Gulf', 23.0, 30.5, 47.5, 59.5])
store.append(['Caspian Sea', 36.0, 47.5, 46.0, 55.5])
store.append(['Black Sea', 40.5, 47.1, 27.0, 42.0])
store.append(['Caribbean', 10.0, 27.5, -86.5, -58.5])
store.append(['South China Sea', -9.5, 24.0, 98.0, 128.0])
store.append(['Australasia', -48, 0.0, 105.0, 179.0])
self.cbox_domains.set_active(1)
# Projections:
store = gtk.ListStore(object, str)
self.cbox_proj = gtk.ComboBox(store)
cell = gtk.CellRendererText()
self.cbox_proj.pack_start(cell, True)
self.cbox_proj.add_attribute(cell, 'text', 1)
store.append([ccrs.PlateCarree(), 'Plate Carree'])
store.append([
ccrs.RotatedPole(pole_latitude=37.5, pole_longitude=177.5),
'Euro Rotated Pole'
])
store.append([ccrs.Robinson(), 'Robinson'])
store.append([ccrs.Mercator(), 'Mercator'])
store.append([ccrs.Geostationary(), 'Geostationary'])
self.cbox_proj.set_active(0)
# coastlines:
store = gtk.ListStore(object, str)
self.cbox_coast = gtk.ComboBox(store)
cell = gtk.CellRendererText()
self.cbox_coast.pack_start(cell, True)
self.cbox_coast.add_attribute(cell, 'text', 1)
store.append([None, 'None'])
store.append(['10m', 'High res (10m)'])
store.append(['50m', 'Medium res (50m)'])
store.append(['110m', 'Low res (110m)'])
self.cbox_coast.set_active(3)
self.coast = '110m'
# lat/lon ranges:
self.inLat1 = gtk.Entry()
self.inLat2 = gtk.Entry()
self.inLon1 = gtk.Entry()
self.inLon2 = gtk.Entry()
self.domain_changed_event(
self.cbox_domains) # update with default domain
# Cell size selection
cellsbox = gtk.HBox(homogeneous=False, spacing=5)
self.chkf1 = gtk.CheckButton("3km")
self.chkf2 = gtk.CheckButton("6km")
self.chkf3 = gtk.CheckButton("12km")
self.chkf4 = gtk.CheckButton("25km")
cellsbox.pack_end(self.chkf1)
cellsbox.pack_end(self.chkf2)
cellsbox.pack_end(self.chkf3)
cellsbox.pack_end(self.chkf4)
# Colour range box:
crangebox = gtk.HBox(homogeneous=False, spacing=5)
self.cmin = gtk.Entry()
self.cmax = gtk.Entry()
self.cauto = gtk.CheckButton('Auto')
crangebox.pack_start(self.cmin)
crangebox.pack_start(self.cmax)
crangebox.pack_start(self.cauto)
self.cauto.set_active(True)
self.cmin.set_sensitive(False)
self.cmax.set_sensitive(False)
self.cauto.connect('toggled', self.cauto_changed_event)
## controls layout
grid = gtk.Table(rows=8, columns=3)
grid.attach(gtk.Label('Field'), 0, 1, 0, 1, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Time'), 0, 1, 1, 2, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Projection'), 0, 1, 2, 3, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Coastline'), 0, 1, 3, 4, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Domain '), 0, 1, 4, 5, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Lat Range'), 0, 1, 5, 6, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Lon Range'), 0, 1, 6, 7, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Cells'), 0, 1, 7, 8, yoptions=gtk.SHRINK)
grid.attach(gtk.Label('Colour range'), 0, 1, 8, 9, yoptions=gtk.SHRINK)
grid.attach(self.cbox_field, 1, 3, 0, 1, yoptions=gtk.SHRINK)
grid.attach(self.cbox_times, 1, 3, 1, 2, yoptions=gtk.SHRINK)
grid.attach(self.cbox_proj, 1, 3, 2, 3, yoptions=gtk.SHRINK)
grid.attach(self.cbox_coast, 1, 3, 3, 4, yoptions=gtk.SHRINK)
grid.attach(self.cbox_domains, 1, 3, 4, 5, yoptions=gtk.SHRINK)
grid.attach(self.inLat1, 1, 2, 5, 6, yoptions=gtk.SHRINK)
grid.attach(self.inLat2, 2, 3, 5, 6, yoptions=gtk.SHRINK)
grid.attach(self.inLon1, 1, 2, 6, 7, yoptions=gtk.SHRINK)
grid.attach(self.inLon2, 2, 3, 6, 7, yoptions=gtk.SHRINK)
grid.attach(cellsbox, 1, 3, 7, 8, yoptions=gtk.SHRINK)
grid.attach(crangebox, 1, 3, 8, 9, yoptions=gtk.SHRINK)
#grid.attach(btnPlot, 0, 1, 8, 9, yoptions=gtk.SHRINK, xoptions=gtk.SHRINK)
# Hbox for plot buttons
btn_hbox = gtk.HBox(homogeneous=False, spacing=5)
btn_hbox.pack_start(btnPrev, True, False, 0)
btn_hbox.pack_start(btnPlot, True, False, 0)
btn_hbox.pack_start(btnNext, True, False, 0)
## File details text view
txt = gtk.TextBuffer()
txt.set_text('Please load a file')
self.tv_file_details = gtk.TextView(txt)
vbox = gtk.VBox(spacing=15)
vbox.pack_start(grid, False)
vbox.pack_start(btn_hbox, False)
vbox.pack_end(self.tv_file_details, True)
# plot controls
from matplotlib.backends.backend_gtkagg import NavigationToolbar2GTKAgg as NavigationToolbar
toolbar = NavigationToolbar(self.canvas, self.win)
#vbox.pack_end(toolbar, False, False)
# Top level layout box:
topbox = gtk.VBox()
topbox.pack_start(menu_bar, expand=False, fill=True)
box = gtk.HBox(homogeneous=False, spacing=5)
topbox.pack_end(box)
# canvas/toolbar layout
plotbox = gtk.VBox(homogeneous=False, spacing=0)
plotbox.pack_start(self.canvas, expand=True, fill=True)
plotbox.pack_end(toolbar, False, False)
box.pack_start(plotbox, expand=True, fill=True)
box.pack_end(vbox, expand=False, fill=False)
self.win.add(topbox)
###################
# connect signals:
###################
# destroy/delete:
self.win.connect("delete_event", self.delete_event)
self.win.connect("destroy", self.destroy)
btnPlot.connect("clicked", self.plot_event)
btnNext.connect("clicked", self.next_time_event)
btnPrev.connect("clicked", self.prev_time_event)
self.cbox_domains.connect('changed', self.domain_changed_event)
# show window
self.win.show_all()
#### Load file, if passed in:
if self.ncfn is not None:
self.loadfile(self.ncfn)
def __init__(self, coord, kmx, kmy, layer, conf, force_update):
self.layers = []
def _zoom(zoom0, zoom1):
out_hbox = gtk.HBox(False, 50)
out_hbox.set_border_width(10)
in_hbox = gtk.HBox(False, 20)
in_hbox.pack_start(lbl("min:"), False)
self.s_zoom0 = SpinBtn(zoom0)
self.s_zoom0.set_digits(0)
in_hbox.pack_start(self.s_zoom0)
out_hbox.pack_start(in_hbox)
in_hbox = gtk.HBox(False, 20)
in_hbox.pack_start(lbl("max:"), False)
self.s_zoom1 = SpinBtn(zoom1)
self.s_zoom1.set_digits(0)
in_hbox.pack_start(self.s_zoom1)
out_hbox.pack_start(in_hbox)
hbox = gtk.HBox()
hbox.set_border_width(10)
hbox.pack_start(myFrame(" Zoom ", out_hbox, 0))
return hbox
def _center(lat0, lon0):
vbox = gtk.VBox(False, 5)
hbox = gtk.HBox(False, 10)
hbox.pack_start(lbl("latitude:"))
self.e_lat0 = myEntry("%.6f" % lat0, 15, False)
hbox.pack_start(self.e_lat0, False)
vbox.pack_start(hbox)
hbox = gtk.HBox(False, 10)
hbox.pack_start(lbl("longitude:"))
self.e_lon0 = myEntry("%.6f" % lon0, 15, False)
hbox.pack_start(self.e_lon0, False)
vbox.pack_start(hbox)
return myFrame(" Center ", vbox)
def _area(kmx, kmy):
vbox = gtk.VBox(False, 5)
hbox = gtk.HBox(False, 10)
hbox.pack_start(lbl("width:"))
self.e_kmx = myEntry("%.6g" % kmx, 10, False)
hbox.pack_start(self.e_kmx, False)
vbox.pack_start(hbox)
hbox = gtk.HBox(False, 10)
hbox.pack_start(lbl("height:"))
self.e_kmy = myEntry("%.6g" % kmy, 10, False)
hbox.pack_start(self.e_kmy, False)
vbox.pack_start(hbox)
return myFrame(" Area (km) ", vbox)
def download_rclick(self, event, menu):
if event.type == gtk.gdk.BUTTON_PRESS and event.button == 3:
menu.popup(None, None, None, event.button, event.time)
def rclick_menu(active_layer, map_serv):
menu = gtk.Menu()
for layer in range(len(LAYER_NAMES)):
self.layers.append(gtk.CheckMenuItem(LAYER_NAMES[layer]))
if layer == active_layer:
self.layers[-1].set_active(True)
else:
self.layers[-1].set_sensitive(layer in MAP_SERVICES[map_serv]['layers'])
menu.append(self.layers[-1])
menu.show_all()
return menu
def _buttons(strFolder, layer, conf):
hbbox = gtk.HButtonBox()
hbbox.set_border_width(10)
hbbox.set_layout(gtk.BUTTONBOX_SPREAD)
menu = rclick_menu(layer, MAP_SERVERS.index(conf.map_service))
gtk.stock_add([(gtk.STOCK_HARDDISK, "_Download", 0, 0, "")])
self.b_download = gtk.Button(stock=gtk.STOCK_HARDDISK)
self.b_download.connect('clicked', self.start_download, strFolder)
self.b_download.connect('event', download_rclick, menu)
hbbox.pack_start(self.b_download)
hbox = gtk.HBox()
gtk.stock_add([(gtk.STOCK_UNDELETE, "", 0, 0, "")])
self.b_open = gtk.Button(stock=gtk.STOCK_UNDELETE)
self.b_open.connect('clicked', self.do_open, strFolder)
hbox.pack_start(self.b_open, padding=25)
if isdir(fldDown):
hbbox.pack_start(hbox)
self.b_pause = gtk.Button(stock='gtk-media-pause')
self.b_pause.connect('clicked', self.do_pause)
self.b_pause.set_sensitive(False)
hbbox.pack_start(self.b_pause)
return hbbox
fldDown = join(conf.init_path, 'download')
print "DLWindow(", coord, kmx, kmy, layer, ')'
self.conf = conf
self.force_update = force_update
kmx = mapUtils.nice_round(kmx)
kmy = mapUtils.nice_round(kmy)
gtk.Window.__init__(self)
lat0 = coord[0]
lon0 = coord[1]
zoom0 = max(MAP_MIN_ZOOM_LEVEL, coord[2] - 3)
zoom1 = min(MAP_MAX_ZOOM_LEVEL, coord[2] + 1)
vbox = gtk.VBox(False)
hbox = gtk.HBox(False, 10)
hbox.pack_start(_center(lat0, lon0))
hbox.pack_start(_area(kmx, kmy))
vbox.pack_start(hbox)
vbox.pack_start(_zoom(zoom0, zoom1))
vbox.pack_start(_buttons(fldDown, layer, conf))
self.pbar = gtk.ProgressBar()
self.pbar.set_text(" ")
vbox.pack_start(self.pbar)
self.add(vbox)
self.set_title("GMapCatcher download")
self.set_border_width(10)
ico = mapPixbuf.ico()
if ico:
self.set_icon(ico)
self.complete = []
self.processing = False
self.gmap = None
self.downloader = None
self.connect('delete-event', self.on_delete)
self.connect('key-press-event', self.key_press)
self.show_all()
def __init__(self,
categories,
category_message_time_tuples,
category_stock_ids,
default_size=None,
parent=None,
destroy_hook=None):
super(ConsoleWindow, self).__init__()
if parent is not None:
self.set_transient_for(parent)
if default_size is None:
default_size = self.DEFAULT_SIZE
self.set_default_size(*default_size)
self.set_title(self.TITLE)
self._filter_category = self.CATEGORY_ALL
self.categories = categories
self.category_icons = []
for id_ in category_stock_ids:
self.category_icons.append(
self.render_icon(id_, gtk.ICON_SIZE_MENU))
self._destroy_hook = destroy_hook
top_vbox = gtk.VBox()
top_vbox.show()
self.add(top_vbox)
message_scrolled_window = gtk.ScrolledWindow()
message_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
message_scrolled_window.show()
self._message_treeview = gtk.TreeView()
self._message_treeview.show()
self._message_treeview.set_rules_hint(True)
# Set up the category column (icons).
category_column = gtk.TreeViewColumn()
category_column.set_title(self.COLUMN_TITLE_CATEGORY)
cell_category = gtk.CellRendererPixbuf()
category_column.pack_start(cell_category, expand=False)
category_column.set_cell_data_func(cell_category,
self._set_category_cell, 0)
category_column.set_clickable(True)
category_column.connect("clicked", self._sort_column, 0)
self._message_treeview.append_column(category_column)
# Set up the message column (info text).
message_column = gtk.TreeViewColumn()
message_column.set_title(self.COLUMN_TITLE_MESSAGE)
cell_message = gtk.CellRendererText()
message_column.pack_start(cell_message, expand=False)
message_column.add_attribute(cell_message, attribute="text", column=1)
message_column.set_clickable(True)
message_column.connect("clicked", self._sort_column, 1)
self._message_treeview.append_column(message_column)
# Set up the time column (text).
time_column = gtk.TreeViewColumn()
time_column.set_title(self.COLUMN_TITLE_TIME)
cell_time = gtk.CellRendererText()
time_column.pack_start(cell_time, expand=False)
time_column.set_cell_data_func(cell_time, self._set_time_cell, 2)
time_column.set_clickable(True)
time_column.set_sort_indicator(True)
time_column.connect("clicked", self._sort_column, 2)
self._message_treeview.append_column(time_column)
self._message_store = gtk.TreeStore(str, str, int)
for category, message, time in category_message_time_tuples:
self._message_store.append(None, [category, message, time])
filter_model = self._message_store.filter_new()
filter_model.set_visible_func(self._get_should_show)
self._message_treeview.set_model(filter_model)
message_scrolled_window.add(self._message_treeview)
top_vbox.pack_start(message_scrolled_window, expand=True, fill=True)
category_hbox = gtk.HBox()
category_hbox.show()
top_vbox.pack_end(category_hbox, expand=False, fill=False)
for i, category in enumerate(categories + [self.CATEGORY_ALL]):
togglebutton = gtk.ToggleButton(label=category,
use_underline=False)
togglebutton.connect(
"toggled", lambda b: self._set_new_filter(
b, category_hbox.get_children()))
togglebutton.show()
category_hbox.pack_start(togglebutton, expand=True, fill=True)
togglebutton.set_active(True)
self.show()
self._scroll_to_end()
self.connect("destroy", self._handle_destroy)
self.drag_dest_set(gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_DROP,
targets_accept,
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
targets_send = [("text/x-jabber-roster-item", 0, TARGET_ROSTER_ITEM),
("text/x-jabber-id", 0, TARGET_JID)]
self.drag_source_set(gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON3_MASK,
targets_send,
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.connect("drag-data-received", self.__on_drag_data_received)
self.connect("drag-data-get", self.__on_drag_data_get)
self.connect("drag-begin", self.__on_drag_begin)
## Create the widgets we'll always have
self.__hboxPJ = gtk.HBox(0, 4)
self.add(self.__hboxPJ)
self.__hboxPJ.show()
self.__lblPJ = gtk.Label("")
self.__lblPJ.set_alignment(0.0, 0.5)
self.__hboxPJ.pack_end(self.__lblPJ, 1, 1, 0)
self.__lblPJ.show()
self.__pixPJ = gtk.Image()
rm = self.__app.resources
self.__pixPJ.set_from_pixbuf(rm.get(rm.rtPIXBUF, "online"))
self.__hboxPJ.pack_end(self.__pixPJ, 0, 0, 0)
self.__pixPJ.show()
## Get presence updates for the current default jid
def __init__(self):
self.dialog = gtk.Dialog(title='Nutrient Goal',
flags=gtk.DIALOG_MODAL,
buttons=(gtk.STOCK_HELP, gtk.RESPONSE_HELP,
'gtk-save', 1, gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL))
self.dialog.set_resizable(False)
hbox1 = gtk.HBox(False, 0)
self.dialog.vbox.pack_start(hbox1, True, True, 0)
notebook1 = gtk.Notebook()
notebook1.set_border_width(5)
hbox1.pack_start(notebook1, True, True, 0)
self.table_list = []
self.table_list.append(gtk.Table(4, 6, False))
self.table_list.append(gtk.Table(4, 11, False))
self.table_list.append(gtk.Table(4, 10, False))
self.table_list.append(gtk.Table(4, 14, False))
self.table_list.append(gtk.Table(4, 5, False))
for i in range(5):
self.table_list[i].set_border_width(5)
self.table_list[i].set_row_spacings(5)
self.table_list[i].set_col_spacings(5)
self.table_list[i].attach(gtk.Label('Daily Goal'), 1, 2, 0, 1,
gtk.FILL | gtk.EXPAND, 0, 0, 0)
self.table_list[i].attach(gtk.Label('Daily Goal'), 3, 4, 0, 1,
gtk.FILL | gtk.EXPAND, 0, 0, 0)
notebook1.add(self.table_list[i])
label_list = []
label0 = gtk.Label('')
label0.set_text_with_mnemonic('M_acro-Nutrients')
label_list.append(label0)
label1 = gtk.Label('')
label1.set_text_with_mnemonic('M_icro-Nutrients')
label_list.append(label1)
label2 = gtk.Label('')
label2.set_text_with_mnemonic('Ami_no Acids')
label_list.append(label2)
label3 = gtk.Label('')
label3.set_text_with_mnemonic('Fa_ts')
label_list.append(label3)
label4 = gtk.Label('')
label4.set_text_with_mnemonic('Misce_llaneous')
label_list.append(label4)
for i in range(5):
notebook1.set_tab_label(notebook1.get_nth_page(i), label_list[i])
self.nutr_list = []
for num, label_text, table_num, l, r, t, b in nutr_data_list:
nutr = Nutrient()
nutr.num = num
nutr.table_num = table_num
nutr.left = l
nutr.right = r
nutr.top = t
nutr.bottom = b
nutr.label = gtk.Label(label_text)
nutr.label.set_alignment(1.0, 0.5)
nutr.entry = gtk.Entry()
self.nutr_list.append(nutr)
for nutr in self.nutr_list:
self.table_list[nutr.table_num].attach(nutr.label, nutr.left,
nutr.right, nutr.top,
nutr.bottom, gtk.FILL, 0, 0,
0)
self.table_list[nutr.table_num].attach(nutr.entry, nutr.left + 1,
nutr.right + 1, nutr.top,
nutr.bottom,
gtk.FILL | gtk.EXPAND, 0, 0,
0)
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(self,
name="Active %s" % Spacestring,
ordering=71.1,
tip="Modify active %s." % spacestring)
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
# Microstructure widget, centered at the top of the page.
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
self.mswidget = whowidget.WhoWidget(microstructure.microStructures,
scope=self)
centerbox.pack_start(self.mswidget.gtk[0], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Active area status in the left half of the main pane.
vbox = gtk.VBox()
mainpane.pack1(vbox, resize=1, shrink=0)
aasframe = gtk.Frame("Active %s Status" % Spacestring)
aasframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(aasframe, expand=0, fill=0, padding=2)
self.aainfo = gtk.Label()
gtklogger.setWidgetName(self.aainfo, "Status")
## self.aainfo.set_alignment(0.0, 0.5)
aasframe.add(self.aainfo)
naaframe = gtk.Frame("Named Active %ss" % Spacestring)
naaframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(naaframe, expand=1, fill=1)
naabox = gtk.VBox()
naaframe.add(naabox)
self.aalist = chooser.ScrolledChooserListWidget(
callback=self.aalistCB,
dbcallback=self.aalistCB2,
name="NamedAreas")
naabox.pack_start(self.aalist.gtk, expand=1, fill=1, padding=2)
bbox = gtk.HBox()
naabox.pack_start(bbox, expand=0, fill=0, padding=2)
self.storebutton = gtk.Button("Store...")
bbox.pack_start(self.storebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.storebutton, "Store")
gtklogger.connect(self.storebutton, 'clicked', self.storeCB)
tooltips.set_tooltip_text(
self.storebutton,
"Save the current active %s for future use." % spacestring)
self.renamebutton = gtk.Button("Rename...")
bbox.pack_start(self.renamebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.renamebutton, "Rename")
gtklogger.connect(self.renamebutton, 'clicked', self.renameCB)
tooltips.set_tooltip_text(
self.renamebutton,
"Rename the selected saved active %s." % spacestring)
self.deletebutton = gtk.Button("Delete")
bbox.pack_start(self.deletebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.deletebutton, "Delete")
gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB)
tooltips.set_tooltip_text(
self.deletebutton,
"Delete the selected saved active %s." % spacestring)
self.restorebutton = gtk.Button("Restore")
bbox.pack_start(self.restorebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.restorebutton, "Restore")
gtklogger.connect(self.restorebutton, 'clicked', self.restoreCB)
tooltips.set_tooltip_text(
self.restorebutton,
"Use the selected saved active %s." % spacestring)
# Active area modification methods in the right half of the main pane
modframe = gtk.Frame("Active %s Modification" % Spacestring)
gtklogger.setWidgetName(modframe, "Modify")
modframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(modframe, resize=0, shrink=0)
modbox = gtk.VBox()
modframe.add(modbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## modbox.pack_start(scroll, expand=1, fill=1)
self.activeareaModFactory = regclassfactory.RegisteredClassFactory(
activeareamod.ActiveAreaModifier.registry,
title="Method:",
scope=self,
name="Method")
## scroll.add_with_viewport(self.activeareaModFactory.gtk)
modbox.pack_start(self.activeareaModFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.activeareaModFactory.set,
self.sensitizeHistory,
setCBkwargs={'interactive': 1})
self.activeareaModFactory.set_callback(self.historian.stateChangeCB)
# Prev, OK, and Next buttons
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevbutton = gtkutils.prevButton()
hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.prevbutton, 'clicked', self.historian.prevCB)
tooltips.set_tooltip_text(
self.prevbutton,
'Recall the previous active %s modification operation.' %
spacestring)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=2)
gtklogger.setWidgetName(self.okbutton, "OK")
gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB)
tooltips.set_tooltip_text(
self.okbutton,
'Perform the active %s modification operation defined above.' %
spacestring)
self.nextbutton = gtkutils.nextButton()
hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.nextbutton, 'clicked', self.historian.nextCB)
tooltips.set_tooltip_text(
self.nextbutton,
"Recall the next active %s modification operation." % spacestring)
# Undo, Redo, Override
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
hbox.pack_start(self.undobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
tooltips.set_tooltip_text(self.undobutton,
"Undo the previous operation.")
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.redobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.redobutton, "Redo an undone operation.")
self.overridebutton = gtk.ToggleButton('Override')
hbox.pack_start(self.overridebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.overridebutton, "Override")
self.overridesignal = gtklogger.connect(self.overridebutton, 'clicked',
self.overrideCB)
tooltips.set_tooltip_text(
self.overridebutton,
"Temporarily activate the entire microstructure.")
# Switchboard signals
self.sbcallbacks = [
switchboard.requestCallback(self.mswidget, self.mswidgetCB),
switchboard.requestCallback("active area modified",
self.aamodified),
switchboard.requestCallbackMain("stored active areas changed",
self.storedAAChanged),
switchboard.requestCallbackMain(
('validity', self.activeareaModFactory), self.validityChangeCB)
]
self.built = True
def _main_window_default_style(self):
wcfg = self.config['main_window']
button_style = self.config.get('font_styles', {}).get('buttons', {})
border_padding = int(2 * button_style.get('points', 10) / 3)
vbox = gtk.VBox(False, 0)
vbox.set_border_width(border_padding)
# Enforce that the window always has at least one status section,
# even if the configuration doesn't specify one.
sd_defs = wcfg.get("status_displays") or [{
"id":
"notification",
"details":
wcfg.get('initial_notification', '')
}]
# Scale the status icons relative to a) how tall the window is,
# and b) how many status lines we are showing.
icon_size = int(0.66 * wcfg.get('height', 360) / len(sd_defs))
status_displays = []
for st in sd_defs:
ss = {
'id': st['id'],
'hbox': gtk.HBox(False, border_padding),
'vbox': gtk.VBox(False, border_padding),
'title': gtk.Label(),
'details': gtk.Label()
}
for which in ('title', 'details'):
ss[which].set_markup(st.get(which, ''))
exact = '%s_%s' % (ss['id'], which)
if exact in self.font_styles:
ss[which].modify_font(self.font_styles[exact])
elif which in self.font_styles:
ss[which].modify_font(self.font_styles[which])
if 'icon' in st:
ss['icon'] = gtk.Image()
ss['hbox'].pack_start(ss['icon'], False, True)
self._set_status_display_icon(ss, st['icon'], icon_size)
text_x = 0.0
else:
# If there is no icon, center our title and details
text_x = 0.5
ss['title'].set_alignment(text_x, 1.0)
ss['details'].set_alignment(text_x, 0.0)
ss['vbox'].pack_start(ss['title'], True, True)
ss['vbox'].pack_end(ss['details'], True, True)
ss['vbox'].set_spacing(1)
ss['hbox'].pack_start(ss['vbox'], True, True)
ss['hbox'].set_spacing(7)
status_displays.append(ss)
self.status_display = dict((ss['id'], ss) for ss in status_displays)
notify = None
if 'notification' not in self.status_display:
notify = gtk.Label()
notify.set_markup(wcfg.get('initial_notification', ''))
notify.set_alignment(0, 0.5)
if 'notification' in self.font_styles:
notify.modify_font(self.font_styles['notification'])
if wcfg.get('background'):
self._set_background_image(vbox, wcfg.get('background'))
button_box = gtk.HBox(False, border_padding)
self._main_window_indicator(vbox, button_box)
self._main_window_add_action_items(button_box)
if notify:
button_box.pack_start(notify, True, True)
for ss in status_displays:
vbox.pack_start(ss['hbox'], True, True)
vbox.pack_end(button_box, False, True)
self.main_window['window'].add(vbox)
self.main_window.update({
'vbox':
vbox,
'notification': (notify if notify else
self.status_display['notification']['details']),
'status_displays':
status_displays,
'buttons':
button_box
})
def hBoxThese(self, homogenous, spacing, list, pad=0):
new_box = gtk.HBox(homogenous, spacing)
for item in list:
new_box.pack_start(item, expand=False, fill=False, padding=pad)
return new_box
def __init__(self,
controller,
device,
minor,
cur_size,
min_size,
max_size,
fstype,
bytes_in_sector=512,
format=True):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.controller = controller
self.device = device
self.minor = minor
self.min_size = min_size
self.max_size = max_size
self.cur_size = cur_size
self.fstype = fstype
self.bytes_in_sector = bytes_in_sector
self.format = format
if self.min_size == -1 or self.max_size == -1:
self.min_size = self.cur_size
self.max_size = self.cur_size
self.sync_slider_to_text = True
self.connect("delete_event", self.delete_event)
self.connect("destroy", self.destroy_event)
self.set_default_size(400, 300)
if self.fstype == "free":
self.set_title(_("New partition on ") + device)
else:
self.set_title(
_("Properties for ") +
self.controller.devices[self.device][minor]['devnode'])
self.globalbox = gtk.VBox(False, 0)
self.globalbox.set_border_width(10)
self.resize_box = gtk.VBox(False, 0)
self.resize_hpaned = gtk.HPaned()
# self.resize_hpaned.set_size_request(400, -1)
self.resize_hpaned.connect("size-allocate", self.part_resized)
self.resize_part_space_frame = gtk.Frame()
self.resize_part_space_frame.set_shadow_type(gtk.SHADOW_IN)
self.resize_part_space = PartitionButton.Partition(
color1=self.controller.colors['linux-swap'],
color2=self.controller.colors['free'],
division=0,
label="")
self.resize_part_space.set_sensitive(False)
self.resize_part_space_frame.add(self.resize_part_space)
if self.type == "free" or self.min_size <= 1:
self.resize_hpaned.pack1(self.resize_part_space_frame,
resize=True,
shrink=True)
else:
self.resize_hpaned.pack1(self.resize_part_space_frame,
resize=True,
shrink=False)
self.resize_unalloc_space_frame = gtk.Frame()
self.resize_unalloc_space_frame.set_shadow_type(gtk.SHADOW_IN)
self.resize_unalloc_space = PartitionButton.Partition(
color1=self.controller.colors['unalloc'],
color2=self.controller.colors['unalloc'],
label="")
self.resize_unalloc_space.set_sensitive(False)
self.resize_unalloc_space_frame.add(self.resize_unalloc_space)
self.resize_hpaned.add2(self.resize_unalloc_space_frame)
self.resize_hpaned.set_position(0)
self.resize_box.pack_start(self.resize_hpaned,
expand=False,
fill=False,
padding=0)
self.resize_box.pack_start(gtk.Label(
_("You can slide above or enter values below")),
expand=False,
padding=2)
resize_text_box = gtk.HBox(False, 0)
resize_text_box.pack_start(gtk.Label(_("New size:")),
expand=False,
fill=False,
padding=0)
self.resize_info_part_size = gtk.Entry(max=9)
self.resize_info_part_size.set_width_chars(7)
self.resize_info_part_size.connect("insert-text",
self.validate_keypress)
self.resize_info_part_size.connect("focus-out-event",
self.update_slider_and_entries,
"part-size")
resize_text_box.pack_start(self.resize_info_part_size,
expand=False,
fill=False,
padding=6)
resize_text_box.pack_start(gtk.Label(_("MB")),
expand=False,
fill=False,
padding=0)
resize_text_box.pack_start(gtk.Label(" "),
expand=False,
fill=False,
padding=20)
resize_text_box.pack_start(gtk.Label(_("Unalloc. size:")),
expand=False,
fill=False,
padding=6)
self.resize_info_unalloc_size = gtk.Entry(max=9)
self.resize_info_unalloc_size.set_width_chars(7)
self.resize_info_unalloc_size.connect("insert-text",
self.validate_keypress)
self.resize_info_unalloc_size.connect("focus-out-event",
self.update_slider_and_entries,
"unalloc-size")
resize_text_box.pack_start(self.resize_info_unalloc_size,
expand=False,
fill=False,
padding=0)
resize_text_box.pack_start(gtk.Label("MB"),
expand=False,
fill=False,
padding=3)
self.resize_box.pack_start(resize_text_box,
expand=False,
fill=False,
padding=10)
self.globalbox.pack_start(self.resize_box,
expand=False,
fill=False,
padding=0)
self.part_info_box = gtk.HBox(False, 0)
part_info_table = gtk.Table(6, 2, False)
part_info_table.set_col_spacings(10)
part_info_table.set_row_spacings(5)
info_partition_label = gtk.Label(_("Partition:"))
info_partition_label.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_label, 0, 1, 0, 1)
self.info_partition = gtk.Label()
self.info_partition.set_alignment(0.0, 0.5)
part_info_table.attach(self.info_partition, 1, 2, 0, 1)
info_partition_format = gtk.Label(_("Format:"))
info_partition_format.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_format, 0, 1, 1, 2)
resize_info_part_format_box = gtk.HBox(False, 0)
self.resize_info_part_format_yes = gtk.RadioButton(label=_("Yes"))
self.resize_info_part_format_no = gtk.RadioButton(
label=_("No"), group=self.resize_info_part_format_yes)
if self.fstype == "free":
self.resize_info_part_format_yes.set_sensitive(False)
self.resize_info_part_format_no.set_sensitive(False)
else:
if self.format:
self.resize_info_part_format_yes.set_active(True)
else:
self.resize_info_part_format_no.set_active(True)
resize_info_part_format_box.pack_start(
self.resize_info_part_format_yes, expand=False, fill=False)
resize_info_part_format_box.pack_start(self.resize_info_part_format_no,
expand=False,
fill=False,
padding=10)
part_info_table.attach(resize_info_part_format_box, 1, 2, 1, 2)
info_partition_type = gtk.Label(_("Type:"))
info_partition_type.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_type, 0, 1, 2, 3)
self.resize_info_part_type = gtk.combo_box_new_text()
self.resize_info_part_type.append_text(_("Primary"))
self.resize_info_part_type.append_text(_("Logical"))
self.resize_info_part_type.set_active(0)
part_info_table.attach(self.resize_info_part_type, 1, 2, 2, 3)
info_partition_fs = gtk.Label(_("Filesystem:"))
info_partition_fs.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_fs, 0, 1, 3, 4)
self.resize_info_part_filesystem = gtk.combo_box_new_text()
for fs in self.controller.supported_filesystems:
self.resize_info_part_filesystem.append_text(fs)
self.resize_info_part_filesystem.set_active(0)
self.resize_info_part_filesystem.connect("changed",
self.filesystem_changed)
part_info_table.attach(self.resize_info_part_filesystem, 1, 2, 3, 4)
info_partition_mountpoint = gtk.Label(_("Mount point:"))
info_partition_mountpoint.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_mountpoint, 0, 1, 4, 5)
self.part_mount_point_entry = gtk.Entry()
part_info_table.attach(self.part_mount_point_entry, 1, 2, 4, 5)
info_partition_mountopts = gtk.Label(_("Mount options:"))
info_partition_mountopts.set_alignment(0.0, 0.5)
part_info_table.attach(info_partition_mountopts, 0, 1, 5, 6)
self.part_mount_opts_entry = gtk.Entry()
part_info_table.attach(self.part_mount_opts_entry, 1, 2, 5, 6)
self.part_info_box.pack_start(part_info_table,
expand=False,
fill=False,
padding=0)
self.globalbox.pack_start(self.part_info_box,
expand=False,
fill=False,
padding=10)
bottom_box = gtk.HBox(True, 0)
ok_button = gtk.Button(_(" OK "))
ok_button.set_flags(gtk.CAN_DEFAULT)
ok_button.set_size_request(60, -1)
ok_button.connect("clicked", self.ok_clicked)
bottom_box.pack_start(ok_button, expand=False, fill=False, padding=0)
cancel_button = gtk.Button(_(" Cancel "))
cancel_button.set_size_request(60, -1)
cancel_button.connect("clicked", self.cancel_clicked)
bottom_box.pack_start(cancel_button,
expand=False,
fill=False,
padding=0)
self.globalbox.pack_end(bottom_box,
expand=False,
fill=False,
padding=0)
self.add(self.globalbox)
ok_button.grab_default()
self.set_modal(True)
self.set_transient_for(self.controller.controller.window)
self.make_visible()
def run_dialog(dialog_type,
text,
title=None,
modal=True,
cancel=False,
extra_text=None):
"""Run a simple dialog with an 'OK' button and some text."""
parent_window = get_dialog_parent()
dialog = gtk.Dialog(parent=parent_window)
if parent_window is None:
dialog.set_icon(rose.gtk.util.get_icon())
if cancel:
cancel_button = dialog.add_button(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL)
if extra_text:
info_button = gtk.Button(stock=gtk.STOCK_INFO)
info_button.show()
info_title = DIALOG_TITLE_EXTRA_INFO
info_button.connect(
"clicked",
lambda b: run_scrolled_dialog(extra_text, title=info_title))
dialog.action_area.pack_start(info_button, expand=False, fill=False)
ok_button = dialog.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
if dialog_type == gtk.MESSAGE_INFO:
stock_id = gtk.STOCK_DIALOG_INFO
elif dialog_type == gtk.MESSAGE_WARNING:
stock_id = gtk.STOCK_DIALOG_WARNING
elif dialog_type == gtk.MESSAGE_QUESTION:
stock_id = gtk.STOCK_DIALOG_QUESTION
elif dialog_type == gtk.MESSAGE_ERROR:
stock_id = gtk.STOCK_DIALOG_ERROR
else:
stock_id = None
if stock_id is not None:
dialog.image = gtk.image_new_from_stock(stock_id, gtk.ICON_SIZE_DIALOG)
dialog.image.show()
dialog.label = gtk.Label(text)
try:
pango.parse_markup(text)
except glib.GError:
try:
dialog.label.set_markup(rose.gtk.util.safe_str(text))
except:
dialog.label.set_text(text)
else:
dialog.label.set_markup(text)
dialog.label.show()
hbox = gtk.HBox()
if stock_id is not None:
image_vbox = gtk.VBox()
image_vbox.pack_start(dialog.image,
expand=False,
fill=False,
padding=DIALOG_PADDING)
image_vbox.show()
hbox.pack_start(image_vbox,
expand=False,
fill=False,
padding=rose.config_editor.SPACING_PAGE)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_border_width(0)
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
vbox = gtk.VBox()
vbox.pack_start(dialog.label, expand=True, fill=True)
vbox.show()
scrolled_window.add_with_viewport(vbox)
scrolled_window.child.set_shadow_type(gtk.SHADOW_NONE)
scrolled_window.show()
hbox.pack_start(scrolled_window,
expand=True,
fill=True,
padding=rose.config_editor.SPACING_PAGE)
hbox.show()
dialog.vbox.pack_end(hbox, expand=True, fill=True)
if "\n" in text:
dialog.label.set_line_wrap(False)
dialog.set_resizable(True)
dialog.set_modal(modal)
if title is not None:
dialog.set_title(title)
# ensure the dialog size does not exceed the maximum allowed
max_size = rose.config_editor.SIZE_MACRO_DIALOG_MAX
my_size = dialog.size_request()
new_size = [-1, -1]
for i in [0, 1]:
new_size[i] = min([my_size[i], max_size[i]])
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
dialog.set_default_size(*new_size)
ok_button.grab_focus()
if modal or cancel:
dialog.show()
response = dialog.run()
dialog.destroy()
return (response == gtk.RESPONSE_OK)
else:
ok_button.connect("clicked", lambda b: dialog.destroy())
dialog.show()
def __init__(self, parent):
FindExtension.__init__(self, parent)
self._pattern = '*'
self._compare_method = fnmatch.fnmatch
# prepare options
plugin_options = parent._application.plugin_options
self._options = plugin_options.create_section(self.__class__.__name__)
# connect notify signal
parent.connect('notify-start', self.__handle_notify_start)
# enabled by default
self._checkbox_active.set_active(True)
# create label showing pattern help
label_help = gtk.Label()
label_help.set_alignment(0, 0)
label_help.set_use_markup(True)
label_help.set_markup(_(
'<b>Pattern matching</b>\n'
'*\t\tEverything\n'
'?\t\tAny single character\n'
'[seq]\tAny character in <i>seq</i>\n'
'[!seq]\tAny character <u>not</u> in <i>seq</i>'
))
# create containers
hbox = gtk.HBox(True, 15)
vbox_left = gtk.VBox(False, 5)
vbox_right = gtk.VBox(False, 0)
# create interface
vbox_pattern = gtk.VBox(False, 0)
label_pattern = gtk.Label(_('Search for:'))
label_pattern.set_alignment(0, 0.5)
self._entries = gtk.ListStore(str)
self._entry_pattern = gtk.ComboBoxEntry(model=self._entries)
self._entry_pattern.connect('changed', self.__handle_pattern_change)
self._checkbox_case_sensitive = gtk.CheckButton(_('Case sensitive'))
self._checkbox_case_sensitive.connect('toggled', self.__handle_case_sensitive_toggle)
# pack interface
self.vbox.remove(self._checkbox_active)
vbox_pattern.pack_start(label_pattern, False, False, 0)
vbox_pattern.pack_start(self._entry_pattern, False, False, 0)
vbox_left.pack_start(self._checkbox_active, False, False, 0)
vbox_left.pack_start(vbox_pattern, False, False, 0)
vbox_left.pack_start(self._checkbox_case_sensitive, False, False, 0)
vbox_right.pack_start(label_help, True, True, 0)
hbox.pack_start(vbox_left, True, True, 0)
hbox.pack_start(vbox_right, True, True, 0)
self.vbox.pack_start(hbox, True, True, 0)
# load saved values
self._load_history()
def __init__(self,
cmd_args,
description=None,
title=None,
stock_id=gtk.STOCK_EXECUTE,
hide_progress=False,
modal=True,
event_queue=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, model, ids, context=None):
super(WinExport, self).__init__()
self.dialog = gtk.Dialog(title=_("Export to CSV"),
parent=self.parent,
flags=gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.dialog.set_icon(TRYTON_ICON)
self.dialog.connect('response', self.response)
vbox = gtk.VBox()
frame_predef_exports = gtk.Frame()
frame_predef_exports.set_border_width(2)
frame_predef_exports.set_shadow_type(gtk.SHADOW_NONE)
vbox.pack_start(frame_predef_exports, True, True, 0)
viewport_exports = gtk.Viewport()
scrolledwindow_exports = gtk.ScrolledWindow()
scrolledwindow_exports.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
label_predef_exports = gtk.Label(_("<b>Predefined exports</b>"))
label_predef_exports.set_use_markup(True)
frame_predef_exports.set_label_widget(label_predef_exports)
viewport_exports.add(scrolledwindow_exports)
frame_predef_exports.add(viewport_exports)
hbox = gtk.HBox(True)
vbox.pack_start(hbox, True, True, 0)
frame_all_fields = gtk.Frame()
frame_all_fields.set_shadow_type(gtk.SHADOW_NONE)
hbox.pack_start(frame_all_fields, True, True, 0)
label_all_fields = gtk.Label(_("<b>All fields</b>"))
label_all_fields.set_use_markup(True)
frame_all_fields.set_label_widget(label_all_fields)
viewport_all_fields = gtk.Viewport()
scrolledwindow_all_fields = gtk.ScrolledWindow()
scrolledwindow_all_fields.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
viewport_all_fields.add(scrolledwindow_all_fields)
frame_all_fields.add(viewport_all_fields)
vbox_buttons = gtk.VBox(False, 10)
vbox_buttons.set_border_width(5)
hbox.pack_start(vbox_buttons, False, True, 0)
button_select = gtk.Button(_("_Add"), stock=None, use_underline=True)
button_select.set_alignment(0.0, 0.0)
img_button = gtk.Image()
img_button.set_from_stock('tryton-list-add', gtk.ICON_SIZE_BUTTON)
button_select.set_image(img_button)
button_select.connect_after('clicked', self.sig_sel)
vbox_buttons.pack_start(button_select, False, False, 0)
button_unselect = gtk.Button(_("_Remove"),
stock=None,
use_underline=True)
button_unselect.set_alignment(0.0, 0.0)
img_button = gtk.Image()
img_button.set_from_stock('tryton-list-remove', gtk.ICON_SIZE_BUTTON)
button_unselect.set_image(img_button)
button_unselect.connect_after('clicked', self.sig_unsel)
vbox_buttons.pack_start(button_unselect, False, False, 0)
button_unselect_all = gtk.Button(_("Clear"),
stock=None,
use_underline=True)
button_unselect_all.set_alignment(0.0, 0.0)
img_button = gtk.Image()
img_button.set_from_stock('tryton-clear', gtk.ICON_SIZE_BUTTON)
button_unselect_all.set_image(img_button)
button_unselect_all.connect_after('clicked', self.sig_unsel_all)
vbox_buttons.pack_start(button_unselect_all, False, False, 0)
hseparator_buttons = gtk.HSeparator()
vbox_buttons.pack_start(hseparator_buttons, False, True, 0)
button_save_export = gtk.Button(_("Save Export"),
stock=None,
use_underline=True)
button_save_export.set_alignment(0.0, 0.0)
img_button = gtk.Image()
img_button.set_from_stock('tryton-save', gtk.ICON_SIZE_BUTTON)
button_save_export.set_image(img_button)
button_save_export.connect_after('clicked', self.addreplace_predef)
vbox_buttons.pack_start(button_save_export, False, False, 0)
button_del_export = gtk.Button(_("Delete Export"),
stock=None,
use_underline=True)
button_del_export.set_alignment(0.0, 0.0)
img_button = gtk.Image()
img_button.set_from_stock('tryton-delete', gtk.ICON_SIZE_BUTTON)
button_del_export.set_image(img_button)
button_del_export.connect_after('clicked', self.remove_predef)
vbox_buttons.pack_start(button_del_export, False, False, 0)
frame_export = gtk.Frame()
frame_export.set_shadow_type(gtk.SHADOW_NONE)
label_export = gtk.Label(_("<b>Fields to export</b>"))
label_export.set_use_markup(True)
frame_export.set_label_widget(label_export)
alignment_export = gtk.Alignment(0.5, 0.5, 1, 1)
alignment_export.set_padding(0, 0, 12, 0)
frame_export.add(alignment_export)
viewport_fields_to_export = gtk.Viewport()
scrolledwindow_export = gtk.ScrolledWindow()
scrolledwindow_export.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
viewport_fields_to_export.add(scrolledwindow_export)
alignment_export.add(viewport_fields_to_export)
hbox.pack_start(frame_export, True, True, 0)
frame_options = gtk.Frame()
frame_options.set_border_width(2)
label_options = gtk.Label(_("<b>Options</b>"))
label_options.set_use_markup(True)
frame_options.set_label_widget(label_options)
vbox.pack_start(frame_options, False, True, 5)
hbox_options = gtk.HBox(False, 2)
frame_options.add(hbox_options)
hbox_options.set_border_width(2)
combo_saveas = gtk.combo_box_new_text()
hbox_options.pack_start(combo_saveas, True, True, 0)
combo_saveas.append_text(_("Open"))
combo_saveas.append_text(_("Save"))
vseparator_options = gtk.VSeparator()
hbox_options.pack_start(vseparator_options, False, False, 10)
checkbox_add_field_names = gtk.CheckButton(_("Add _field names"))
checkbox_add_field_names.set_active(True)
hbox_options.pack_start(checkbox_add_field_names, False, False, 0)
button_cancel = gtk.Button("gtk-cancel", stock="gtk-cancel")
self.dialog.add_action_widget(button_cancel, gtk.RESPONSE_CANCEL)
button_cancel.set_flags(gtk.CAN_DEFAULT)
button_ok = gtk.Button("gtk-ok", stock="gtk-ok")
self.dialog.add_action_widget(button_ok, gtk.RESPONSE_OK)
button_ok.set_flags(gtk.CAN_DEFAULT)
self.dialog.vbox.pack_start(vbox)
self.ids = ids
self.model = model
self.context = context
self.view1 = gtk.TreeView()
self.view1.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.view1.connect('row-expanded', self.on_row_expanded)
scrolledwindow_all_fields.add(self.view1)
self.view2 = gtk.TreeView()
self.view2.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
scrolledwindow_export.add(self.view2)
self.view1.set_headers_visible(False)
self.view2.set_headers_visible(False)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn('Field name', cell, text=0)
self.view1.append_column(column)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn('Field name', cell, text=0)
self.view2.append_column(column)
self.model1 = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
self.fields = {}
self.model_populate(self._get_fields(model))
self.view1.set_model(self.model1)
self.view1.connect('row-activated', self.sig_sel)
self.view2.set_model(self.model2)
self.view2.connect('row-activated', self.sig_unsel)
if sys.platform != 'darwin':
self.view2.drag_source_set(
gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON3_MASK,
[('EXPORT_TREE', gtk.TARGET_SAME_WIDGET, 0)],
gtk.gdk.ACTION_MOVE)
self.view2.drag_dest_set(
gtk.DEST_DEFAULT_ALL,
[('EXPORT_TREE', gtk.TARGET_SAME_WIDGET, 0)],
gtk.gdk.ACTION_MOVE)
self.view2.connect('drag-begin', self.drag_begin)
self.view2.connect('drag-motion', self.drag_motion)
self.view2.connect('drag-drop', self.drag_drop)
self.view2.connect("drag-data-get", self.drag_data_get)
self.view2.connect('drag-data-received', self.drag_data_received)
self.view2.connect('drag-data-delete', self.drag_data_delete)
self.wid_action = combo_saveas
self.wid_write_field_names = checkbox_add_field_names
self.wid_action.set_active(0)
# Creating the predefined export view
self.pref_export = gtk.TreeView()
self.pref_export.append_column(
gtk.TreeViewColumn(_('Name'), gtk.CellRendererText(), text=2))
scrolledwindow_exports.add(self.pref_export)
self.pref_export.connect("button-press-event", self.export_click)
self.pref_export.connect("key-press-event", self.export_keypress)
# Fill the predefined export tree view
self.predef_model = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_PYOBJECT,
gobject.TYPE_STRING)
self.fill_predefwin()
sensible_allocation = self.sensible_widget.get_allocation()
self.dialog.set_default_size(int(sensible_allocation.width * 0.9),
int(sensible_allocation.height * 0.9))
self.dialog.show_all()
common.center_window(self.dialog, self.parent, self.sensible_widget)
self.register()
def __init__(self, parent=None):
hildon.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.set_title(self.__class__.__name__)
hbox = gtk.HBox(False, 8)
self.add(hbox)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
hbox.pack_start(sw, True, True, 0)
model = self.__create_model()
treeview = gtk.TreeView(model)
treeview.set_headers_visible(True)
sw.add(treeview)
column = gtk.TreeViewColumn()
column.set_title("Macro")
cell_renderer = gtk.CellRendererPixbuf()
column.pack_start(cell_renderer, False)
column.set_attributes(cell_renderer, stock_id=1)
cell_renderer = gtk.CellRendererText()
column.pack_start(cell_renderer, True)
column.set_cell_data_func(cell_renderer, macro_set_func_text)
treeview.append_column(column)
cell_renderer = gtk.CellRendererText()
treeview.insert_column_with_data_func(-1, "Label", cell_renderer,
label_set_func)
cell_renderer = gtk.CellRendererText()
treeview.insert_column_with_data_func(-1, "Accel", cell_renderer,
accel_set_func)
cell_renderer = gtk.CellRendererText()
treeview.insert_column_with_data_func(-1, "ID", cell_renderer,
id_set_func)
align = gtk.Alignment(0.5, 0.0, 0.0, 0.0)
hbox.pack_end(align, False, False, 0)
frame = gtk.Frame("Selected Item")
align.add(frame)
vbox = gtk.VBox(False, 8)
vbox.set_border_width(4)
frame.add(vbox)
display = StockItemDisplay()
treeview.set_data("stock-display", display)
display.type_label = gtk.Label()
display.macro_label = gtk.Label()
display.id_label = gtk.Label()
display.label_accel_label = gtk.Label()
display.icon_image = gtk.Image()
# empty image
vbox.pack_start(display.type_label, False, False, 0)
vbox.pack_start(display.icon_image, False, False, 0)
vbox.pack_start(display.label_accel_label, False, False, 0)
vbox.pack_start(display.macro_label, False, False, 0)
vbox.pack_start(display.id_label, False, False, 0)
selection = treeview.get_selection()
selection.set_mode(gtk.SELECTION_SINGLE)
selection.connect("changed", self.on_selection_changed)
self.show_all()
def __init__(self):
gtk.ToolItem.__init__(self)
preview = ColorPreview()
self.dropdown_button = dropdownpanel.DropdownPanelButton(preview)
self.preview_size = _get_icon_size()
self.connect("toolbar-reconfigured", self._toolbar_reconf_cb)
self.connect("create-menu-proxy", lambda *a: True)
self.set_tooltip_text(_("Color History and other tools"))
self.add(self.dropdown_button)
from application import get_app
app = get_app()
app.brush.observers.append(self._brush_settings_changed_cb)
preview.color = app.brush_color_manager.get_color()
self._app = app
self._main_preview = preview
panel_frame = gtk.Frame()
panel_frame.set_shadow_type(gtk.SHADOW_OUT)
self.dropdown_button.set_property("panel-widget", panel_frame)
panel_vbox = gtk.VBox()
panel_vbox.set_spacing(widgets.SPACING_TIGHT)
panel_vbox.set_border_width(widgets.SPACING)
panel_frame.add(panel_vbox)
def hide_panel_cb(*a):
self.dropdown_button.panel_hide()
def hide_panel_idle_cb(*a):
gobject.idle_add(self.dropdown_button.panel_hide)
# Colour changing
section_frame = widgets.section_frame(_("Change Color"))
panel_vbox.pack_start(section_frame, True, True)
section_table = gtk.Table()
section_table.set_col_spacings(widgets.SPACING)
section_table.set_border_width(widgets.SPACING)
section_frame.add(section_table)
hsv_widget = HSVTriangle()
hsv_widget.set_size_request(175, 175)
hsv_widget.set_color_manager(app.brush_color_manager)
section_table.attach(hsv_widget, 0, 1, 0, 1)
preview_hbox = gtk.HBox()
color_picker = ColorPickerButton()
preview_adj = PreviousCurrentColorAdjuster()
preview_adj.set_color_manager(app.brush_color_manager)
color_picker.set_color_manager(app.brush_color_manager)
preview_hbox.pack_start(color_picker, False, False)
preview_hbox.pack_start(preview_adj, True, True)
side_vbox = gtk.VBox()
side_vbox.set_spacing(widgets.SPACING_TIGHT)
section_table.attach(side_vbox, 1, 2, 0, 1)
def init_proxy(widget, action_name):
action = app.find_action(action_name)
assert action is not None, \
"Must be able to find action %s" % (action_name,)
widget.set_related_action(action)
widget.connect("clicked", hide_panel_cb)
return widget
button = init_proxy(gtk.Button(), "ColorDetailsDialog")
side_vbox.pack_end(button, False, False)
side_vbox.pack_end(preview_hbox, False, False)
side_vbox.pack_end(gtk.Alignment(), True, True)
button = init_proxy(gtk.ToggleButton(), "HCYWheelTool")
button.set_label(_("HCY Wheel"))
side_vbox.pack_end(button, False, False)
button = init_proxy(gtk.ToggleButton(), "PaletteTool")
button.set_label(_("Color Palette"))
side_vbox.pack_end(button, False, False)
# History
section_frame = widgets.section_frame(_("Recently Used"))
panel_vbox.pack_start(section_frame, True, True)
history = ColorHistoryView(app)
history.button_clicked += self._history_button_clicked
section_frame.add(history)
