def __init__(self, winMain):
self.winMain = winMain
gtk.Table.__init__(self, 3, 3, False)
# Ruler horizontal/vertical
self.hruler = gtk.HRuler()
self.hruler.set_metric(gtk.PIXELS)
self.hruler.set_range(0, 11111, 0, 11111)
self.vruler = gtk.VRuler()
self.vruler.set_metric(gtk.PIXELS)
self.vruler.set_range(0, 11111, 0, 11111)
# Scrolled Window containing drawing Area
self.area = gtk.DrawingArea()
self.area.set_events(gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK)
self.area.set_size_request(11111, 11111)
self.area.connect("expose-event", self.area_expose_cb)
self.sw = gtk.ScrolledWindow()
self.sw.add_with_viewport(self.area)
self.attach(self.hruler, 1, 2, 0, 1,
gtk.EXPAND | gtk.SHRINK | gtk.FILL, gtk.FILL,
0, 0)
self.attach(self.vruler, 0, 1, 1, 2, gtk.FILL,
gtk.EXPAND | gtk.SHRINK | gtk.FILL, 0, 0)
self.attach(self.sw, 1, 2, 1, 2, gtk.FILL, gtk.FILL, 0, 0)
# Tell mouse motion to rulers for updating the mouse position marker.
def motion_notify(ruler, event):
return ruler.emit("motion_notify_event", event)
self.sw.connect_object("motion_notify_event",
motion_notify, self.hruler)
self.sw.connect_object("motion_notify_event",
motion_notify, self.vruler)
# Set ruler scaling regarding to the visible area
def size_allocate_cb(wid, allocation):
x, y, w, h = allocation
#print("x: %d y: %d w:%d h:%d" % (x,y,w,h))
lower, upper, pos, maxSize = self.hruler.get_range()
maxSize = max(maxSize, w)
self.hruler.set_range(lower, lower + w, pos, maxSize)
lower, upper, pos, maxSize = self.vruler.get_range()
maxSize = max(maxSize, h)
self.vruler.set_range(lower, lower + h, pos, maxSize)
self.sw.connect('size-allocate', size_allocate_cb)
# Recalculate ruler ranges with respect to scroll window and mouse position
def val_cb(adj, ruler, horiz):
#print("lower: %d value: %d upper-page_size:%d upper:%d, page_size:%d" % (adj.lower, adj.value, adj.upper-adj.page_size,adj.upper,adj.page_size))
#position of the scrollbar between 'lower' and 'upper -page_size'.
#lower is 0, upper is the maximum value of the scroll region (self.are.set_size_request()), page_size is the scroll knob length.
v = adj.value
if horiz:
span = self.sw.get_allocation().width
else:
span = self.sw.get_allocation().height
lower, upper, pos, maxSize = ruler.get_range()
ruler.set_range(v, v + span, pos - v, maxSize)
while gtk.events_pending():
gtk.main_iteration()
self.hadj = self.sw.get_hadjustment()
self.hadj.connect('value-changed', val_cb, self.hruler,
True)
self.vadj = self.sw.get_vadjustment()
self.vadj.connect('value-changed', val_cb, self.vruler,
False)
self.hruler.show()
self.vruler.show()
self.sw.show()
self.area.show()
self.show()
def getScreen(self, anaconda):
self.neededSwap = 0
self.storage = anaconda.id.storage
self.intf = anaconda.intf
self.dispatch = anaconda.dispatch
rc = anaconda.id.upgradeSwapInfo
self.neededSwap = 1
self.row = 0
box = gtk.VBox(False, 5)
box.set_border_width(5)
label = gtk.Label(
_("Recent kernels (2.4 or newer) need significantly more "
"swap than older kernels, up to twice "
"the amount of RAM on the system. "
"You currently have %dMB of swap configured, but "
"you may create additional swap space on one of "
"your file systems now.") % (iutil.swapAmount() / 1024) +
_("\n\nThe installer has detected %s MB of RAM.\n") %
(iutil.memInstalled() / 1024))
label.set_alignment(0.5, 0.0)
# label.set_size_request(400, 200)
label.set_line_wrap(True)
box.pack_start(label, False)
hs = gtk.HSeparator()
box.pack_start(hs, False)
self.option1 = gtk.RadioButton(None,
(_("I _want to create a swap file")))
box.pack_start(self.option1, False)
(fsList, suggSize, suggMntPoint) = rc
self.swapbox = gtk.VBox(False, 5)
box.pack_start(self.swapbox, False)
label = gui.MnemonicLabel(
_("Select the _partition to put the swap file on:"))
a = gtk.Alignment(0.2, 0.5)
a.add(label)
self.swapbox.pack_start(a, False)
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
for (dev, size) in fsList:
iter = self.store.append()
self.store.set_value(iter, 0, dev)
self.store.set_value(iter, 1, str(size))
self.view = gtk.TreeView(self.store)
label.set_mnemonic_widget(self.view)
i = 0
for title in [(_("Mount Point")), (_("Partition")),
(_("Free Space (MB)"))]:
col = gtk.TreeViewColumn(title, gtk.CellRendererText(), text=i)
self.view.append_column(col)
i = i + 1
sw = gtk.ScrolledWindow()
sw.add(self.view)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_size_request(300, 90)
a = gtk.Alignment(0.5, 0.5)
a.add(sw)
self.swapbox.pack_start(a, False, True, 10)
rootiter = self.store.get_iter_first()
sel = self.view.get_selection()
sel.select_iter(rootiter)
label = gtk.Label(
_("A minimum swap file size of "
"%d MB is recommended. Please enter a size for the swap "
"file:") % suggSize)
label.set_size_request(400, 40)
label.set_line_wrap(True)
a = gtk.Alignment(0.5, 0.5)
a.add(label)
self.swapbox.pack_start(a, False, True, 10)
hbox = gtk.HBox(False, 5)
a = gtk.Alignment(0.4, 0.5)
a.add(hbox)
self.swapbox.pack_start(a, False)
label = gui.MnemonicLabel(_("Swap file _size (MB):"))
hbox.pack_start(label, False)
self.entry = gtk.Entry(4)
label.set_mnemonic_widget(self.entry)
self.entry.set_size_request(40, 25)
self.entry.set_text(str(suggSize))
hbox.pack_start(self.entry, False, True, 10)
self.option2 = gtk.RadioButton(self.option1,
(_("I _don't want to create a swap "
"file")))
box.pack_start(self.option2, False, True, 20)
self.option1.connect("toggled", self.toggle)
return box
def __init__(self, maitansetup, *args, **kwargs):
gtk.Window.__init__(self, *args, **kwargs)
if (maitansetup):
self.setup = maitansetup
else:
self.setup = MaitanSetup()
accelgroup = gtk.AccelGroup()
self.add_accel_group(accelgroup)
item_quit = gtk.ImageMenuItem(gtk.STOCK_QUIT, accelgroup)
menu_file = gtk.Menu()
menu_file.add(item_quit)
self.item_file = gtk.MenuItem('_File')
self.item_file.props.submenu = menu_file
menubar = gtk.MenuBar()
menubar.append(self.item_file)
self.textbuf = gtk.TextBuffer()
self.textbuf.set_text(self.setup.get_default_document())
self.textview = gtk.TextView(self.textbuf)
self.textview.set_wrap_mode(gtk.WRAP_CHAR)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(self.textview)
self.button_cut = gtk.Button(stock=gtk.STOCK_EXECUTE)
self.button_paste = gtk.Button(stock=gtk.STOCK_PREFERENCES)
self.button_clear = gtk.Button(stock=gtk.STOCK_CLEAR)
notebook = gtk.Notebook()
notebook.set_tab_pos(gtk.POS_BOTTOM)
vbox_img = gtk.VBox()
notebook.append_page(vbox_img, gtk.Label("Image"))
hbox_imgctl = gtk.HBox()
self.zoom_ratio = gtk.Adjustment(value=30,
lower=5,
upper=200,
step_incr=5)
self.zoom_ratio.connect('value-changed', self.draw_image)
sb = gtk.SpinButton(self.zoom_ratio)
hbox_imgctl.pack_end(sb, expand=False, fill=False)
hbox_imgctl.pack_end(gtk.Label("Zoom for preview (%): "),
expand=False,
fill=False)
self.image = gtk.Image()
self.image_exists = False
self.image.set_from_stock(gtk.STOCK_DIALOG_ERROR, gtk.ICON_SIZE_DIALOG)
self.imagebuf = None
sw_img = gtk.ScrolledWindow()
sw_img.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw_img.add_with_viewport(self.image)
vbox_img.pack_start(sw_img, expand=True, fill=True)
vbox_img.pack_start(hbox_imgctl, expand=False, fill=False)
self.textbuf_log = gtk.TextBuffer()
self.textview_log = gtk.TextView(self.textbuf_log)
self.textview_log.set_wrap_mode = gtk.WRAP_CHAR
self.textview_log.set_editable(False)
sw_log = gtk.ScrolledWindow()
sw_log.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw_log.add(self.textview_log)
notebook.append_page(sw_log, gtk.Label("Log"))
hbox_btn = gtk.HButtonBox()
hbox_btn.pack_start(self.button_cut, expand=False, fill=False)
hbox_btn.pack_start(self.button_clear, expand=False, fill=False)
hbox_btn.pack_start(self.button_paste, expand=False, fill=False)
box = gtk.VBox(spacing=3)
box.pack_start(sw)
box.pack_start(hbox_btn, expand=False, fill=False)
paned = gtk.VPaned()
paned.add1(box)
paned.add2(notebook)
vbox = gtk.VBox()
vbox.pack_start(menubar, expand=False, fill=False)
vbox.pack_start(paned)
self.clipboard = gtk.Clipboard()
self.clipboard_primary = gtk.Clipboard(selection='PRIMARY')
self.connect('delete_event', gtk.main_quit)
item_quit.connect('activate', gtk.main_quit)
self.button_cut.connect('clicked', self.on_button_cut_clicked)
self.button_paste.connect('clicked', self.on_button_paste_clicked)
self.button_clear.connect('clicked', self.on_button_clear_clicked)
# self.clipboard.connect('owner-change', self.on_clipboard_owner_change)
self.add(vbox)
self.set_size_request(350, 300)
def create_mainwin_widgets(self):
self.datascrollwin = gtk.ScrolledWindow(None, None)
FuelpadAbstractWindow.create_mainwin_widgets(self)
hbox = gtk.HBox()
text = gtk.Entry()
hbox.pack_start(text)
hbox.pack_start(go)
window.add(hbox)
browser = webkit.WebView()
window.add(browser)
browser.show()
browser.open("http://www.example.com")
scroller = gtk.ScrolledWindow()
scroller.add(browser)
window.add(scroller)
scroller.show()
window.show_all()
window.remove(scroller)
vbox = gtk.VBox()
window.add(vbox)
vbox.pack_start(hbox)
vbox.show()
vbox.pack_start(scroller)
print text.get_text()
def goclicked(btn):
class EdMainWindow():
def __init__(self, fname, parent, names):
self.full = False
self.statuscount = 0
self.alt = False
register_stock_icons()
global mained
mained = self
# Create the toplevel window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window = window
www = gtk.gdk.screen_width()
hhh = gtk.gdk.screen_height()
if pedconfig.conf.full_screen:
window.set_default_size(www, hhh)
else:
xx = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/xx")
yy = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/yy")
ww = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/ww")
hh = gconf.client_get_default().get_int(pedconfig.conf.config_reg +
"/hh")
if ww == 0 or hh == 0:
window.set_position(gtk.WIN_POS_CENTER)
window.set_default_size(7 * www / 8, 5 * hhh / 8)
window.move(www / 32, hhh / 10)
else:
window.set_default_size(ww, hh)
window.move(xx, yy)
window.set_icon_from_file(get_img_path("pyedit.png"))
merge = gtk.UIManager()
window.set_data("ui-manager", merge)
aa = create_action_group(self)
merge.insert_action_group(aa, 0)
window.add_accel_group(merge.get_accel_group())
try:
mergeid = merge.add_ui_from_string(ui_info)
except gobject.GError, msg:
print "Building menus failed: %s" % msg
# Add MRU
for cnt in range(6):
ss = "/sess_%d" % cnt
fname = gconf.client_get_default().get_string\
(pedconfig.conf.config_reg + ss)
if fname != "":
self.add_mru(merge, aa, fname, ss)
merge_id = merge.new_merge_id()
merge.add_ui(merge_id, "ui/MenuBar/FileMenu/SaveAs", "", None,
gtk.UI_MANAGER_SEPARATOR, False)
mbar = merge.get_widget("/MenuBar")
mbar.show()
window.set_events(gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK
| gtk.gdk.FOCUS_CHANGE_MASK)
#window.set_events( gtk.gdk.ALL_EVENTS_MASK)
global notebook
# Create note for the main window, give access to it for all
notebook = gtk.Notebook()
notebook.popup_enable()
notebook.set_scrollable(True)
#notebook.add_events(gtk.gdk.FOCUS_CHANGE_MASK)
notebook.add_events(gtk.gdk.ALL_EVENTS_MASK)
notebook.connect("switch-page", self.note_swpage_cb)
notebook.connect("focus-in-event", self.note_focus_in)
# Futile attempts
#notebook.connect("change-current-page", self.note_page_cb)
#notebook.connect("grab-focus", self.note_grab_focus_cb)
#notebook.connect("focus", self.note_focus_cb)
#notebook.connect("create-window", self.note_create_cb)
#notebook.connect("enter-notify-event", self.note_enter_notify)
window.connect("window_state_event", self.update_resize_grip)
window.connect("destroy", OnExit)
window.connect("key-press-event", self.area_key)
window.connect("key-release-event", self.area_key)
#window.connect("set-focus", self.area_focus)
window.connect("focus-in-event", self.area_focus_in)
window.connect("focus-out-event", self.area_focus_out)
window.connect("window-state-event", self.area_winstate)
#window.connect("area-focus-event", self.area_focus_in)
#window.connect("event", self.area_event)
#window.connect("enter-notify-event", self.area_enter)
#window.connect("leave-notify-event", self.area_leave)
#window.connect("event", self.unmap)
table = gtk.Table(2, 4, False)
window.add(table)
table.attach(
mbar,
# X direction # # Y direction
0,
1,
0,
1,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
tbar = merge.get_widget("/ToolBar")
tbar.set_tooltips(True)
tbar.show()
table.attach(
tbar,
# X direction # # Y direction
0,
1,
1,
2,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
hpaned = gtk.HPaned()
hpaned.set_border_width(5)
scroll = gtk.ScrolledWindow()
treeview = self.create_tree()
treeview.connect("row-activated", self.tree_sel)
treeview.connect("cursor-changed", self.tree_sel_row)
self.treeview = treeview
scroll.add(treeview)
frame2 = gtk.Frame()
frame2.add(scroll)
hpaned.add(frame2)
self.hpanepos = gconf.client_get_default(). \
get_int(pedconfig.conf.config_reg + "/hpaned")
if self.hpanepos == 0: self.hpanepos = 200
hpaned.set_position(self.hpanepos)
hpaned.pack2(notebook)
self.hpaned = hpaned
# Create statusbars
self.statusbar = gtk.Statusbar()
self.statusbar2 = gtk.Statusbar()
slab = gtk.Label(" ")
hpane2 = gtk.HPaned()
hpane2.set_position(self.get_width() - 200)
hpane2.pack2(self.statusbar2)
shbox = gtk.HBox()
shbox.pack_start(slab, False)
shbox.pack_start(self.statusbar)
hpane2.pack1(shbox)
# Main Pane
table.attach(
hpaned,
# X direction Y direction
0,
1,
2,
3,
gtk.EXPAND | gtk.FILL,
gtk.EXPAND | gtk.FILL,
0,
0)
table.attach(
hpane2,
#table.attach(self.statusbar,
# X direction Y direction
0,
1,
3,
4,
gtk.EXPAND | gtk.FILL,
0,
0,
0)
window.show_all()
# ----------------------------------------------------------------
cnt = 0
# Read in buffers
for aa in names:
aaa = os.path.realpath(aa)
#print "loading file: ", aaa
vpaned = edPane()
ret = vpaned.area.loadfile(aaa)
if not ret:
self.update_statusbar("Cannot read file '{0:s}'".format(aaa))
continue
ret = vpaned.area2.loadfile(aaa)
cnt += 1
notebook.append_page(vpaned)
vpaned.area.set_tablabel()
if cnt == 0:
#print "No file on command line, creating new", os.getcwd()
fcnt = gconf.client_get_default().get_int\
(pedconfig.conf.config_reg + "/cnt")
# Load old session
for nnn in range(fcnt):
ss = "/sess_%d" % nnn
fff = gconf.client_get_default().get_string\
(pedconfig.conf.config_reg + ss)
#print "loading ", fff
vpaned = edPane()
ret = vpaned.area.loadfile(fff)
if not ret:
self.update_statusbar(
"Cannot read file '{0:s}'".format(fff))
continue
vpaned.area2.loadfile(fff)
notebook.append_page(vpaned)
vpaned.area.set_tablabel()
# Show newly created buffers:
window.show_all()
# Set last file
fff = gconf.client_get_default().get_string\
(pedconfig.conf.config_reg + "/curr")
#print "curr file", fff
cc = notebook.get_n_pages()
for mm in range(cc):
vcurr = notebook.get_nth_page(mm)
if vcurr.area.fname == fff:
#print "found buff", fff
notebook.set_current_page(mm)
self.window.set_focus(vcurr.vbox.area)
break
# Set the signal handler for 1s tick
signal.signal(signal.SIGALRM, handler)
signal.alarm(1)
self.update_statusbar("Initial")
def __init__(self):
super(PyApp, self).__init__()
self.sr = None
self.configWindow("VariationDetector", 1000, 700)
self.configureSerial()
self.loopTime = 5
self.timeoutHandler = gtk.timeout_add(self.loopTime, self.process)
"""
#f = open("/Users/clemi/Work/canonair/mbed/Captures/Autre.txt",'r')
f = open("/Users/clemi/Work/canonair/mbed/Captures/Peugeot407-capture8.txt",'r')
self.data = f.read().split("\n")
f.close()
#print(self.data)
self.q = Queue.Queue()
for d in self.data:
p = d.split(":")[1].strip().replace("[","").replace("]","").replace("|"," ").split(" ")
#print(p)
t = "caca %s %s %s" %(p[2],p[3],p[4])
for i in p[5:]:
t += ' %s' %i
#print(t)
self.q.put(t)
"""
self.g = SimpleGraph(700, 250, 500, 8)
#for i in range(50):
# self.g.appendPoint(i*3)
self.indexStart = 0
self.iterStart = None
self.rolling = False
self.size = 0
self.framesDisp = {}
self.frames = {}
self.framesOld = {}
# Build The HBOX
self.hbox = gtk.HBox(False, 3)
self.add(self.hbox)
# Build The VBox
self.vbox1 = gtk.VBox(False, 3)
self.vbox1.set_size_request(200, 700)
self.hbox.pack_start(self.vbox1, False, False, 0)
# Add the scrolled view
self.sw = gtk.ScrolledWindow()
self.sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.sw.set_size_request(200, 550)
#self.hbox.pack_start(self.sw,False,False,0);
#self.hbox.add(self.sw)
self.vbox1.pack_start(self.sw, False, False, 0)
#self.vbox.add(self.sw)
self.rollingButton = gtk.CheckButton("Rolling")
self.rollingButton.set_size_request(200, 50)
self.rollingButton.set_active(False)
self.rollingButton.unset_flags(gtk.CAN_FOCUS)
self.rollingButton.connect("clicked", self.onRolling)
self.vbox1.add(self.rollingButton)
self.graphButton = gtk.ToggleButton("Add Graph")
self.graphButton.set_size_request(200, 50)
self.graphButton.connect("clicked", self.onGraph)
self.vbox1.add(self.graphButton)
self.stopButton = gtk.ToggleButton("Stop")
self.stopButton.set_size_request(200, 50)
self.stopButton.connect("clicked", self.onStop)
self.vbox1.add(self.stopButton)
# Create the store
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
self.store.append(["all", False])
#self.store.append(["240",False])
self.treeView = gtk.TreeView(self.store)
#self.treeView.connect("row-activated", self.on_activated)
self.treeView.set_rules_hint(True)
self.sw.add(self.treeView)
# Create the column renderers
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("ID", rendererText, text=0)
column.set_sort_column_id(0)
self.treeView.append_column(column)
rendererToggle = gtk.CellRendererToggle()
rendererToggle.set_property('activatable', True)
rendererToggle.connect('toggled', self.col1_toggled_cb, self.store)
column = gtk.TreeViewColumn("Visible", rendererToggle, text=0)
column.add_attribute(rendererToggle, "active", 1)
column.set_sort_column_id(1)
self.treeView.append_column(column)
# Add the Second VBox
self.vbox2 = gtk.VBox(False, 3)
self.hbox.add(self.vbox2)
# Add the Text View
self.entry = gtk.TextView()
self.entry.set_size_request(200, 400)
self.entry.add_events(gtk.gdk.KEY_RELEASE_MASK)
self.entry.connect("copy-clipboard", self.cpyClipBoard)
self.vbox2.pack_start(self.entry, False, False, 0)
# Add the drawing area
self.sw2 = gtk.ScrolledWindow()
self.drawingArea = gtk.DrawingArea()
self.drawingArea.set_size_request(250, 500)
self.sw2.add_with_viewport(self.drawingArea)
self.drawingArea.connect("expose-event", self.area_expose_cb)
self.vbox2.add(self.sw2)
# Get the buffer
self.buffer = self.entry.get_buffer()
self.c_tag = []
for i in range(255):
self.c_tag.append(
self.buffer.create_tag("colored%s" % i,
foreground="#%02x0000" % i,
weight=pango.WEIGHT_BOLD))
fontdesc = pango.FontDescription("monospace")
self.entry.modify_font(fontdesc)
self.show_all()
self.count = 0
Yiddish (ײַדישע) דאָס הײַזעלע
Japanese (日本語) こんにちは, ｺﾝﾆﾁﾊ
Chinese (中文,普通话,汉语) 你好
Cantonese (粵語,廣東話) 早晨, 你好
Korean (한글) 안녕하세요, 안녕하십니까
Difference among chinese characters in GB, JIS, KSC, BIG5:
GB -- 元气 开发
JIS -- 元気 開発
KSC -- 元氣 開發
BIG5 -- 元氣 開發
'''
win = hildon.Window()
win.connect('destroy', gtk.main_quit)
#win.set_default_size(600, 400)
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
win.add(swin)
swin.show()
l = gtk.Label(hellos)
swin.add_with_viewport(l)
l.show()
win.show()
gtk.main()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_resizable(True)
self.window.set_size_request(450,540)
self.window.connect("destroy", self.close_application)
self.window.connect("key_press_event", self.key_pressed)
self.handler = self.window.connect("key_release_event", self.key_released)
self.window.set_title("Devanagari Editor")
self.window.set_border_width(0)
self.window.set_icon_from_file("DElogo.ico")
menubar = gtk.MenuBar()
menu_file = gtk.Menu()
menu_edit = gtk.Menu()
menu_help = gtk.Menu()
item_open = gtk.MenuItem("Open")
item_open.connect("activate", self.open_devanagari_file)
item_save = gtk.MenuItem("Save")
item_save.connect("activate", self.save_devanagari_file)
item_quit = gtk.MenuItem("Quit")
item_quit.connect("activate", self.close_application)
menu_file.append(item_open)
menu_file.append(item_save)
menu_file.append(item_quit)
item_cut = gtk.MenuItem("Cut")
item_copy = gtk.MenuItem("Copy")
item_paste = gtk.MenuItem("Paste")
menu_edit.append(item_cut)
menu_edit.append(item_copy)
menu_edit.append(item_paste)
item_about = gtk.MenuItem("About")
menu_help.append(item_about)
item_file = gtk.MenuItem("File")
item_edit = gtk.MenuItem("Edit")
item_help = gtk.MenuItem("Help")
item_file.set_submenu(menu_file)
item_edit.set_submenu(menu_edit)
item_help.set_submenu(menu_help)
menubar.append(item_file)
menubar.append(item_edit)
menubar.append(item_help)
self.box1 = gtk.VBox(False, 0)
self.window.add(self.box1)
self.box1.show()
self.box1.pack_start(menubar, False, False, 0)
box2 = gtk.VBox(False, 0)
box2.set_border_width(0)
self.box1.pack_start(box2, True, True, 0)
box2.show()
# the source text buffer
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.textview = gtk.TextView()
self.textbuffer = self.textview.get_buffer()
self.textview.set_wrap_mode(gtk.WRAP_WORD)
self.textview.modify_font(pango.FontDescription("Sans 12"))
sw.add(self.textview)
sw.show()
self.textview.show()
box2.pack_start(sw)
self.Mode = 'Devanagari'
# clipboard
self.clipboard = gtk.Clipboard(gtk.gdk.display_get_default(), "CLIPBOARD")
# show the window
self.window.show_all()
def __init__(self,
model,
callback,
sel_multi=True,
context=None,
domain=None,
view_ids=None,
views_preload=None,
new=True):
NoModal.__init__(self)
if views_preload is None:
views_preload = {}
self.domain = domain or []
self.context = context or {}
self.sel_multi = sel_multi
self.callback = callback
self.win = gtk.Dialog(_('Search'), self.parent,
gtk.DIALOG_DESTROY_WITH_PARENT)
self.win.set_icon(TRYTON_ICON)
self.win.set_has_separator(True)
self.win.set_default_response(gtk.RESPONSE_APPLY)
self.win.connect('response', self.response)
self.accel_group = gtk.AccelGroup()
self.win.add_accel_group(self.accel_group)
self.but_cancel = self.win.add_button(gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL)
self.but_find = self.win.add_button(gtk.STOCK_FIND, gtk.RESPONSE_APPLY)
if new and common.MODELACCESS[model]['create']:
self.but_new = self.win.add_button(gtk.STOCK_NEW,
gtk.RESPONSE_ACCEPT)
self.but_new.set_accel_path('<tryton>/Form/New', self.accel_group)
self.but_ok = self.win.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
self.but_ok.add_accelerator('clicked', self.accel_group,
gtk.keysyms.Return, gtk.gdk.CONTROL_MASK,
gtk.ACCEL_VISIBLE)
hbox = gtk.HBox()
hbox.show()
self.win.vbox.pack_start(hbox, expand=False, fill=True)
self.win.vbox.pack_start(gtk.HSeparator(), expand=False, fill=True)
scrollwindow = gtk.ScrolledWindow()
scrollwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.win.vbox.pack_start(scrollwindow, expand=True, fill=True)
self.screen = Screen(model,
domain=domain,
mode=['tree'],
context=context,
view_ids=view_ids,
views_preload=views_preload,
row_activate=self.sig_activate)
self.view = self.screen.current_view
self.view.unset_editable()
# Prevent to set tree_state
self.screen.tree_states_done.add(id(self.view))
sel = self.view.treeview.get_selection()
if not sel_multi:
sel.set_mode(gtk.SELECTION_SINGLE)
else:
sel.set_mode(gtk.SELECTION_MULTIPLE)
viewport = gtk.Viewport()
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.add(self.screen.widget)
self.screen.widget.show()
viewport.show()
scrollwindow.add(viewport)
scrollwindow.show()
self.model_name = model
self.win.set_size_request(700, 500)
self.register()
sensible_allocation = self.sensible_widget.get_allocation()
self.win.set_default_size(int(sensible_allocation.width * 0.9),
int(sensible_allocation.height * 0.9))
def __init__(self):
# Create a new dialog window for the scrolled window to be
# packed into.
window = gtk.Dialog()
window.connect("destroy", self.destroy)
window.set_title("ScrolledWindow example")
window.set_border_width(0)
window.set_size_request(300, 300)
# create a new scrolled window.
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_border_width(10)
# the policy is one of POLICY AUTOMATIC, or POLICY_ALWAYS.
# POLICY_AUTOMATIC will automatically decide whether you need
# scrollbars, whereas POLICY_ALWAYS will always leave the scrollbars
# there. The first one is the horizontal scrollbar, the second, the
# vertical.
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
# The dialog window is created with a vbox packed into it.
window.vbox.pack_start(scrolled_window, gtk.TRUE, gtk.TRUE, 0)
scrolled_window.show()
# create the layout widget and pack into the table
self.layout = gtk.Layout(None, None)
self.layout.set_size(600, 600)
# pack the table into the scrolled window
scrolled_window.add_with_viewport(self.layout)
self.layout.show()
# create 3 buttons and put them into the layout widget
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 0, 0)
button.show()
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 100, 0)
button.show()
button = gtk.Button("Press Me")
button.connect("clicked", self.ButtonClicked)
self.layout.put(button, 200, 0)
button.show()
# Add a "close" button to the bottom of the dialog
button = gtk.Button("close")
button.connect_object("clicked", self.destroy, window)
# this makes it so the button is the default.
button.set_flags(gtk.CAN_DEFAULT)
window.action_area.pack_start( button, gtk.TRUE, gtk.TRUE, 0)
# This grabs this button to be the default button. Simply hitting
# the "Enter" key will cause this button to activate.
button.grab_default()
# show all the widgets
button.show()
window.show()
def __init__(self, hosts=None, owner=None, poll_interval=None):
gobject.threads_init()
set_exception_hook_dialog("cylc gscan")
setup_icons()
if not hosts:
hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"])
self.hosts = hosts
if owner is None:
owner = USER
self.owner = owner
self.window = gtk.Window()
self.window.set_title("cylc gscan")
self.window.set_icon(get_icon())
self.vbox = gtk.VBox()
self.vbox.show()
self.theme_name = gcfg.get(['use theme'])
self.theme = gcfg.get(['themes', self.theme_name])
self.dots = DotMaker(self.theme)
suite_treemodel = gtk.TreeStore(str, str, bool, str, int, str, str)
self._prev_tooltip_location_id = None
self.suite_treeview = gtk.TreeView(suite_treemodel)
# Construct the host column.
host_name_column = gtk.TreeViewColumn("Host")
cell_text_host = gtk.CellRendererText()
host_name_column.pack_start(cell_text_host, expand=False)
host_name_column.set_cell_data_func(
cell_text_host, self._set_cell_text_host)
host_name_column.set_sort_column_id(0)
host_name_column.set_visible("host" in gsfg.get(["columns"]))
host_name_column.set_resizable(True)
# Construct the suite name column.
suite_name_column = gtk.TreeViewColumn("Suite")
cell_text_name = gtk.CellRendererText()
suite_name_column.pack_start(cell_text_name, expand=False)
suite_name_column.set_cell_data_func(
cell_text_name, self._set_cell_text_name)
suite_name_column.set_sort_column_id(1)
suite_name_column.set_visible("suite" in gsfg.get(["columns"]))
suite_name_column.set_resizable(True)
# Construct the suite title column.
suite_title_column = gtk.TreeViewColumn("Title")
cell_text_title = gtk.CellRendererText()
suite_title_column.pack_start(cell_text_title, expand=False)
suite_title_column.set_cell_data_func(
cell_text_title, self._set_cell_text_title)
suite_title_column.set_sort_column_id(3)
suite_title_column.set_visible("title" in gsfg.get(
["columns"]))
suite_title_column.set_resizable(True)
# Construct the update time column.
time_column = gtk.TreeViewColumn("Updated")
cell_text_time = gtk.CellRendererText()
time_column.pack_start(cell_text_time, expand=False)
time_column.set_cell_data_func(
cell_text_time, self._set_cell_text_time)
time_column.set_sort_column_id(4)
time_column.set_visible("updated" in gsfg.get(["columns"]))
time_column.set_resizable(True)
self.suite_treeview.append_column(host_name_column)
self.suite_treeview.append_column(suite_name_column)
self.suite_treeview.append_column(suite_title_column)
self.suite_treeview.append_column(time_column)
# Construct the status column.
status_column = gtk.TreeViewColumn("Status")
status_column.set_sort_column_id(5)
status_column.set_visible("status" in gsfg.get(["columns"]))
status_column.set_resizable(True)
status_column_info = 6
cycle_column_info = 5
cell_text_cycle = gtk.CellRendererText()
status_column.pack_start(cell_text_cycle, expand=False)
status_column.set_cell_data_func(
cell_text_cycle, self._set_cell_text_cycle, cycle_column_info)
self.suite_treeview.append_column(status_column)
for i in range(len(TASK_STATUSES_ORDERED)):
cell_pixbuf_state = gtk.CellRendererPixbuf()
status_column.pack_start(cell_pixbuf_state, expand=False)
status_column.set_cell_data_func(
cell_pixbuf_state, self._set_cell_pixbuf_state,
(status_column_info, i)
)
self.suite_treeview.show()
if hasattr(self.suite_treeview, "set_has_tooltip"):
self.suite_treeview.set_has_tooltip(True)
try:
self.suite_treeview.connect('query-tooltip',
self._on_query_tooltip)
except TypeError:
# Lower PyGTK version.
pass
self.suite_treeview.connect("button-press-event",
self._on_button_press_event)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.suite_treeview)
scrolled_window.show()
self.vbox.pack_start(scrolled_window, expand=True, fill=True)
self.updater = ScanAppUpdater(
self.hosts, suite_treemodel, self.suite_treeview,
owner=self.owner, poll_interval=poll_interval
)
self.updater.start()
self.window.add(self.vbox)
self.window.connect("destroy", self._on_destroy_event)
self.window.set_default_size(300, 150)
self.suite_treeview.grab_focus()
self.window.show()
def __init__(self, config, parent=None):
Window.__init__(self)
if parent is None:
self.mainwindow = self # temp hack to make modal win32 file choosers work
else:
self.mainwindow = parent # temp hack to make modal win32 file choosers work
self.connect('destroy', self.quit)
self.set_title('%s metafile creator %s' % (app_name, version))
self.set_border_width(SPACING)
self.set_position(gtk.WIN_POS_CENTER)
self.config = config
right_column_width = 276
self.box = gtk.VBox(spacing=SPACING)
self.table = gtk.Table(rows=3, columns=2, homogeneous=False)
self.table.set_col_spacings(SPACING)
self.table.set_row_spacings(SPACING)
y = 0
# file list
self.table.attach(
lalign(gtk.Label('Make .atorrent metafiles for these files:')),
0,
2,
y,
y + 1,
xoptions=gtk.FILL,
yoptions=gtk.FILL,
)
y += 1
self.file_store = gtk.ListStore(gobject.TYPE_STRING)
for i in range(8):
self.file_store.append(('foo', ))
self.file_scroll = gtk.ScrolledWindow()
self.file_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.file_scroll.set_shadow_type(gtk.SHADOW_OUT)
self.file_list = gtk.TreeView(self.file_store)
r = gtk.CellRendererText()
column = gtk.TreeViewColumn('_Files', r, text=0)
self.file_list.append_column(column)
self.file_list.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
file_list_height = self.file_list.size_request()[1] + SCROLLBAR_WIDTH
self.file_store.clear()
self.file_scroll.set_size_request(-1, file_list_height)
self.file_scroll.add(self.file_list)
self.table.attach(self.file_scroll,
0,
2,
y,
y + 1,
yoptions=gtk.EXPAND | gtk.FILL)
y += 1
self.file_list_button_box = gtk.HBox(homogeneous=True, spacing=SPACING)
self.add_button = gtk.Button("Add Files")
self.add_button.connect('clicked', self.choose_files)
self.file_list_button_box.pack_start(self.add_button)
self.add_folder_button = gtk.Button("Add Folders")
self.add_folder_button.connect('clicked', self.choose_folders)
self.file_list_button_box.pack_start(self.add_folder_button)
self.remove_button = gtk.Button(stock=gtk.STOCK_REMOVE)
self.remove_button.connect('clicked', self.remove_selection)
self.remove_button.set_sensitive(False)
self.file_list_button_box.pack_start(self.remove_button)
self.clear_button = gtk.Button(stock=gtk.STOCK_CLEAR)
self.clear_button.connect('clicked', self.clear_file_list)
self.clear_button.set_sensitive(False)
self.file_list_button_box.pack_start(self.clear_button)
self.table.attach(self.file_list_button_box,
0,
2,
y,
y + 1,
xoptions=gtk.FILL,
yoptions=0)
y += 1
# Announce
self.table.attach(ralign(gtk.Label('Announce URL:')),
0,
1,
y,
y + 1,
xoptions=gtk.FILL,
yoptions=0)
self.announce_entry = gtk.Entry()
self.announce_entry.set_text(self.config['tracker_name'])
self.announce_entry.set_size_request(right_column_width, -1)
self.table.attach(self.announce_entry,
1,
2,
y,
y + 1,
xoptions=gtk.FILL | gtk.EXPAND,
yoptions=0)
y += 1
# Piece size
self.table.attach(ralign(gtk.Label('Piece size:')),
0,
1,
y,
y + 1,
xoptions=gtk.FILL,
yoptions=0)
self.piece_size = gtk.combo_box_new_text()
self.piece_size.offset = 15
for i in range(7):
self.piece_size.append_text(
str(Size(2**(i + self.piece_size.offset))))
self.piece_size.set_active(self.config['piece_size_pow2'] -
self.piece_size.offset)
self.piece_size_box = gtk.HBox(spacing=SPACING)
self.piece_size_box.pack_start(self.piece_size,
expand=False,
fill=False)
self.table.attach(self.piece_size_box,
1,
2,
y,
y + 1,
xoptions=gtk.FILL | gtk.EXPAND,
yoptions=0)
y += 1
self.box.pack_start(self.table, expand=True, fill=True)
self.buttonbox = gtk.HBox(homogeneous=True, spacing=SPACING)
self.quitbutton = gtk.Button(stock=gtk.STOCK_QUIT)
self.quitbutton.connect('clicked', self.quit)
self.buttonbox.pack_start(self.quitbutton, expand=True, fill=True)
self.buttonbox.pack_start(gtk.Label(''), expand=True, fill=True)
self.makebutton = IconButton('Make', stock=gtk.STOCK_EXECUTE)
self.makebutton.connect('clicked', self.make)
self.makebutton.set_sensitive(False)
self.buttonbox.pack_end(self.makebutton, expand=True, fill=True)
self.box.pack_end(self.buttonbox, expand=False, fill=False)
self.announce_entry.connect('changed', self.check_buttons)
self.file_store.connect('row-changed', self.check_buttons)
sel = self.file_list.get_selection()
sel.connect('changed', self.check_buttons)
self.add(self.box)
# HelpWindow(None, makeHelp('btmaketorrentgui', defaults))
self.show_all()
from gettext import gettext as _
import gtk
from sugar.graphics.toolbutton import ToolButton
from sugar.graphics.icon import Icon
from sugar.graphics import style
import logging
''' Set up a help palette for the main toolbars '''
help_palettes = {}
help_windows = {}
help_box = gtk.VBox()
help_box.set_homogeneous(False)
help_palettes['main-toolbar'] = help_box
help_windows['main-toolbar'] = gtk.ScrolledWindow()
help_windows['main-toolbar'].set_size_request(
int(gtk.gdk.screen_width() / 3),
gtk.gdk.screen_height() - style.GRID_CELL_SIZE * 3)
help_windows['main-toolbar'].set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
help_windows['main-toolbar'].add_with_viewport(help_palettes['main-toolbar'])
help_palettes['main-toolbar'].show()
class HelpButton(gtk.ToolItem):
def __init__(self, activity):
self._activity = activity
gtk.ToolItem.__init__(self)
help_button = ToolButton('toolbar-help')
def __init__(self, columns):
gtk.VBox.__init__(self, False, 6)
self.table_tree = gtk.TreeView()
self.table_tree.set_headers_visible(True)
self.table_tree.set_headers_clickable(True)
self.table_tree.set_enable_search(True)
self.table_tree.set_rules_hint(True)
self.table_tree.set_enable_tree_lines(True)
self.table_tree.get_selection().set_mode(gtk.SELECTION_SINGLE)
self.toggle_columns = []
self.table_tree.connect("row-activated", self.row_activated_cb)
for i, column in enumerate(columns):
col = gtk.TreeViewColumn(column['col_name'])
col.set_clickable(True)
col.set_resizable(True)
col.set_sort_column_id(column['col_id'])
if 'col_min' in column.keys():
col.set_min_width(column['col_min'])
if 'col_max' in column.keys():
col.set_max_width(column['col_max'])
if 'expand' in column.keys():
col.set_expand(True)
self.table_tree.append_column(col)
if (not 'col_style'
in column.keys()) or column['col_style'] == 'text':
cell = gtk.CellRendererText()
col.pack_start(cell, True)
col.set_attributes(cell, text=column['col_id'])
if 'col_t_id' in column.keys():
col.add_attribute(cell, 'font', column['col_t_id'])
elif column['col_style'] == 'check toggle':
cell = HobCellRendererToggle()
cell.set_property('activatable', True)
cell.connect("toggled", self.toggled_cb, i, self.table_tree)
cell.connect_render_state_changed(self.stop_cell_fadeinout_cb,
self.table_tree)
self.toggle_id = i
col.pack_end(cell, True)
col.set_attributes(cell, active=column['col_id'])
self.toggle_columns.append(column['col_name'])
if 'col_group' in column.keys():
col.set_cell_data_func(cell, self.set_group_number_cb)
elif column['col_style'] == 'radio toggle':
cell = gtk.CellRendererToggle()
cell.set_property('activatable', True)
cell.set_radio(True)
cell.connect("toggled", self.toggled_cb, i, self.table_tree)
self.toggle_id = i
col.pack_end(cell, True)
col.set_attributes(cell, active=column['col_id'])
self.toggle_columns.append(column['col_name'])
elif column['col_style'] == 'binb':
cell = gtk.CellRendererText()
col.pack_start(cell, True)
col.set_cell_data_func(cell, self.display_binb_cb,
column['col_id'])
if 'col_t_id' in column.keys():
col.add_attribute(cell, 'font', column['col_t_id'])
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
scroll.add(self.table_tree)
self.pack_start(scroll, True, True, 0)
def gen_shared_sstate_widget(self, sstatemirrors_list, window):
hbox = gtk.HBox(False)
sstatemirrors_store = gtk.ListStore(str, str, str)
for sstatemirror in sstatemirrors_list:
sstatemirrors_store.append(sstatemirror)
self.sstatemirrors_tv = gtk.TreeView()
self.sstatemirrors_tv.set_rules_hint(True)
self.sstatemirrors_tv.set_headers_visible(True)
tree_selection = self.sstatemirrors_tv.get_selection()
tree_selection.set_mode(gtk.SELECTION_SINGLE)
# Allow enable drag and drop of rows including row move
self.sstatemirrors_tv.enable_model_drag_source(
gtk.gdk.BUTTON1_MASK, self.TARGETS,
gtk.gdk.ACTION_DEFAULT | gtk.gdk.ACTION_MOVE)
self.sstatemirrors_tv.enable_model_drag_dest(self.TARGETS,
gtk.gdk.ACTION_DEFAULT)
self.sstatemirrors_tv.connect("drag_data_get", self.drag_data_get_cb)
self.sstatemirrors_tv.connect("drag_data_received",
self.drag_data_received_cb)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.scroll.set_shadow_type(gtk.SHADOW_IN)
self.scroll.connect('size-allocate', self.scroll_changed)
self.scroll.add(self.sstatemirrors_tv)
#list store for cell renderer
m = gtk.ListStore(gobject.TYPE_STRING)
m.append(["Standard"])
m.append(["Custom"])
cell0 = gtk.CellRendererCombo()
cell0.set_property("model", m)
cell0.set_property("text-column", 0)
cell0.set_property("editable", True)
cell0.set_property("has-entry", False)
col0 = gtk.TreeViewColumn("Configuration")
col0.pack_start(cell0, False)
col0.add_attribute(cell0, "text", 0)
col0.set_cell_data_func(cell0, self.configuration_field)
self.sstatemirrors_tv.append_column(col0)
cell0.connect("edited", self.combo_changed, sstatemirrors_store)
self.cell1 = gtk.CellRendererText()
self.cell1.set_padding(5, 2)
col1 = gtk.TreeViewColumn('Regex', self.cell1)
col1.set_cell_data_func(self.cell1, self.regex_field)
self.sstatemirrors_tv.append_column(col1)
self.cell1.connect("edited", self.regex_changed, sstatemirrors_store)
cell2 = gtk.CellRendererText()
cell2.set_padding(5, 2)
cell2.set_property("editable", True)
col2 = gtk.TreeViewColumn('URL', cell2)
col2.set_cell_data_func(cell2, self.url_field)
self.sstatemirrors_tv.append_column(col2)
cell2.connect("edited", self.url_changed, sstatemirrors_store)
self.sstatemirrors_tv.set_model(sstatemirrors_store)
self.sstatemirrors_tv.set_cursor(self.selected_mirror_row)
hbox.pack_start(self.scroll, expand=True, fill=True)
hbox.show_all()
return hbox, sstatemirrors_store
def create_ui(self):
self.set_border_width(5)
app_vbox = gtk.VBox(spacing=5)
self.module_hbox = gtk.HBox(spacing=5)
app_vbox.pack_start(self.module_hbox, fill=False, expand=False)
label = gtk.Label()
label.set_markup('<b>%s</b>' % _('Choose Module:'))
self.module_hbox.pack_start(label, fill=False, expand=False)
self.module_combo = gtk.ComboBox(self.modules_list_model)
cell = gtk.CellRendererText()
self.module_combo.pack_start(cell, True)
self.module_combo.add_attribute(cell, 'text', 0)
self.module_combo.changed_signal_id = self.module_combo.connect(
'changed', self.on_module_selection_changed_cb)
self.module_combo.set_row_separator_func(lambda x, y: x.get(y, 1)[0])
self.module_hbox.pack_start(self.module_combo, fill=True)
separator = gtk.VSeparator()
self.module_hbox.pack_start(separator, fill=False, expand=False)
preferences = gtk.Button(stock=gtk.STOCK_PREFERENCES)
preferences.connect('clicked', self.on_preferences_cb)
self.module_hbox.pack_start(preferences, fill=False, expand=False)
self.progressbar = gtk.ProgressBar()
self.progressbar.set_text(_('Build Progress'))
app_vbox.pack_start(self.progressbar, fill=False, expand=False)
expander = gtk.Expander(_('Terminal'))
expander.set_expanded(False)
app_vbox.pack_start(expander, fill=False, expand=False)
sclwin = gtk.ScrolledWindow()
sclwin.set_size_request(-1, 300)
sclwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
expander.add(sclwin)
if vte:
self.terminal = vte.Terminal()
self.terminal.connect('child-exited', self.on_vte_child_exit_cb)
else:
os.environ['TERM'] = 'dumb' # avoid commands printing vt sequences
self.terminal = gtk.TextView()
self.terminal.set_size_request(800, -1)
textbuffer = self.terminal.get_buffer()
terminal_bold_tag = textbuffer.create_tag('bold')
terminal_bold_tag.set_property('weight', pango.WEIGHT_BOLD)
terminal_mono_tag = textbuffer.create_tag('mono')
terminal_mono_tag.set_property('family', 'Monospace')
terminal_stdout_tag = textbuffer.create_tag('stdout')
terminal_stdout_tag.set_property('family', 'Monospace')
terminal_stderr_tag = textbuffer.create_tag('stderr')
terminal_stderr_tag.set_property('family', 'Monospace')
terminal_stderr_tag.set_property('foreground', 'red')
terminal_stdin_tag = textbuffer.create_tag('stdin')
terminal_stdin_tag.set_property('family', 'Monospace')
terminal_stdin_tag.set_property('style', pango.STYLE_ITALIC)
self.terminal.set_editable(False)
self.terminal.set_wrap_mode(gtk.WRAP_CHAR)
sclwin.add(self.terminal)
self.terminal_sclwin = sclwin
self.error_hbox = self.create_error_hbox()
app_vbox.pack_start(self.error_hbox, fill=False, expand=False)
buttonbox = gtk.HButtonBox()
buttonbox.set_layout(gtk.BUTTONBOX_END)
app_vbox.pack_start(buttonbox, fill=False, expand=False)
# Translators: This is a button label (to start build)
self.build_button = gtk.Button(_('Start'))
self.build_button.connect('clicked', self.on_build_cb)
buttonbox.add(self.build_button)
button = gtk.Button(stock=gtk.STOCK_HELP)
button.connect('clicked', self.on_help_cb)
buttonbox.add(button)
buttonbox.set_child_secondary(button, True)
app_vbox.show_all()
self.error_hbox.hide()
self.add(app_vbox)
def gen_editable_settings(self, setting, tooltip=""):
setting_hbox = gtk.HBox(False, 12)
vbox = gtk.VBox(False, 12)
setting_hbox.pack_start(vbox, expand=True, fill=True)
setting_store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
for key in setting.keys():
setting_store.set(setting_store.append(), 0, key, 1, setting[key])
setting_tree = gtk.TreeView(setting_store)
setting_tree.set_headers_visible(True)
setting_tree.set_size_request(300, 100)
col = gtk.TreeViewColumn('Key')
col.set_min_width(100)
col.set_max_width(150)
col.set_resizable(True)
col1 = gtk.TreeViewColumn('Value')
col1.set_min_width(100)
col1.set_max_width(150)
col1.set_resizable(True)
setting_tree.append_column(col)
setting_tree.append_column(col1)
cell = gtk.CellRendererText()
cell.set_property('width-chars', 10)
cell.set_property('editable', True)
cell.set_data("column", 0)
cell.connect("edited", self.editable_settings_cell_edited,
setting_store)
cell1 = gtk.CellRendererText()
cell1.set_property('width-chars', 10)
cell1.set_property('editable', True)
cell1.set_data("column", 1)
cell1.connect("edited", self.editable_settings_cell_edited,
setting_store)
col.pack_start(cell, True)
col1.pack_end(cell1, True)
col.set_attributes(cell, text=0)
col1.set_attributes(cell1, text=1)
scroll = gtk.ScrolledWindow()
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(setting_tree)
vbox.pack_start(scroll, expand=True, fill=True)
# some buttons
hbox = gtk.HBox(True, 6)
vbox.pack_start(hbox, False, False)
button = gtk.Button(stock=gtk.STOCK_ADD)
button.connect("clicked", self.editable_settings_add_item_clicked,
setting_store)
hbox.pack_start(button)
button = gtk.Button(stock=gtk.STOCK_REMOVE)
button.connect("clicked", self.editable_settings_remove_item_clicked,
setting_tree)
hbox.pack_start(button)
info = HobInfoButton(tooltip, self)
setting_hbox.pack_start(info, expand=False, fill=False)
return setting_hbox, setting_store
def __init__(self, box, conf, ind):
self.conf = conf
self.ind = ind
for key in settings:
if not key in conf.launcher[ind]:
conf.launcher[ind][key] = settings[key]
self.settings = conf.launcher[ind]
mixerbox = gtk.HBox(False, 0)
box.pack_start(mixerbox, False, False)
label = gtk.Label("Mixer :")
label.set_alignment(0, 0.5)
self.mixer = gtk.combo_box_entry_new_text()
mixer_list = ("aumix", "xfce4-mixer", "xterm -e alsamixer",
"alsamixergui", "gamix", "gmixer", "gnome-alsamixer",
"gnome-volume-control", "pavucontrol")
if not conf.launcher[ind]['mixer'] in mixer_list:
mixer_list = (conf.launcher[ind]['mixer'], ) + mixer_list
ind_mixer = 0 # FIXME !!
for mixer in mixer_list:
self.mixer.append_text(mixer)
if mixer == conf.launcher[ind]['mixer']:
self.mixer.set_active(ind_mixer)
ind_mixer += 1
self.mixer.child.connect('changed', self.changed_mixer)
mixerbox.pack_start(label)
mixerbox.pack_start(self.mixer)
self.alsactrl = AlsaControl(int(self.settings["card_index"]),
self.settings["control"])
""" Initialize treeview with mixers """
self.liststore = gtk.ListStore(bool, str, int)
for mixer in self.alsactrl.get_mixers():
active = (mixer == self.settings["control"])
if active:
self.liststore.append([active, mixer, pango.WEIGHT_BOLD])
else:
self.liststore.append([active, mixer, pango.WEIGHT_NORMAL])
self.treeview = gtk.TreeView(self.liststore)
self.treeview.set_headers_visible(False)
cell1 = gtk.CellRendererToggle()
cell1.set_radio(True)
cell1.set_property("activatable", True)
cell1.connect('toggled', self.on_treeview_toggled, self.liststore)
column1 = gtk.TreeViewColumn()
column1.pack_start(cell1, True)
column1.add_attribute(cell1, 'active', 0)
self.treeview.append_column(column1)
cell2 = gtk.CellRendererText()
column2 = gtk.TreeViewColumn()
column2.pack_start(cell2, True)
column2.add_attribute(cell2, 'text', 1)
column2.add_attribute(cell2, 'weight', 2)
self.treeview.append_column(column2)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwindow.add(self.treeview)
""" Initialize combobox with list of audio cards """
icon = Core.pixbuf_from_file('images/conf/audio-card.png', 22, 22)
self.combo_model = gtk.ListStore(int, gtk.gdk.Pixbuf, str)
cards = self.alsactrl.get_cards()
for index, card in enumerate(cards):
if card is not None:
self.combo_model.append([index, icon, card])
card_combobox = gtk.ComboBox()
card_combobox.set_model(self.combo_model)
card_combobox.set_active(int(self.settings["card_index"]))
cell1 = gtk.CellRendererPixbuf()
cell1.set_property("xalign", 0)
cell1.set_property("xpad", 3)
card_combobox.pack_start(cell1, False)
card_combobox.add_attribute(cell1, "pixbuf", 1)
cell2 = gtk.CellRendererText()
cell2.set_property("xpad", 10)
card_combobox.pack_start(cell2, True)
card_combobox.set_attributes(cell2, text=2)
card_combobox.connect("changed", self.on_card_combobox_changed)
box.pack_start(card_combobox, False, False)
box.pack_end(scrolledwindow, True)
def __init__(self, parent, application):
SettingsPage.__init__(self, parent, application, 'accelerators',
_('Key bindings'))
# create list box
container = gtk.ScrolledWindow()
container.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
container.set_shadow_type(gtk.SHADOW_IN)
self._accels = gtk.TreeStore(str, str, int, int, int, int)
self._accels.set_sort_column_id(Column.TITLE, gtk.SORT_ASCENDING)
self._list = gtk.TreeView()
self._list.set_model(self._accels)
self._list.set_rules_hint(True)
self._list.set_enable_search(True)
self._list.set_search_column(Column.TITLE)
# create and configure cell renderers
cell_name = gtk.CellRendererText()
cell_primary = gtk.CellRendererAccel()
cell_secondary = gtk.CellRendererAccel()
cell_primary.set_property('accel-mode',
gtk.CELL_RENDERER_ACCEL_MODE_OTHER)
cell_primary.set_property('editable', True)
cell_primary.connect('accel-edited', self.__accel_edited, True)
cell_primary.connect('accel-cleared', self.__accel_cleared, True)
cell_secondary.set_property('accel-mode',
gtk.CELL_RENDERER_ACCEL_MODE_OTHER)
cell_secondary.set_property('editable', True)
cell_secondary.connect('accel-edited', self.__accel_edited, False)
cell_secondary.connect('accel-cleared', self.__accel_cleared, False)
# create and pack columns
col_name = gtk.TreeViewColumn(_('Description'),
cell_name,
markup=Column.TITLE)
col_name.set_min_width(200)
col_name.set_resizable(True)
col_name.set_sort_column_id(Column.TITLE)
col_name.set_sort_order(gtk.SORT_ASCENDING)
col_primary = gtk.TreeViewColumn(_('Primary'),
cell_primary,
accel_key=Column.PRIMARY_KEY,
accel_mods=Column.PRIMARY_MODS)
col_primary.set_min_width(100)
col_secondary = gtk.TreeViewColumn(_('Secondary'),
cell_secondary,
accel_key=Column.SECONDARY_KEY,
accel_mods=Column.SECONDARY_MODS)
col_secondary.set_min_width(100)
self._list.append_column(col_name)
self._list.append_column(col_primary)
self._list.append_column(col_secondary)
# warning label
label_warning = gtk.Label(
_('<b>Note:</b> You can only edit accelerators from '
'objects created at least once in current session. '
'To disable accelerator press <i>Backspace</i> '
'in assign mode.'))
label_warning.set_alignment(0, 0)
label_warning.set_use_markup(True)
label_warning.set_line_wrap(True)
label_warning.connect('size-allocate', self._adjust_label)
# pack interface
container.add(self._list)
self.pack_start(label_warning, False, False, 0)
self.pack_start(container, True, True, 0)
def __init__(self, dbstate, uistate, track=[]):
self.dbstate = dbstate
self.__uistate = uistate
self.title = _("Plugin Manager")
ManagedWindow.ManagedWindow.__init__(self, uistate, track,
self.__class__)
self.__pmgr = GuiPluginManager.get_instance()
self.__preg = PluginRegister.get_instance()
self.set_window(
gtk.Dialog("", uistate.window, gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)), None,
self.title)
self.window.set_size_request(750, 400)
self.window.connect('response', self.close)
notebook = gtk.Notebook()
#first page with all registered plugins
vbox_reg = gtk.VBox()
scrolled_window_reg = gtk.ScrolledWindow()
self.list_reg = gtk.TreeView()
# model: plugintype, hidden, pluginname, plugindescr, pluginid
self.model_reg = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.selection_reg = self.list_reg.get_selection()
self.list_reg.set_model(self.model_reg)
self.list_reg.set_rules_hint(True)
self.list_reg.connect('button-press-event', self.button_press_reg)
col0_reg = gtk.TreeViewColumn(_('Type'),
gtk.CellRendererText(),
text=0)
col0_reg.set_sort_column_id(0)
col0_reg.set_resizable(True)
self.list_reg.append_column(col0_reg)
col = gtk.TreeViewColumn(_('Status'), gtk.CellRendererText(), markup=1)
col.set_sort_column_id(1)
self.list_reg.append_column(col)
col2_reg = gtk.TreeViewColumn(_('Name'),
gtk.CellRendererText(),
text=2)
col2_reg.set_sort_column_id(2)
col2_reg.set_resizable(True)
self.list_reg.append_column(col2_reg)
col = gtk.TreeViewColumn(_('Description'),
gtk.CellRendererText(),
text=3)
col.set_sort_column_id(3)
col.set_resizable(True)
self.list_reg.append_column(col)
self.list_reg.set_search_column(2)
scrolled_window_reg.add(self.list_reg)
vbox_reg.pack_start(scrolled_window_reg)
hbutbox = gtk.HButtonBox()
hbutbox.set_layout(gtk.BUTTONBOX_SPREAD)
self.__info_btn = gtk.Button(_("Info"))
hbutbox.add(self.__info_btn)
self.__info_btn.connect('clicked', self.__info, self.list_reg,
4) # id_col
self.__hide_btn = gtk.Button(_("Hide/Unhide"))
hbutbox.add(self.__hide_btn)
self.__hide_btn.connect('clicked', self.__hide, self.list_reg, 4,
1) # list, id_col, hide_col
if __debug__:
self.__edit_btn = gtk.Button(_("Edit"))
hbutbox.add(self.__edit_btn)
self.__edit_btn.connect('clicked', self.__edit, self.list_reg,
4) # id_col
self.__load_btn = gtk.Button(_("Load"))
hbutbox.add(self.__load_btn)
self.__load_btn.connect('clicked', self.__load, self.list_reg,
4) # id_col
vbox_reg.pack_start(hbutbox, expand=False, padding=5)
notebook.append_page(vbox_reg,
tab_label=gtk.Label(_('Registered Plugins')))
#second page with loaded plugins
vbox_loaded = gtk.VBox()
scrolled_window = gtk.ScrolledWindow()
self.list = gtk.TreeView()
self.model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, object,
gobject.TYPE_STRING, gobject.TYPE_STRING)
self.selection = self.list.get_selection()
self.list.set_model(self.model)
self.list.set_rules_hint(True)
self.list.connect('button-press-event', self.button_press)
self.list.connect('cursor-changed', self.cursor_changed)
col = gtk.TreeViewColumn(_('Loaded'), gtk.CellRendererText(), markup=0)
col.set_sort_column_id(0)
col.set_resizable(True)
self.list.append_column(col)
col1 = gtk.TreeViewColumn(_('File'), gtk.CellRendererText(), text=1)
col1.set_sort_column_id(1)
col1.set_resizable(True)
self.list.append_column(col1)
col = gtk.TreeViewColumn(_('Status'), gtk.CellRendererText(), markup=5)
col.set_sort_column_id(5)
self.list.append_column(col)
col2 = gtk.TreeViewColumn(_('Message'), gtk.CellRendererText(), text=2)
col2.set_sort_column_id(2)
col2.set_resizable(True)
self.list.append_column(col2)
self.list.set_search_column(1)
scrolled_window.add(self.list)
vbox_loaded.pack_start(scrolled_window)
hbutbox = gtk.HButtonBox()
hbutbox.set_layout(gtk.BUTTONBOX_SPREAD)
self.__info_btn = gtk.Button(_("Info"))
hbutbox.add(self.__info_btn)
self.__info_btn.connect('clicked', self.__info, self.list, 4) # id_col
self.__hide_btn = gtk.Button(_("Hide/Unhide"))
hbutbox.add(self.__hide_btn)
self.__hide_btn.connect('clicked', self.__hide, self.list, 4,
5) # list, id_col, hide_col
if __debug__:
self.__edit_btn = gtk.Button(_("Edit"))
hbutbox.add(self.__edit_btn)
self.__edit_btn.connect('clicked', self.__edit, self.list,
4) # id_col
self.__load_btn = gtk.Button(_("Load"))
self.__load_btn.set_sensitive(False)
hbutbox.add(self.__load_btn)
self.__load_btn.connect('clicked', self.__load, self.list,
4) # id_col
vbox_loaded.pack_start(hbutbox, expand=False, padding=5)
notebook.append_page(vbox_loaded,
tab_label=gtk.Label(_('Loaded Plugins')))
#third page with method to install plugin
install_page = gtk.VBox()
scrolled_window = gtk.ScrolledWindow()
self.addon_list = gtk.TreeView()
# model: help_name, name, ptype, image, desc, use, rating, contact, download, url
self.addon_model = gtk.ListStore(
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.addon_list.set_model(self.addon_model)
self.addon_list.set_rules_hint(True)
#self.addon_list.connect('button-press-event', self.button_press)
col = gtk.TreeViewColumn(_('Addon Name'),
gtk.CellRendererText(),
text=1)
col.set_sort_column_id(1)
self.addon_list.append_column(col)
col = gtk.TreeViewColumn(_('Type'), gtk.CellRendererText(), text=2)
col.set_sort_column_id(2)
self.addon_list.append_column(col)
col = gtk.TreeViewColumn(_('Description'),
gtk.CellRendererText(),
text=4)
col.set_sort_column_id(4)
self.addon_list.append_column(col)
self.addon_list.connect('cursor-changed', self.button_press_addon)
install_row = gtk.HBox()
install_row.pack_start(gtk.Label(_("Path to Addon:")), expand=False)
self.install_addon_path = gtk.Entry()
button = gtk.Button()
img = gtk.Image()
img.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
button.add(img)
button.connect('clicked', self.__select_file)
install_row.pack_start(self.install_addon_path, expand=True)
install_row.pack_start(button, expand=False, fill=False)
scrolled_window.add(self.addon_list)
install_page.pack_start(scrolled_window)
#add some spce under the scrollbar
install_page.pack_start(gtk.Label(''), expand=False, fill=False)
#path to addon path line
install_page.pack_start(install_row, expand=False, fill=False)
hbutbox = gtk.HButtonBox()
hbutbox.set_layout(gtk.BUTTONBOX_SPREAD)
self.__add_btn = gtk.Button(_("Install Addon"))
hbutbox.add(self.__add_btn)
self.__add_btn.connect('clicked', self.__get_addon_top)
self.__add_all_btn = gtk.Button(_("Install All Addons"))
hbutbox.add(self.__add_all_btn)
self.__add_all_btn.connect('clicked', self.__get_all_addons)
self.__refresh_btn = gtk.Button(_("Refresh Addon List"))
hbutbox.add(self.__refresh_btn)
self.__refresh_btn.connect('clicked', self.__refresh_addon_list)
install_page.pack_start(hbutbox, expand=False, padding=5)
# notebook.append_page(install_page,
# tab_label=gtk.Label(_('Install Addons')))
#add the notebook to the window
self.window.vbox.add(notebook)
if __debug__:
# Only show the "Reload" button when in debug mode
# (without -O on the command line)
self.__reload_btn = gtk.Button(_("Reload"))
self.window.action_area.add(self.__reload_btn)
self.__reload_btn.connect('clicked', self.__reload)
#obtain hidden plugins from the pluginmanager
self.hidden = self.__pmgr.get_hidden_plugin_ids()
self.window.show_all()
self.__populate_lists()
self.list_reg.columns_autosize()
def __init__(self, session, on_new_conversation):
'''class constructor'''
gtk.VBox.__init__(self)
gui.MainWindowBase.__init__(self, session, on_new_conversation)
UserPanel = extension.get_default('user panel')
ContactList = extension.get_default('contact list')
self.below_menu = extension.get_and_instantiate('below menu', self)
self.below_panel = extension.get_and_instantiate('below panel', self)
self.below_userlist = extension.get_and_instantiate(
'below userlist', self)
self.contact_list = ContactList(session)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
scroll.set_border_width(1)
self.session.signals.contact_attr_changed.subscribe(
self._on_contact_attr_changed)
self.session.signals.close.subscribe(self.on_disconnect)
self.menu = None
self.contact_menu = None
self.group_menu = None
self._build_menus()
self.panel = UserPanel(session)
self.panel.nick.connect('text-changed', self._on_nick_changed)
self.panel.message.connect('text-changed', self._on_message_changed)
self.panel.mail.connect('button_release_event', self._on_mail_click)
self.panel.search.connect('toggled', self._on_search_toggled)
self.panel.enabled = False
self.entry = gtk.Entry()
self.entry.connect('changed', self._on_entry_changed)
self.entry.connect('key-press-event', self._on_entry_key_press)
self.pack_start(self.menu, False)
self.pack_start(self.below_menu, False)
self.pack_start(self.panel, False)
self.pack_start(self.below_panel, False)
self.pack_start(self.entry, False)
self.pack_start(scroll, True, True)
self.pack_start(self.below_userlist, False)
self.contact_list.contact_selected.subscribe(self._on_contact_selected)
self.contact_list.group_selected.subscribe(self._on_group_selected)
self.contact_list.contact_menu_selected.subscribe(
self._on_contact_menu_selected)
self.contact_list.group_menu_selected.subscribe(
self._on_group_menu_selected)
scroll.add(self.contact_list)
scroll.show_all()
if self.session.config.b_show_userpanel:
self.panel.hide()
self.session.config.subscribe(self._on_show_userpanel_changed,
'b_show_userpanel')
def __init__(self):
gtk.VBox.__init__(self, False, 2)
self.set_border_width(4)
self.store = gtk.ListStore(str, int, str)
self.view = gtk.TreeView(self.store)
self.view.set_rules_hint(True)
self.view.set_reorderable(True)
idx = 0
lbls = (_('Column title'), _('Column size'), _('Function/cfield'))
for lbl in lbls[:-1]:
rend = gtk.CellRendererText()
rend.set_property('editable', True)
rend.connect('edited', self.__on_rend_edited, idx)
col = gtk.TreeViewColumn(lbl, rend, text=idx)
self.view.append_column(col)
idx += 1
# Last column
model = gtk.ListStore(str)
cfields = AuditManager().get_configuration('global.cfields').keys()
cfields.sort()
for field in cfields:
model.append(['%' + field + '%'])
rend = gtk.CellRendererCombo()
rend.set_property('model', model)
rend.set_property('text-column', 0)
rend.set_property('editable', True)
rend.connect('edited', self.__on_rend_edited, idx)
self.view.props.has_tooltip = True
self.view.connect('query-tooltip', self.__on_query_tooltip)
col = gtk.TreeViewColumn(lbls[-1], rend, text=idx)
self.view.append_column(col)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.add(self.view)
bb = gtk.HButtonBox()
bb.set_layout(gtk.BUTTONBOX_END)
btn = gtk.Button(stock=gtk.STOCK_ADD)
btn.connect('clicked', self.__on_add_row)
bb.pack_start(btn)
btn = gtk.Button(stock=gtk.STOCK_REMOVE)
btn.connect('clicked', self.__on_remove_row)
bb.pack_start(btn)
self.pack_start(sw)
self.pack_end(bb, False, False)
# Let's populate
columns_str = Prefs()['gui.maintab.sniffview.columns'].value
for column_str in columns_str.split(','):
try:
label, pixel_size, eval_str = column_str.split('|', 2)
pixel_size = int(pixel_size)
self.store.append([label, pixel_size, eval_str])
except:
pass
self.widgets = []
def _createUI(self):
self.leftSizeGroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.hadj = gtk.Adjustment()
self.vadj = gtk.Adjustment()
# controls for tracks and layers
self._controls = TimelineControls()
controlwindow = gtk.ScrolledWindow(None, self.vadj)
controlwindow.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER)
controlwindow.add_with_viewport(self._controls)
controlwindow.set_size_request(-1, 1)
self.attach(controlwindow, 0, 1, 1, 2, xoptions=0)
# timeline ruler
self.ruler = ruler.ScaleRuler(self.hadj)
self.ruler.set_size_request(0, 25)
self.ruler.set_border_width(2)
self.ruler.connect("key-press-event", self._keyPressEventCb)
self.attach(self.ruler, 1, 2, 0, 1, yoptions=0)
# proportional timeline
self._canvas = TimelineCanvas(self.app)
timelinewindow = gtk.ScrolledWindow(self.hadj, self.vadj)
timelinewindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
timelinewindow.add(self._canvas)
#FIXME: remove padding between scrollbar and scrolled window
self.attach(timelinewindow, 1, 2, 1, 2)
# drag and drop
self.drag_dest_set(gtk.DEST_DEFAULT_MOTION, [dnd.FILESOURCE_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag-data-received", self._dragDataReceivedCb)
self.connect("drag-leave", self._dragLeaveCb)
self.connect("drag-drop", self._dragDropCb)
self.connect("drag-motion", self._dragMotionCb)
# toolbar actions
actions = (
("ZoomIn", gtk.STOCK_ZOOM_IN, None, None, ZOOM_IN, self._zoomInCb),
("ZoomOut", gtk.STOCK_ZOOM_OUT, None, None, ZOOM_OUT,
self._zoomOutCb),
)
selection_actions = (
("DeleteObj", gtk.STOCK_DELETE, None, "Delete", DELETE,
self.deleteSelected),
("UnlinkObj", "pitivi-unlink", None, "<Shift><Control>L", UNLINK,
self.unlinkSelected),
("LinkObj", "pitivi-link", None, "<Control>L", LINK,
self.linkSelected),
("UngroupObj", "pitivi-ungroup", None, "<Shift><Control>G",
UNGROUP, self.ungroupSelected),
("GroupObj", "pitivi-group", None, "<Control>G", GROUP,
self.groupSelected),
)
toggle_actions = (("Razor", "pitivi-split", _("Razor"), "<Ctrl>R",
RAZOR, self.toggleRazor), )
actiongroup = gtk.ActionGroup("timelinepermanent")
actiongroup.add_actions(actions)
actiongroup.add_toggle_actions(toggle_actions)
self.ui_manager.insert_action_group(actiongroup, 0)
actiongroup = gtk.ActionGroup("timelineselection")
actiongroup.add_actions(selection_actions)
self.link_action = actiongroup.get_action("LinkObj")
self.unlink_action = actiongroup.get_action("UnlinkObj")
self.group_action = actiongroup.get_action("GroupObj")
self.ungroup_action = actiongroup.get_action("UngroupObj")
self.delete_action = actiongroup.get_action("DeleteObj")
self.ui_manager.insert_action_group(actiongroup, -1)
self.ui_manager.add_ui_from_string(ui)
# drag and drop
self.drag_dest_set(gtk.DEST_DEFAULT_MOTION, [dnd.FILESOURCE_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag-data-received", self._dragDataReceivedCb)
self.connect("drag-leave", self._dragLeaveCb)
self.connect("drag-drop", self._dragDropCb)
self.connect("drag-motion", self._dragMotionCb)
self._canvas.connect("button-press-event", self._buttonPress)
self._canvas.connect("button-release-event", self._buttonRelease)
self._canvas.connect("key-press-event", self._keyPressEventCb)
def __init__(self,
partitions,
diskset,
intf,
parent,
origvgrequest,
isNew=0):
self.partitions = partitions
self.diskset = diskset
self.origvgrequest = origvgrequest
self.isNew = isNew
self.intf = intf
self.parent = parent
self.availlvmparts = self.partitions.getAvailLVMPartitions(
self.origvgrequest, self.diskset)
self.logvolreqs = self.partitions.getLVMLVForVG(self.origvgrequest)
self.origvolreqs = copy.copy(self.logvolreqs)
# if no PV exist, raise an error message and return
if len(self.availlvmparts) < 1:
self.intf.messageWindow(
_("Not enough physical volumes"),
_("At least one unused physical "
"volume partition is "
"needed to create an LVM Volume Group.\n\n"
"Create a partition or RAID array "
"of type \"physical volume (LVM)\" and then "
"select the \"LVM\" option again."),
custom_icon="error")
self.dialog = None
return
if isNew:
tstr = _("Make LVM Volume Group")
else:
try:
tstr = _("Edit LVM Volume Group: %s") % (
origvgrequest.volumeGroupName, )
except:
tstr = _("Edit LVM Volume Group")
dialog = gtk.Dialog(tstr, self.parent)
gui.addFrame(dialog)
dialog.add_button('gtk-cancel', 2)
dialog.add_button('gtk-ok', 1)
dialog.set_position(gtk.WIN_POS_CENTER)
maintable = gtk.Table()
maintable.set_row_spacings(5)
maintable.set_col_spacings(5)
row = 0
# volume group name
if not origvgrequest.getPreExisting():
lbl = createAlignedLabel(_("_Volume Group Name:"))
self.volnameEntry = gtk.Entry(16)
lbl.set_mnemonic_widget(self.volnameEntry)
if not self.isNew:
self.volnameEntry.set_text(self.origvgrequest.volumeGroupName)
else:
self.volnameEntry.set_text(
lvm.createSuggestedVGName(self.partitions))
else:
lbl = createAlignedLabel(_("Volume Group Name:"))
self.volnameEntry = gtk.Label(self.origvgrequest.volumeGroupName)
maintable.attach(lbl, 0, 1, row, row + 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
maintable.attach(self.volnameEntry, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, gtk.SHRINK)
row = row + 1
if not origvgrequest.getPreExisting():
lbl = createAlignedLabel(_("_Physical Extent:"))
(self.peOption, self.peOptionMenu) = self.createPEOptionMenu(
self.origvgrequest.pesize)
lbl.set_mnemonic_widget(self.peOption)
else:
# FIXME: this is a nice hack -- if we create the option menu, but
# don't display it, getting the value always returns what we init'd
# it to
lbl = createAlignedLabel(_("Physical Extent:"))
(self.peOption, self.peOptionMenu) = self.createPEOptionMenu(
self.origvgrequest.pesize)
self.peOption = gtk.Label(
self.prettyFormatPESize(origvgrequest.pesize))
maintable.attach(lbl, 0, 1, row, row + 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
maintable.attach(self.peOption, 1, 2, row, row + 1,
gtk.EXPAND | gtk.FILL, gtk.SHRINK)
row = row + 1
(self.lvmlist, sw) = self.createAllowedLvmPartitionsList(
self.availlvmparts, self.origvgrequest.physicalVolumes,
self.partitions, origvgrequest.getPreExisting())
if origvgrequest.getPreExisting():
self.lvmlist.set_sensitive(gtk.FALSE)
self.lvmlist.set_size_request(275, 80)
lbl = createAlignedLabel(_("Physical Volumes to _Use:"))
lbl.set_mnemonic_widget(self.lvmlist)
maintable.attach(lbl, 0, 1, row, row + 1)
maintable.attach(sw, 1, 2, row, row + 1)
row = row + 1
maintable.attach(createAlignedLabel(_("Used Space:")), 0, 1, row,
row + 1, gtk.EXPAND | gtk.FILL, gtk.SHRINK)
lbox = gtk.HBox()
self.usedSpaceLabel = gtk.Label("")
labelalign = gtk.Alignment()
labelalign.set(1.0, 0.5, 0.0, 0.0)
labelalign.add(self.usedSpaceLabel)
lbox.pack_start(labelalign, gtk.FALSE, gtk.FALSE)
self.usedPercentLabel = gtk.Label("")
labelalign = gtk.Alignment()
labelalign.set(1.0, 0.5, 0.0, 0.0)
labelalign.add(self.usedPercentLabel)
lbox.pack_start(labelalign, gtk.FALSE, gtk.FALSE, padding=10)
maintable.attach(lbox, 1, 2, row, row + 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
maintable.set_row_spacing(row, 0)
row = row + 1
maintable.attach(createAlignedLabel(_("Free Space:")), 0, 1, row,
row + 1, gtk.EXPAND | gtk.FILL, gtk.SHRINK)
lbox = gtk.HBox()
self.freeSpaceLabel = gtk.Label("")
labelalign = gtk.Alignment()
labelalign.set(1.0, 0.5, 0.0, 0.0)
labelalign.add(self.freeSpaceLabel)
lbox.pack_start(labelalign, gtk.FALSE, gtk.FALSE)
self.freePercentLabel = gtk.Label("")
labelalign = gtk.Alignment()
labelalign.set(1.0, 0.5, 0.0, 0.0)
labelalign.add(self.freePercentLabel)
lbox.pack_start(labelalign, gtk.FALSE, gtk.FALSE, padding=10)
maintable.attach(lbox, 1, 2, row, row + 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
maintable.set_row_spacing(row, 0)
row = row + 1
maintable.attach(createAlignedLabel(_("Total Space:")), 0, 1, row,
row + 1, gtk.EXPAND | gtk.FILL, gtk.SHRINK)
self.totalSpaceLabel = gtk.Label("")
labelalign = gtk.Alignment()
labelalign.set(0.0, 0.5, 0.0, 0.0)
labelalign.add(self.totalSpaceLabel)
maintable.attach(labelalign, 1, 2, row, row + 1, gtk.EXPAND | gtk.FILL,
gtk.SHRINK)
maintable.set_row_spacing(row, 5)
row = row + 1
# populate list of logical volumes
lvtable = gtk.Table()
lvtable.set_row_spacings(5)
lvtable.set_col_spacings(5)
self.logvolstore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
if self.logvolreqs:
for lvrequest in self.logvolreqs:
iter = self.logvolstore.append()
self.logvolstore.set_value(iter, 0,
lvrequest.logicalVolumeName)
if lvrequest.mountpoint is not None:
self.logvolstore.set_value(iter, 1, lvrequest.mountpoint)
else:
self.logvolstore.set_value(iter, 1, "")
self.logvolstore.set_value(
iter, 2, "%g" %
(lvrequest.getActualSize(self.partitions, self.diskset)))
self.logvollist = gtk.TreeView(self.logvolstore)
col = gtk.TreeViewColumn(_("Logical Volume Name"),
gtk.CellRendererText(),
text=0)
self.logvollist.append_column(col)
col = gtk.TreeViewColumn(_("Mount Point"),
gtk.CellRendererText(),
text=1)
self.logvollist.append_column(col)
col = gtk.TreeViewColumn(_("Size (MB)"),
gtk.CellRendererText(),
text=2)
self.logvollist.append_column(col)
self.logvollist.connect('row-activated', self.logvolActivateCb)
sw = gtk.ScrolledWindow()
sw.add(self.logvollist)
sw.set_size_request(100, 100)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
lvtable.attach(sw, 0, 1, 0, 1)
# button box of options
lvbbox = gtk.VBox()
add = gtk.Button(_("_Add"))
add.connect("clicked", self.addLogicalVolumeCB)
lvbbox.pack_start(add)
edit = gtk.Button(_("_Edit"))
edit.connect("clicked", self.editLogicalVolumeCB)
lvbbox.pack_start(edit)
delete = gtk.Button(_("_Delete"))
delete.connect("clicked", self.delLogicalVolumeCB)
lvbbox.pack_start(delete)
lvalign = gtk.Alignment()
lvalign.set(0.5, 0.0, 0.0, 0.0)
lvalign.add(lvbbox)
lvtable.attach(lvalign, 1, 2, 0, 1, gtk.SHRINK, gtk.SHRINK)
# pack all logical volumne stuff in a frame
lvtable.set_border_width(12)
l = gtk.Label()
l.set_markup("<b>%s</b>" % (_("Logical Volumes"), ))
frame = gtk.Frame()
frame.set_label_widget(l)
frame.add(lvtable)
frame.set_shadow_type(gtk.SHADOW_NONE)
# dialog.vbox.pack_start(frame)
maintable.attach(frame, 0, 2, row, row + 1)
row = row + 1
dialog.vbox.pack_start(maintable)
dialog.set_size_request(500, 450)
dialog.show_all()
# set space labels to correct values
self.updateVGSpaceLabels()
self.dialog = dialog
def __init__(self, mainWindow):
self.runcmd = mainWindow.runcmd
# Create a new window
self.window = gtk.Window() #hadjustment=None, vadjustment=None)
self.swindow = gtk.ScrolledWindow(hadjustment=None, vadjustment=None)
self.swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.window.set_title("AGOOEY Process Selector")
self.window.set_size_request(600, 240)
self.window.connect("delete_event", self.delete_event)
self.vbox = gtk.VBox(homogeneous=False, spacing=0)
self.hbox = gtk.HBox(homogeneous=False, spacing=0)
rows = 6
cols = 6
self.table = gtk.Table(rows, cols, False)
button_strings = [
'm__readfiles', 's__readfiles', 'coarseorb', 'demassist',
'subtrrefpha', 'dinsar', 'm__porbits', 's__porbits', 'coarsecorr',
'coregpm', 'comprefdem', 'slant2h', 'm__crop', 's__crop',
'm__filtazi', 'resample', 'subtrrefdem', 'geocode', 'm__simamp',
'', 's__filtazi', 'filtrange', 'coherence', '', 'm__timing', '',
'fine', 'interfero', 'filtphase', '', 'm__ovs', 's__ovs',
'reltiming', 'comprefpha', 'unwrap'
]
button = map(lambda i: gtk.Button(button_strings[i]),
range(len(button_strings)))
##### SET THE HBOX #####
self.processEntry = gtk.Entry()
self.processEntry.set_editable(False)
self.processEntry.show()
self.applyButton = gtk.Button(label='Apply',
stock=None,
use_underline=True)
self.applyButton.connect("clicked", self.applyButtonClicked)
self.applyButton.set_flags(gtk.CAN_DEFAULT)
self.applyButton.show()
self.refreshButton = gtk.Button(label='Clear',
stock=None,
use_underline=True)
self.refreshButton.connect("clicked", self.refreshButtonClicked)
self.refreshButton.set_flags(gtk.CAN_DEFAULT)
self.refreshButton.show()
self.advancedChkBtn = gtk.CheckButton("Advanced")
self.advancedChkBtn.connect("toggled", self.advancedChkBtnToggled)
self.advancedChkBtn.show()
self.hbox.pack_start(self.refreshButton,
expand=False,
fill=False,
padding=10)
self.hbox.pack_start(self.applyButton,
expand=False,
fill=False,
padding=10)
self.hbox.pack_end(self.advancedChkBtn,
expand=False,
fill=False,
padding=20)
#### SET THE TABLE ####
for i in range(len(button_strings)):
y, x = divmod(i, cols)
if not button_strings[i]:
continue
button[i].connect("clicked", self.processButtonClicked)
self.table.attach(button[i], x, x + 1, y, y + 1)
button[i].show()
### SET THE VBOX ####
self.vbox.pack_start(
self.processEntry,
expand=False,
fill=False,
)
self.vbox.pack_start(
self.hbox,
expand=False,
fill=False,
)
self.vbox.pack_start(
self.table,
expand=False,
fill=False,
)
self.window.set_default(self.applyButton)
self.swindow.add_with_viewport(self.vbox)
self.window.add(self.swindow)
#self.vbox.show()
self.window.show_all()
page.index("://")
except:
page = "http://" + page
width = int(sys.argv[2])
height = int(sys.argv[3])
except:
warnings.warn("No argument given. Switch to Default settings", Warning)
#crea finestra grafica
win = gtk.Window()
#crea visualizzazione web
webview = webkit.WebView()
#crea finestra con scroll
sw = gtk.ScrolledWindow()
def on_load_finished(self, browser):
html = browser.get_title()
if html != None:
win.set_title(html + " - Fuku WebView")
else:
win.set_title("Fuku WebView")
#alcune impostazioni per la kiosk
win.set_size_request(width, height)
win.set_decorated(True)
win.connect("destroy", lambda q: gtk.main_quit())
def __init__(self):
self.stemmer = Stemmer(sys.argv)
self.word_count = 0
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect('delete_event', self.delete_event)
self.window.connect('destroy', self.destroy)
self.window.set_title('Tamil Stemmer GUI')
self.window.set_size_request(350, 400)
self.list = gtk.ListStore(int, str, str, str)
self.entry = gtk.Entry()
self.entry.connect('activate', self.add_new_row, self.list)
self.tvcolumn1 = gtk.TreeViewColumn('No.')
self.cell1 = gtk.CellRendererText()
self.tvcolumn1.pack_start(self.cell1, True)
self.tvcolumn1.add_attribute(self.cell1, 'text', 0)
self.tvcolumn1.set_resizable(True)
self.tvcolumn2 = gtk.TreeViewColumn('Word')
self.cell2 = gtk.CellRendererText()
self.tvcolumn2.pack_start(self.cell2, True)
self.tvcolumn2.add_attribute(self.cell2, 'text', 1)
self.tvcolumn2.set_min_width(175)
self.tvcolumn3 = gtk.TreeViewColumn('Stemmed word')
self.cell3 = gtk.CellRendererText()
self.tvcolumn3.pack_start(self.cell3, True)
self.tvcolumn3.add_attribute(self.cell3, 'text', 2)
self.tview = gtk.TreeView(self.list)
self.tview.append_column(self.tvcolumn1)
self.tview.append_column(self.tvcolumn2)
self.tview.append_column(self.tvcolumn3)
self.tview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
self.scrollwindow = gtk.ScrolledWindow()
self.scrollwindow.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrollwindow.add(self.tview)
self.textview = gtk.TextView()
self.textbuffer = self.textview.get_buffer()
self.textview.set_editable(False)
self.textview.set_justification(gtk.JUSTIFY_CENTER)
self.scrolledwindow2 = gtk.ScrolledWindow()
self.scrolledwindow2.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.scrolledwindow2.add(self.textview)
self.vbox = gtk.VBox(False, 5)
self.vbox.pack_start(self.entry, expand=False, fill=False, padding=0)
self.vbox.pack_start(self.scrollwindow,
expand=True,
fill=True,
padding=0)
self.vbox.pack_start(self.scrolledwindow2,
expand=True,
fill=True,
padding=0)
self.window.add(self.vbox)
self.window.show_all()
def __init__(self,
setup,
title=None,
parent=None,
flags=gtk.DIALOG_MODAL,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK,
gtk.RESPONSE_ACCEPT)):
gtk.Dialog.__init__(self, title, parent, flags, buttons)
page = []
tabs = ("Document", "Compile Option")
note = gtk.Notebook()
for i in range(len(tabs)):
page.append(gtk.VBox())
note.append_page(page[i], gtk.Label(tabs[i]))
textbuf = gtk.TextBuffer()
textbuf.set_text(setup.preamble)
self.textbuf_preamble = textbuf
textview = gtk.TextView(textbuf)
textview.set_wrap_mode(gtk.WRAP_CHAR)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(textview)
page[0].pack_start(sw)
page[0].pack_start(gtk.HSeparator())
textbuf = gtk.TextBuffer()
textbuf.set_text(setup.begin_document)
self.textbuf_begin_document = textbuf
textview = gtk.TextView(textbuf)
textview.set_wrap_mode(gtk.WRAP_CHAR)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(textview)
page[0].pack_start(sw)
page[0].pack_start(gtk.HSeparator())
textbuf = gtk.TextBuffer()
textbuf.set_text(setup.default_document)
self.textbuf_default_document = textbuf
textview = gtk.TextView(textbuf)
textview.set_wrap_mode(gtk.WRAP_CHAR)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(textview)
page[0].pack_start(sw)
page[0].pack_start(gtk.HSeparator())
textbuf = gtk.TextBuffer()
textbuf.set_text(setup.end_document)
self.textbuf_end_document = textbuf
textview = gtk.TextView(textbuf)
textview.set_wrap_mode(gtk.WRAP_CHAR)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.add(textview)
page[0].pack_start(sw)
frame = gtk.Frame("LaTeX")
page[1].pack_start(frame)
vbox = gtk.VBox()
frame.add(vbox)
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.pack_start(gtk.Label("Command: "), expand=False, fill=False)
self.entry_latex_command = gtk.Entry()
hbox.pack_start(self.entry_latex_command)
self.entry_latex_command.set_text(setup.latex_command)
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.pack_start(gtk.Label("Default Options: "),
expand=False,
fill=False)
self.entry_latex_options = gtk.Entry()
hbox.pack_start(self.entry_latex_options)
self.entry_latex_options.set_text(setup.latex_options)
frame = gtk.Frame("Dvi2png")
page[1].pack_start(frame)
vbox = gtk.VBox()
frame.add(vbox)
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.pack_start(gtk.Label("Command: "), expand=False, fill=False)
self.entry_dvipng_command = gtk.Entry()
hbox.pack_start(self.entry_dvipng_command)
self.entry_dvipng_command.set_text(setup.dvipng_command)
(op, res) = ("-D", 340)
if "resolution" in setup.dvipng_options:
(op, res) = setup.dvipng_options["resolution"]
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.pack_start(gtk.Label("Resolution: "), expand=False, fill=False)
self.entry_dvipng_resolution_option = gtk.Entry()
hbox.pack_start(self.entry_dvipng_resolution_option)
self.entry_dvipng_resolution_option.set_text(op)
self.resolution = gtk.Adjustment(value=res,
lower=8,
upper=20000,
step_incr=50)
sb = gtk.SpinButton(self.resolution)
hbox.pack_start(sb)
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.pack_start(gtk.Label("Options: "), expand=False, fill=False)
self.entry_dvipng_options = gtk.Entry()
hbox.pack_start(self.entry_dvipng_options)
if "userdefinedoptions" in setup.dvipng_options:
self.entry_dvipng_options.set_text(
setup.dvipng_options["userdefinedoptions"])
self.vbox.pack_start(note)
self.show_all()
def __init__(self, instance, effect_properties_handling, clip_properties):
gtk.HBox.__init__(self)
#self.set_expanded(True)
self.selected_effects = []
self.timeline_objects = []
self._factory = None
self.app = instance
self.effectsHandler = self.app.effects
self._effect_config_ui = None
self.pipeline = None
self.effect_props_handling = effect_properties_handling
self.clip_properties = clip_properties
self._info_bar = None
self._config_ui_h_pos = None
self._timeline = None
self._vcontent = gtk.VPaned()
self.add(self._vcontent)
self._table = gtk.Table(3, 1, False)
self._toolbar = gtk.Toolbar()
self._removeEffectBt = gtk.ToolButton("gtk-delete")
self._removeEffectBt.set_label(_("Remove effect"))
self._removeEffectBt.set_use_underline(True)
self._removeEffectBt.set_is_important(True)
self._removeEffectBt.set_sensitive(False)
self._toolbar.insert(self._removeEffectBt, 0)
self._table.attach(self._toolbar, 0, 1, 0, 1, yoptions=gtk.FILL)
self.storemodel = gtk.ListStore(bool, str, str, str, object)
#Treeview
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# TreeView
# Displays name, description
self.treeview = gtk.TreeView(self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.set_property("rules_hint", True)
self.treeview.set_property("has_tooltip", True)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_SINGLE)
activatedcell = gtk.CellRendererToggle()
activatedcell.props.xpad = PADDING
activatedcol = self.treeview.insert_column_with_attributes(-1,
_("Activated"),
activatedcell,
active = COL_ACTIVATED)
activatedcell.connect("toggled", self._effectActiveToggleCb)
typecol = gtk.TreeViewColumn(_("Type"))
typecol.set_sort_column_id(COL_TYPE)
self.treeview.append_column(typecol)
typecol.set_spacing(SPACING)
typecol.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
typecol.set_min_width(50)
typecell = gtk.CellRendererText()
typecell.props.xpad = PADDING
typecell.set_property("ellipsize", pango.ELLIPSIZE_END)
typecol.pack_start(typecell)
typecol.add_attribute(typecell, "text", COL_TYPE)
namecol = gtk.TreeViewColumn(_("Effect name"))
namecol.set_sort_column_id(COL_NAME_TEXT)
self.treeview.append_column(namecol)
namecol.set_spacing(SPACING)
namecell = gtk.CellRendererText()
namecell.props.xpad = PADDING
namecell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(namecell)
namecol.add_attribute(namecell, "text", COL_NAME_TEXT)
self.treeview.drag_dest_set(gtk.DEST_DEFAULT_MOTION,
[dnd.EFFECT_TUPLE],
gtk.gdk.ACTION_COPY)
self.selection = self.treeview.get_selection()
self.selection.connect("changed", self._treeviewSelectionChangedCb)
self._removeEffectBt.connect("clicked", self._removeEffectClicked)
self.connect("drag-data-received", self._dragDataReceivedCb)
self.treeview.connect("drag-leave", self._dragLeaveCb)
self.treeview.connect("drag-drop", self._dragDropCb)
self.treeview.connect("drag-motion", self._dragMotionCb)
self.treeview.connect("query-tooltip", self._treeViewQueryTooltipCb)
self._vcontent.connect("notify", self._vcontentNotifyCb)
#self.connect('notify::expanded', self._expandedCb)
self._table.attach(self.treeview_scrollwin, 0, 1, 2, 3)
self._vcontent.pack1(self._table, resize=True, shrink=False)
self._showInfoBar()
self._vcontent.show()
