def select_color(cls, color, callback):
'''select color, receives a e3.Message.Color with the current
color the callback receives a new color object woth the new selection
'''
def select_color_cb(button, window, callback, response, color_sel):
'''callback called on button selection'''
if response == stock.ACCEPT:
window.hide()
gtk_color = color_sel.get_current_color()
color = e3.Color(gtk_color.red, gtk_color.green,
gtk_color.blue)
callback(color)
window.hide()
window = cls.new_window('Select color')
color_sel = gtk.ColorSelection()
window.hbox.pack_start(color_sel, True, True)
color_sel.set_current_color(gtk.gdk.color_parse('#' + color.to_hex()))
cls.add_button(window, gtk.STOCK_CANCEL, stock.CANCEL, callback,
select_color_cb, color_sel)
cls.add_button(window, gtk.STOCK_OK, stock.ACCEPT, callback,
select_color_cb, color_sel)
window.show_all()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.destroy)
self.window.set_border_width(10)
self.devlist = gtk.combo_box_new_text()
self.devlist.padding = 8
self.devlist.connect("changed", self.selectDev)
self.devlist.set_title("Select device here.")
self.devlist.show()
self.colorpick = gtk.ColorSelection()
self.colorpick.connect("color-changed", self.colorUpdate)
self.colorpick.show()
self.mainbox = gtk.VBox()
self.mainbox.items = 2
self.mainbox.add(self.devlist)
self.mainbox.add(self.colorpick)
self.mainbox.show()
self.window.add(self.mainbox)
self.window.show()
self.devlist.append_text("Disconnected")
devs.append(["none", ""])
self.devlist.set_active(0)
for addr, name in bs.scan():
self.devlist.append_text("Bluetooth: %(addr)s (%(name)s)" % {
"addr": addr,
"name": name
})
devs.append(["b", addr])
def __init__(self, loop):
window = gtk.Window()
vbox1 = gtk.VBox()
hbox1 = gtk.HBox()
window.add(vbox1)
window.connect("delete_event", gtk.main_quit)
window.set_border_width(5)
window.set_icon_from_file(icon)
color = gtk.ColorSelection()
color.connect("color_changed",self.new_color)
self.combobox = gtk.combo_box_new_text()
self.combobox.set_border_width(5)
label = gtk.Label("Selected Lamp:")
separator = gtk.HSeparator()
vbox1.pack_start(hbox1)
hbox1.pack_start(label, False, False, 1)
hbox1.pack_start(self.combobox, True, True, 2)
vbox1.pack_start(separator)
vbox1.pack_start(color,True,True,2)
hbox1.set_border_width(5)
window.show_all()
bus = dbus.SystemBus(mainloop=loop)
self.server = dbus.Interface(bus.get_object(avahi.DBUS_NAME, '/'), 'org.freedesktop.Avahi.Server')
sbrowser = dbus.Interface(bus.get_object(avahi.DBUS_NAME,
self.server.ServiceBrowserNew(avahi.IF_UNSPEC,
avahi.PROTO_UNSPEC, TYPE, 'local', dbus.UInt32(0))),
avahi.DBUS_INTERFACE_SERVICE_BROWSER)
sbrowser.connect_to_signal("ItemNew", self.mlfound)
def add_connector(self, widget):
self.newConnector = [(0, 0, 0), [], 0, 10]
dialog = gtk.Dialog("Add a connector", None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT))
dialog.vbox.set_spacing(10)
b_connectorSpec = gtk.Button("Connect The Nodes")
b_connectorSpec.connect("clicked", self.get_connector_spec)
dialog.vbox.pack_start(b_connectorSpec)
l_vehicle_nb = gtk.Label("Vehicle number:")
dialog.vbox.pack_start(l_vehicle_nb)
e_vehicle_nb = gtk.Entry()
self.numbify(e_vehicle_nb)
dialog.vbox.pack_start(e_vehicle_nb)
l_vehicle_sp = gtk.Label("Vehicle speed:")
dialog.vbox.pack_start(l_vehicle_sp)
e_vehicle_sp = gtk.Entry()
self.numbify(e_vehicle_sp)
dialog.vbox.pack_start(e_vehicle_sp)
l_pick_color = gtk.Label("Pick a connector color")
dialog.vbox.pack_start(l_pick_color)
colorselwidget = gtk.ColorSelection()
dialog.vbox.pack_start(colorselwidget)
dialog.show_all()
response = dialog.run()
if response == gtk.RESPONSE_ACCEPT:
# L'utilisateur valide
if self.is_connector_ok(self.newConnector) is True:
self.newConnector[0] = self.hex_to_rgb(
str(colorselwidget.get_current_color()))
self.newConnector[2] = int(e_vehicle_nb.get_text())
self.newConnector[3] = int(e_vehicle_sp.get_text())
self.Connectors.append(self.newConnector)
self.Nodes = utils.count_connectors_per_node(
self.Nodes, self.Connectors)
self.info.set_text("Connector has been added successfully!")
print "connector created"
else:
self.info.set_text("Error creating connector")
dialog.destroy()
return -1
else:
# L'utilisateur annule (soit gtk.RESPONSE_CANCEL, soit gtk.RESPONSE_NONE)
print "Cancel"
#message d'erreur AFAIRE
del self.newConnector
dialog.destroy()
return 0
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("ThunderBorg LED control")
self.window.connect("destroy", self.destroy)
self.vbxGrid = gtk.VBox(False, 0)
self.window.add(self.vbxGrid)
self.lblThunderBorgColour = gtk.Label("ThunderBorg LED colour")
self.lblThunderBorgColour.set_use_markup(gtk.TRUE)
self.lblThunderBorgColour.set_markup(
"\n<b><big><big>ThunderBorg LED colour\n</big></big></b>")
self.vbxGrid.pack_start(self.lblThunderBorgColour, True, True, 0)
self.lblThunderBorgColour.show()
self.clrThunderBorg = gtk.ColorSelection()
self.clrThunderBorg.set_has_palette(False)
self.clrThunderBorg.connect("color_changed",
self.ThunderBorgColourChanged)
self.vbxGrid.pack_start(self.clrThunderBorg, True, True, 0)
self.clrThunderBorg.show()
self.lblThunderBorgLidColour = gtk.Label("Lid LED colour")
self.lblThunderBorgLidColour.set_use_markup(gtk.TRUE)
self.lblThunderBorgLidColour.set_markup(
"<b><big><big>\nLid LED colour\n</big></big></b>")
self.vbxGrid.pack_start(self.lblThunderBorgLidColour, True, True, 0)
self.lblThunderBorgLidColour.show()
self.clrThunderBorgLid = gtk.ColorSelection()
self.clrThunderBorgLid.set_has_palette(False)
self.clrThunderBorgLid.connect("color_changed",
self.ThunderBorgLidColourChanged)
self.vbxGrid.pack_start(self.clrThunderBorgLid, True, True, 0)
self.clrThunderBorgLid.show()
self.vbxGrid.show()
self.window.show()
def __init__(self):
import application
app = application.get_app()
assert app is not None
flags = gtk.DIALOG_DESTROY_WITH_PARENT
buttons = (_('Save as Default'), RESPONSE_SAVE_AS_DEFAULT,
gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)
windowing.Dialog.__init__(self,
app=app,
title=_('Background'),
parent=app.drawWindow,
flags=flags,
buttons=buttons)
#set up window
self.connect('response', self.on_response)
notebook = self.nb = gtk.Notebook()
self.vbox.pack_start(notebook)
#set up patterns tab
patterns_scroll = gtk.ScrolledWindow()
patterns_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
notebook.append_page(patterns_scroll, gtk.Label(_('Pattern')))
self.bgl = BackgroundList(self)
patterns_scroll.add_with_viewport(self.bgl)
def lazy_init(*ignored):
if not self.bgl.initialized:
self.bgl.initialize()
self.connect("realize", lazy_init)
#set up colors tab
color_vbox = gtk.VBox()
notebook.append_page(color_vbox, gtk.Label(_('Color')))
self.cs = gtk.ColorSelection()
self.cs.connect('color-changed', self.color_changed_cb)
color_vbox.pack_start(self.cs, expand=True)
b = gtk.Button(_('Add color to Patterns'))
b.connect('clicked', self.add_color_to_patterns_cb)
color_vbox.pack_start(b, expand=False)
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.client = gconf.client_get_default()
self.current_nick = self.client.get_string("/desktop/sugar/user/nick")
self.current_colour = self.client.get_string(
"/desktop/sugar/user/color")
self.current_colours = _parse_string(self.current_colour)
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
self.ok_button = ToolButton(icon)
self.ok_button.props.tooltip = "Aplicar"
self.ok_button.connect("clicked", self.apply)
self.ok_button.show()
activity_toolbar.insert(self.ok_button, 2)
self.set_toolbox(self.toolbox)
self.toolbox.show()
self.canvas = gtk.VBox()
name_box = gtk.HBox()
self.canvas.pack_start(name_box, True, True, 5)
name_label = gtk.Label("Nombre:")
self.name_entry = gtk.Entry()
self.name_entry.set_text(self.current_nick)
name_label.show()
self.name_entry.show()
name_box.pack_start(name_label, False, True, 0)
name_box.pack_start(self.name_entry, True, True, 0)
name_box.show()
self.colour_picker = gtk.HBox()
selectors = gtk.VBox()
self.out_colour_selector = gtk.ColorSelection()
self.out_colour_selector.set_current_color(
gtk.gdk.color_parse(self.current_colours[0]))
self.out_colour_selector.connect("color-changed",
self.colour_changed_callback, "out")
self.out_colour_selector.show()
selectors.pack_start(self.out_colour_selector, True, True, 0)
self.in_colour_selector = gtk.ColorSelection()
self.in_colour_selector.set_current_color(
gtk.gdk.color_parse(self.current_colours[1]))
self.in_colour_selector.connect("color-changed",
self.colour_changed_callback, "in")
self.in_colour_selector.show()
selectors.pack_start(self.in_colour_selector, True, True, 0)
selectors.show()
self.colour_picker.pack_start(selectors, True, True, 0)
self.xo_icon = gtk.EventBox()
self.icon = Icon(pixel_size=style.XLARGE_ICON_SIZE)
self.icon.props.xo_color = XoColor(self.current_colour)
self.icon.props.icon_name = 'computer-xo'
self.icon.props.pixel_size = style.XLARGE_ICON_SIZE
self.icon.show()
self.xo_icon.add(self.icon)
self.xo_icon.show()
self.colour_picker.pack_start(self.xo_icon)
self.canvas.pack_start(self.colour_picker, True, True, 5)
self.colour_picker.show()
self.canvas.show()
self.set_canvas(self.canvas)
self.show()
#!/usr/bin/env python import gtk window = gtk.Window() window.add(gtk.ColorSelection()) window.show_all() gtk.main()
def initColorDrag(
): # mainly for IcePref2, IcePref-TD, and IceWMCPWallpaper - 'color buttons'
# added 5.16.2003, a hidden color dialog for handling drag-n-drop color support on 'color buttons'
global COLOR_HOLDER
# using a 'popup' (frameless) window type, so it wont map to the taskbar and make the screen 'flicker'
COLOR_HOLDER = gtk.Window(gtk.WINDOW_POPUP)
COLOR_HOLDER.colorsel = gtk.ColorSelection()
COLOR_HOLDER.add(COLOR_HOLDER.colorsel)
COLOR_HOLDER.set_position(gtk.WIN_POS_CENTER)
COLOR_HOLDER.set_size_request(1, 1)
COLOR_HOLDER.show_all(
) # must be called now, before use, to avoid 'gtk.Critical' whining on stdout
COLOR_HOLDER.hide()
#DJM! COLOR_HOLDER.colorsel.set_update_policy(gtk.UPDATE_CONTINUOUS)
global setDrag2
def setDrag2(
*args
): # drag-n-drop callback, added 5.16.2003, drag-n-drop support for 'color buttons'
drago = args
if len(drago) < 7:
args[0].drag_highlight()
args[0].grab_focus()
else:
try:
global COLOR_HOLDER
COLOR_HOLDER.show()
COLOR_HOLDER.set_position(gtk.WIN_POS_MOUSE)
COLOR_HOLDER.hide()
""" 5.16.2003 - Erica Andrews
send the same drag-n-drop signal we just received to the hidden COLOR_HOLDER's
'preview' (gtk.Preview) box, to set the color - I don't know a work-around
for this yet, since the 'application/x-color' returned by the drag-n-drop
gtk.SelectionData.data object is some type of unparseable 'native' unicode
junk that Python doesn't appear to be able to turn into a string, int or
anything useful - so, we will let the built-in drag-n-drop of the
gtk.ColorSelectionDialog handle it the way it knows how since it has direct
access to the 'secret' C code underneath Pygtk. """
wprev = COLOR_HOLDER.colorsel.get_children()[0].get_children(
)[0].get_children()[1].get_children()[0]
wprev.emit("drag_data_received", drago[1], drago[2], drago[3],
drago[4], drago[5], drago[6])
col = COLOR_HOLDER.colorsel.get_color()
# update the color on the 'color button' can called this drag-n-drop
drago[0].get_data("colorbutton").updateColorProperties(
col[0], col[1], col[2])
except:
pass
args[0].drag_unhighlight()
global addDragSupportColor
def addDragSupportColor(
widget
): # drag-n-drop support, added 5.15.2003 , for color buttons
widget.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[('application/x-icewmcp-color', 0, 0),
("application/x-color", 0, 0)],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
widget.connect("drag_drop", setDrag2)
widget.connect("drag_begin", setDrag2)
widget.connect("drag_data_received", setDrag2)
def tohex(val):
h = hex(val)[2:]
if val < 0x10:
h = '0' + h
return h.upper()
if len(sys.argv) > 1:
lamp = tohex(int(sys.argv[1]))
else:
lamp = tohex(0)
def new_color(color):
c = color.get_current_color()
r = c.red / 256
g = c.green / 256
b = c.blue / 256
cmd = "acC#%s#%s%s%sab" % (lamp, tohex(r), tohex(g), tohex(b))
s.sendto(cmd, addr)
window = gtk.Window()
window.connect("delete_event", gtk.main_quit)
window.set_border_width(10)
color = gtk.ColorSelection()
color.connect("color_changed", new_color)
window.add(color)
window.show_all()
gtk.main()
#!/usr/bin/env python
import gtk
import gtk.gdk
def color_change(widget):
color = widget.get_current_color()
#print sorted(dir(color))
#print color.to_string()
print "#%02x%02x%02x" % (color.red >> 8, color.green >> 8, color.blue >> 8)
win = gtk.Window(gtk.WINDOW_TOPLEVEL)
csel = gtk.ColorSelection()
win.add(csel)
csel.show()
win.show()
csel.connect("color-changed", color_change)
win.connect("destroy", lambda *args: exit(0))
gtk.main()
def __init__(self):
self.window = gtk.Window()
self.colorsel = gtk.ColorSelection()
self.window.connect('destroy', lambda w: gtk.main_quit())
self.window.set_size_request(400, 300)
self.window.set_title("Bluetooth RGB Controller")
icon = self.window.render_icon(gtk.STOCK_CONVERT, gtk.ICON_SIZE_BUTTON)
self.window.set_icon(icon)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
# self.window.add(self.colorsel)
self.uimanager = gtk.UIManager()
accelgroup = self.uimanager.get_accel_group()
self.window.add_accel_group(accelgroup)
genericactions = gtk.ActionGroup('GenericActions')
self.genericactions = genericactions
self.uimanager.insert_action_group(genericactions, 0)
serialactions = gtk.ActionGroup('SerialActions')
self.serialactions = serialactions
serialactions.add_actions([
('mnuHelp', None, '_Help'),
# ('funAbout', gtk.STOCK_ABOUT, '_About', None, 'About', self.aboutButton),
('funQuit', gtk.STOCK_QUIT, '_Quit', None, 'Quit the Program',
self.quit),
('mnuFile', None, '_File'),
('funConnect', gtk.STOCK_REFRESH, 'Serial _Connect', None,
'Serial Connect', self.setup_serial)
])
self.uimanager.insert_action_group(serialactions, 0)
self.uimanager.add_ui_from_string(self.ui)
self.menubar = self.uimanager.get_widget('/MenuBar')
self.vbox.pack_start(self.menubar, False)
self.toolbar = self.uimanager.get_widget('/Toolbar')
self.vbox.pack_start(self.toolbar, False)
self.content = gtk.VBox()
headerVbox = gtk.VBox(True, 0)
headerLabel1 = gtk.Label("Select RGB Color")
headerVbox.pack_start(headerLabel1)
mainHbox = gtk.HBox(True, 0)
loopVbox = gtk.VBox(True, 0)
fadeLabel = gtk.Label("Fade Delay (variable on arduino (ms): ")
self.fadeScale = gtk.HScale()
self.fadeScale.set_name("fade")
self.fadeScale.set_range(5, 60)
self.fadeScale.set_digits(0)
self.fadeScale.set_size_request(160, 35)
self.fadeScale.set_value(35)
loopVbox = gtk.VBox(False, 0)
# the radio buttons
global button
button = gtk.RadioButton(None, "Color Changer")
button.connect("toggled", self.callback, "Color Changer")
loopVbox.pack_start(button, gtk.TRUE, gtk.TRUE, 10)
button.show()
global button1
button1 = gtk.RadioButton(button, "Breathe")
button1.connect("toggled", self.callback, "Breathe")
loopVbox.pack_start(button1, gtk.TRUE, gtk.TRUE, 10)
button1.show()
global button2
button2 = gtk.RadioButton(button, "Color Select")
button2.set_active(False)
button2.connect("toggled", self.callback, "Color Select")
loopVbox.pack_start(button2, gtk.TRUE, gtk.TRUE, 10)
button2.show()
rHbox = gtk.HBox(True, 0)
rLabel = gtk.Label("Red: ")
rHbox.pack_start(rLabel, expand=False, fill=False)
self.rScale = gtk.HScale()
self.rScale.set_name("red")
self.rScale.set_range(0, 255)
self.rScale.set_increments(1, 10)
self.rScale.set_digits(0)
self.rScale.set_size_request(160, 35)
self.rScale.connect("value-changed", self.slider_changed)
rHbox.pack_end(self.rScale)
gHbox = gtk.HBox(True, 0)
gLabel = gtk.Label("Green: ")
gHbox.pack_start(gLabel, expand=False, fill=False)
self.gScale = gtk.HScale()
self.gScale.set_name("green")
self.gScale.set_range(0, 255)
self.gScale.set_increments(1, 10)
self.gScale.set_digits(0)
self.gScale.set_size_request(160, 35)
self.gScale.connect("value-changed", self.slider_changed)
gHbox.pack_end(self.gScale)
bHbox = gtk.HBox(True, 0)
bLabel = gtk.Label("Blue: ")
bHbox.pack_start(bLabel, expand=False, fill=False)
self.bScale = gtk.HScale()
self.bScale.set_name("blue")
self.bScale.set_range(0, 255)
self.bScale.set_increments(1, 10)
self.bScale.set_digits(0)
self.bScale.set_size_request(160, 35)
self.bScale.connect("value-changed", self.slider_changed)
bHbox.pack_end(self.bScale)
#make a new hbox
delayHbox = gtk.HBox(True, 0)
delayLabel = gtk.Label("Delay :")
#pack the delay slider into the hbox
delayHbox.pack_start(delayLabel, expand=True, fill=False)
#define the various stuff for the slider itself
self.delayScale = gtk.HScale()
self.delayScale.set_name("delay")
self.delayScale.set_range(0, 100)
self.delayScale.set_increments(1, 10)
self.delayScale.set_digits(0)
# self.delayScale.set_size_request(160, 35)
self.delayScale.connect("value-changed", self.slider_changed)
delayHbox.pack_end(self.delayScale)
cHbox = gtk.HBox(True, 0)
cLabel = gtk.Label("RGB")
cHbox.pack_start(cLabel, expand=False, fill=False)
cHbox.pack_end(self.colorsel)
rgbVbox = gtk.VBox(True, 0)
rgbVbox.pack_start(headerVbox)
rgbVbox.pack_start(rHbox)
rgbVbox.pack_start(gHbox)
rgbVbox.pack_end(bHbox)
# rgbVbox.pack_end(dHbox)
self.colorsel.connect('color-changed', self.color_picker_callback)
self.window.connect('destroy', sys.exit)
# mainHbox.pack_start(radio_vbox)
mainHbox.pack_start(loopVbox)
mainHbox.pack_end(rgbVbox)
# mainHbox.pack_end(delayHbox)
self.content.pack_start(mainHbox)
self.content.pack_end(delayHbox)
if (mode == 2):
self.enableAll()
else:
self.disableAll()
# button.set_sensitive(False);
# button1.set_sensitive(False);
# button2.set_sensitive(False);
self.vbox.pack_start(self.content)
self.window.show_all()
return
def __init__(self):
# color systems
self.__colorSystems = ["YIQ", "RGB", "HSV"]
self.__activeColorSystem = self.__colorSystems[0]
## main window
spacing = 5
self.window = gtk.Window()
self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT)
self.window.set_default_size(*windowSize)
self.window.set_title("colorname")
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(1)
pixbuf = self.window.render_icon(gtk.STOCK_SELECT_COLOR,
gtk.ICON_SIZE_DIALOG)
self.window.set_icon(pixbuf)
## main boxes
mainBox = gtk.VBox(spacing=spacing)
self.window.add(mainBox)
## misc
self.colorSelect = gtk.ColorSelection()
mainBox.pack_start(self.colorSelect, expand=False)
listsBox = gtk.VPaned()
listsBox.set_position(150)
mainBox.pack_start(listsBox, expand=True)
## colors
colorFrame = gtk.Frame(label="Colors")
listsBox.pack1(colorFrame, shrink=False)
colorBox = gtk.VBox(spacing=spacing)
colorFrame.add(colorBox)
self.colorModel = gtk.ListStore(gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
colorView = gtk.TreeView(self.colorModel)
# columns
toggleRend = gtk.CellRendererToggle()
toggleRend.set_property('activatable', True)
toggleRend.connect("toggled", self.__colorlistCheckboxHandler,
self.colorModel)
toggleCol = gtk.TreeViewColumn("", toggleRend)
toggleCol.add_attribute(toggleRend, "active", 0)
colorView.append_column(toggleCol)
colorView.append_column(
gtk.TreeViewColumn("Colorlist", gtk.CellRendererText(), text=1))
# create scrollbars around the view.
colorScrolledListView = gtk.ScrolledWindow()
colorScrolledListView.set_property("hscrollbar_policy",
gtk.POLICY_NEVER)
colorScrolledListView.add(colorView)
colorBox.pack_start(colorScrolledListView)
## results
resultFrame = gtk.Frame(label="Results")
listsBox.pack2(resultFrame, shrink=0)
self.resultModel = gtk.ListStore(gobject.TYPE_FLOAT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_UINT)
self.__resultView = gtk.TreeView(self.resultModel)
self.__resultView.set_search_column(1)
resultRend = gtk.CellRendererText()
# color
colNr = 1
colorCell = gtk.CellRendererPixbuf()
colorNameCol = gtk.TreeViewColumn("Color")
colorNameCol.pack_start(colorCell, False)
colorNameCol.pack_start(resultRend, True)
colorNameCol.set_sort_column_id(colNr)
colorNameCol.set_cell_data_func(colorCell, self.__renderColorPixbuf)
colorNameCol.set_attributes(resultRend, text=colNr)
self.__resultView.append_column(colorNameCol)
# source
colNr = 2
sourceCol = gtk.TreeViewColumn("Source", resultRend, text=colNr)
sourceCol.set_sort_column_id(colNr)
sourceCol.set_min_width(-1)
self.__resultView.append_column(sourceCol)
# distance
colNr = 0
distCol = gtk.TreeViewColumn("Distance", resultRend, text=colNr)
distCol.set_sort_column_id(colNr)
distCol.set_sort_order(gtk.SORT_ASCENDING)
self.__resultView.append_column(distCol)
self.__resultView.connect("button_press_event", self.__resultsPopup)
# create scrollbars around the view.
resultScrolledListView = gtk.ScrolledWindow()
resultScrolledListView.set_property("hscrollbar_policy",
gtk.POLICY_NEVER)
resultScrolledListView.add(self.__resultView)
resultFrame.add(resultScrolledListView)
## button box
buttonBox = gtk.HBox(spacing=spacing)
execButton = gtk.Button(stock=gtk.STOCK_EXECUTE)
execButton.connect("clicked", self.execute)
buttonBox.pack_start(execButton, fill=False, expand=False)
selCombobox = gtk.combo_box_new_text()
map(selCombobox.append_text, self.__colorSystems)
selCombobox.set_active(0)
buttonBox.pack_start(selCombobox, fill=False, expand=False)
selCombobox.connect("changed", self.__comboboxChangedHandler)
closeButton = gtk.Button(stock=gtk.STOCK_CLOSE)
closeButton.connect_object("clicked", gtk.Widget.destroy, self.window)
buttonBox.pack_end(closeButton, fill=False, expand=False)
aboutButton = gtk.Button("A_bout")
aboutButton.connect("clicked", self.__showAbout)
buttonBox.pack_end(aboutButton, fill=False, expand=False)
mainBox.pack_start(buttonBox, fill=False, expand=False)
##
self.window.show_all()