def __init__(self, plugin, window):
WindowExtension.__init__(self, plugin, window)
self.preferences = plugin.preferences
self._monitor = None
# Init statusbar button
self.statusbar_frame = gtk.Frame()
self.statusbar_frame.set_shadow_type(gtk.SHADOW_IN)
self.window.statusbar.pack_end(self.statusbar_frame, False)
self.statusbar_button = gtk.ToggleButton(
'<attachments>') # translated below
button_set_statusbar_style(self.statusbar_button)
self.statusbar_button.set_use_underline(True)
self.__class__.toggle_fileview.connect_actionable(
self, self.statusbar_button)
self.statusbar_frame.add(self.statusbar_button)
self.statusbar_frame.show_all()
# Init browser widget
opener = self.window.get_resource_opener()
self.widget = AttachmentBrowserPluginWidget(self, opener,
self.preferences)
# FIXME FIXME FIXME - get rid of ui object here
self.on_preferences_changed(plugin.preferences)
self.connectto(plugin.preferences, 'changed',
self.on_preferences_changed)
# XXX
if self.window.ui.page:
self.on_open_page(self.window.ui, self.window.ui.page,
self.window.ui.page)
self.connectto(self.window.ui, 'open-page')
self.connectto(self.window, 'pane-state-changed')
def create_gui_panel(self):
self.logview = gtk.TextView()
self.logview.set_editable(False)
# Use a monospace font. This is safe - by testing - setting an
# illegal font description has no effect.
self.logview.modify_font(pango.FontDescription("monospace"))
searchbox = gtk.HBox()
entry = gtk.Entry()
entry.connect("activate", self.enter_clicked, self.logview)
searchbox.pack_start(entry, True)
b = gtk.Button("Find Next")
b.connect_object('clicked', self.on_find_clicked, self.logview, entry)
searchbox.pack_start(b, False)
self.hbox = gtk.HBox()
self.freeze_button = gtk.ToggleButton("Dis_connect")
self.freeze_button.set_active(False)
self.freeze_button.connect("toggled", self.freeze_log)
searchbox.pack_end(self.freeze_button, False)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.logview)
self.logview.set_border_width(5)
self.logview.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#fff"))
self.vbox = gtk.VBox()
self.log_label = gtk.Label("PATH")
self.log_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#00a"))
self.vbox.pack_start(self.log_label, False)
self.vbox.pack_start(sw, True)
self.vbox.pack_start(searchbox, False)
self.vbox.pack_start(self.hbox, False)
def get_entry(self, value_item):
"""Create a widget for this array element."""
bad_img = gtk.image_new_from_stock(gtk.STOCK_DIALOG_WARNING,
gtk.ICON_SIZE_MENU)
button = gtk.ToggleButton()
button.options = [
rose.TYPE_LOGICAL_VALUE_FALSE, rose.TYPE_LOGICAL_VALUE_TRUE
]
button.labels = [
rose.TYPE_LOGICAL_FALSE_TITLE, rose.TYPE_LOGICAL_TRUE_TITLE
]
button.set_tooltip_text(value_item)
if value_item in self.allowed_values:
index = self.allowed_values.index(value_item)
button.set_active(index)
button.set_image(self.make_log_image(index))
button.set_label(button.labels[index])
else:
button.set_inconsistent(True)
button.set_image(bad_img)
button.connect('toggled', self._switch_state_and_set)
button.show()
return button
def create_buttons(self):
# create whiteboard button
actions_hbox = self.chat_control.xml.get_object('actions_hbox')
self.button = gtk.ToggleButton(label=None, use_underline=True)
self.button.set_property('relief', gtk.RELIEF_NONE)
self.button.set_property('can-focus', False)
img = gtk.Image()
img_path = self.plugin.local_file_path('tictactoe.png')
pixbuf = gtk.gdk.pixbuf_new_from_file(img_path)
iconset = gtk.IconSet(pixbuf=pixbuf)
factory = gtk.IconFactory()
factory.add('tictactoe', iconset)
factory.add_default()
img.set_from_stock('tictactoe', gtk.ICON_SIZE_MENU)
self.button.set_image(img)
send_button = self.chat_control.xml.get_object('send_button')
send_button_pos = actions_hbox.child_get_property(send_button,
'position')
actions_hbox.add_with_properties(self.button, 'position',
send_button_pos - 1, 'expand', False)
id_ = self.button.connect('toggled', self.on_tictactoe_button_toggled)
self.chat_control.handlers[id_] = self.button
self.button.show()
def __init__(self, host='localhost', port='2947', device=None, debug=0):
self.host = host
self.port = port
self.device = device
self.debug = debug
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_size_request(WIN_X, WIN_Y)
if not self.window.get_display():
raise Exception("Can't open display")
self.window.set_title('Navigator')
self.widget = Navigation()
self.window.connect('delete_event', self.delete_event)
self.window.connect('destroy', self.destroy)
self.widget.show()
vbox = gtk.VBox(False, 0)
self.window.add(vbox)
self.window.present()
buttonbox = gtk.HButtonBox()
buttonbox.set_layout(gtk.BUTTONBOX_END)
button_toggle_placemark = gtk.ToggleButton('Placemark')
button_toggle_placemark.connect('toggled', self.toggle_placemark)
buttonbox.pack_start(button_toggle_placemark, expand=True, fill=True)
button_dist = gtk.Button('ruler')
button_dist.connect('clicked', self.distance_dialog)
buttonbox.pack_start(button_dist, expand=True, fill=True)
button_reset_rotate = gtk.Button('Reset Rotate')
button_reset_rotate.connect('clicked', self.reset_rotate)
buttonbox.pack_start(button_reset_rotate, expand=True, fill=True)
vbox.pack_start(buttonbox, False, False, 0)
vbox.add(self.widget)
self.window.show_all()
self.ruler_start = False
self.dialog = False
def exc_error(cls, message, response_cb=None, title=_("Error!")):
'''show an error dialog displaying the message and the traceback;
this dialog should have only the option to close and the response
callback is optional since in few cases one want to know when the error
dialog was closed, but it can happen, so return stock.CLOSE to the
callback if its set'''
#cls.message_window('%s\n\n%s' % (message, traceback.format_exc()),
# gtk.STOCK_DIALOG_ERROR, response_cb, title).show()
window = gtk.Window()
vbox = gtk.VBox()
text = gtk.Label(message)
vbox.pack_start(text)
hide_button = gtk.ToggleButton('Show details')
trace = gtk.Label(traceback.format_exc())
def on_hide(*args):
if hide_button.get_active(): #show
hide_button.set_label('Hide details')
trace.show()
else:
hide_button.set_label('Show details')
trace.hide()
hide_button.connect('toggled', on_hide)
close_button = gtk.Button(stock=gtk.STOCK_OK)
def on_ok(*args):
window.destroy()
close_button.connect('clicked', on_ok)
vbox.pack_start(hide_button, False, False)
vbox.pack_start(trace)
vbox.pack_start(close_button, False, False)
window.add(vbox)
window.show_all()
on_hide()
def __init__(self):
gtk.HBox.__init__(self)
self._popping_down = False
self._old_date = None
self._block_changed = False
# bootstrap problems, kiwi.ui.widgets.entry imports dateentry
# we need to use a proxy entry because we want the mask
from kiwi.ui.widgets.entry import ProxyEntry
self.entry = ProxyEntry()
# Set datatype before connecting to change event, to not get when the
# mask is set
self.entry.set_property('data-type', datetime.date)
self.entry.connect('changed', self._on_entry__changed)
self.entry.connect('activate', self._on_entry__activate)
mask = self.entry.get_mask()
if mask:
self.entry.set_width_chars(len(mask))
self.pack_start(self.entry, False, False)
self.entry.show()
self._button = gtk.ToggleButton()
self._button.connect('scroll-event', self._on_entry__scroll_event)
self._button.connect('toggled', self._on_button__toggled)
self._button.set_focus_on_click(False)
self.pack_start(self._button, False, False)
self._button.show()
arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_NONE)
self._button.add(arrow)
arrow.show()
self._popup = _DateEntryPopup(self)
self._popup.connect('date-selected', self._on_popup__date_selected)
self._popup.connect('hide', self._on_popup__hide)
self._popup.set_size_request(-1, 24)
def fillCardsFrame(self, vbox):
hbox1 = gtk.HBox(True, 0)
hbox1.show()
vbox.pack_start(hbox1, True, True, 0)
cards = [
"A", "K", "Q", "J", "T", "9", "8", "7", "6", "5", "4", "3", "2"
]
for j in range(0, len(cards)):
hbox1 = gtk.HBox(True, 0)
hbox1.show()
vbox.pack_start(hbox1, True, True, 0)
for i in range(0, len(cards)):
if i < (j + 1):
suit = "o"
else:
suit = "s"
button = gtk.ToggleButton("%s%s%s" %
(cards[i], cards[j], suit))
button.connect("toggled", self.cardCallback,
"%s%s%s" % (cards[i], cards[j], suit))
hbox1.pack_start(button, True, True, 0)
button.show()
def __init__(self,
title='Array Cycler',
default_width=DEFAULT_WIN_WIDTH,
default_height=DEFAULT_WIN_HEIGHT,
cadence=0.6):
self.cadence = cadence
self.viewport = Viewport()
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.set_title(title)
self.win.set_default_size(default_width, default_height)
self.win.connect('key-press-event', self._on_key_press)
self.win.connect('realize', self._on_realize)
self.win.connect('unrealize', self._on_unrealize)
vb = gtk.VBox()
vb.pack_start(self.viewport, True, True, 2)
hb = gtk.HBox()
vb.pack_start(hb, False, True, 2)
self.status_label = gtk.Label()
self.status_label.set_alignment(0, 0.5)
hb.pack_start(self.status_label, True, True, 2)
self.plane_label = gtk.Label()
self.plane_label.set_alignment(0, 0.5)
hb.pack_start(self.plane_label, True, True, 2)
self.desc_label = gtk.Label()
hb.pack_start(self.desc_label, True, True, 2)
self.cycle_tbutton = gtk.ToggleButton('Cycle')
hb.pack_start(self.cycle_tbutton, False, True, 2)
self.win.add(vb)
self.viewport.setShapeGetter(self._get_shape)
self.viewport.setSurfaceGetter(self._get_surface)
self.viewport.setTuningSetter(self._set_tuning)
self.cycle_tbutton.set_active(True)
def create_ui(self):
mainvbox = gtk.VBox()
hbox = gtk.HBox()
self.adapterlist = gtk.combo_box_new_text()
self.adapterlist.connect("changed", self.adapter_changed)
self.initialtuning = gtk.combo_box_new_text()
self.find_adapters_and_fill_list()
hbox.add(self.adapterlist)
hbox.add(self.initialtuning)
scanbutton = gtk.Button("Scan")
scanbutton.connect("clicked", self.scan_button_clicked)
hbox.add(scanbutton)
mainvbox.pack_start(hbox, fill=False, expand=False)
scanvbox = gtk.VBox()
self.label = gtk.Label("")
self.progressbar = gtk.ProgressBar()
scanvbox.pack_start(self.label, True, True, 3)
scanvbox.pack_start(self.progressbar, True, True, 3)
mainvbox.pack_start(scanvbox, fill=False, expand=False)
self.channelstore = gtk.ListStore(str, int, int, int)
self.channelstore.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.channelview = gtk.TreeView(self.channelstore)
self.channelview.set_headers_visible(True)
self.channelview.set_sensitive(True)
namecol = gtk.TreeViewColumn("Channel", gtk.CellRendererText(), text=0)
self.channelview.append_column(namecol)
self.channelview.connect("row-activated", self.play_channel)
channelscroll = gtk.ScrolledWindow()
channelscroll.add(self.channelview)
label = gtk.Label("Current Program:")
eitscroll = gtk.ScrolledWindow()
textview = gtk.TextView()
textview.set_wrap_mode(gtk.WRAP_WORD)
self.eittextbuffer = textview.get_buffer()
eitscroll.add(textview)
eitscroll.show()
textview.show()
channelvbox = gtk.VBox()
channelvbox.pack_start(channelscroll)
channelvbox.pack_start(label, False, False, 3)
channelvbox.pack_start(eitscroll)
playervbox = gtk.VBox()
self.videowidget = VideoWidget()
playervbox.pack_start(self.videowidget)
hbox = gtk.HBox()
playervbox.pack_start(hbox, fill=False, expand=False)
self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE,
gtk.ICON_SIZE_BUTTON)
self.pause_image.show()
self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY,
gtk.ICON_SIZE_BUTTON)
self.play_image.show()
self.playbutton = button = gtk.Button()
button.add(self.play_image)
button.set_property('can-default', True)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.set_property('has-default', False)
button.connect('clicked', lambda *args: self.play_toggled())
image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_NEXT,
gtk.ICON_SIZE_BUTTON)
image.show()
button = gtk.Button()
button.add(image)
button.set_property('can-default', True)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.set_property('has-default', False)
button.connect('clicked', lambda *args: self.seek_end_toggled())
self.adjustment = gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0)
hscale = gtk.HScale(self.adjustment)
hscale.set_digits(2)
hscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
hscale.connect('button-press-event', self.scale_button_press_cb)
hscale.connect('button-release-event', self.scale_button_release_cb)
hscale.connect('format-value', self.scale_format_value_cb)
hbox.pack_start(hscale, True, True, 3)
self.hscale = hscale
image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_RECORD,
gtk.ICON_SIZE_BUTTON)
image.show()
self.recordbutton = button = gtk.ToggleButton()
button.add(image)
button.set_focus_on_click(False)
button.set_size_request(40, 40)
button.show()
hbox.pack_start(button, False, False, 3)
button.connect('clicked', lambda *args: self.recording_toggled())
self.spinner = spinner = gtk.Spinner()
spinner.show()
spinner.size(32, 32)
hbox.pack_start(spinner, False, True, 3)
hbox = gtk.HBox()
hbox.add(channelvbox)
hbox.add(playervbox)
mainvbox.add(hbox)
# add widgets to window
self.add(mainvbox)
def __init__(self):
'''Konstruktor klasy MainWindow'''
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("elSter - console")
self.window.connect("destroy", self.on_window1_destroy)
self.window.set_border_width(0)
self.container = gtk.HBox(gtk.FALSE, ConfigWindow.zmienna+1)
self.container.set_border_width(10)
self.vcontainer = gtk.VBox(gtk.FALSE,2)
self.window.set_default_size((self.size_of_window * ConfigWindow.zmienna) + 10 * ConfigWindow.zmienna * ConfigWindow.iloscbt,
(self.size_of_window * ConfigWindow.iloscbt) + 10 * ConfigWindow.zmienna * ConfigWindow.iloscbt)
#self.window.set_default_size(640,320)
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_policy(gtk.POLICY_ALWAYS,gtk.POLICY_ALWAYS)
self.scrolled_window.show()
# self.window.add(self.vcontainer)
self.window.add(self.vcontainer)
# self.scrolled_window.add(self.menuTool())
# self.scrolled_window.add(self.container)
#self.scrolled_window.add(self.container)
#self.scrolled_window.set_size_request(640,320)
# self.vcontainer.add(self.scrolled_window)
self.vcontainer.pack_start(self.menuTool(),False,False,0)
self.vcontainer.pack_start(self.container, False, False, 0)
#
# self.vcontainer.pack_start(self.scrolled_window,True,True,0)
# self.cb_list = gtk.ListStore(str)
# self.cb_keyboard = gtk.ComboBox(self.cb_list)
# self.cb_cell = gtk.CellRendererText()
# self.cb_keyboard.pack_start(self.cb_cell,True)
# self.cb_keyboard.add_attribute(self.cb_cell,'text',0)
# print alphabet
# for i in range(47,91):
# self.cb_list.append(alphabet[i-47])
# self.cb_keyboard.set_model(self.cb_list)
# self.cb_keyboard.show()
# global bt_table_id, bt_table
'''Początek tworzenia tablic odpowiedzialnych za przechowywanie obiektów graficznych'''
self.vBox = {}
self.btBox = {}
self.btBlackout = {}
self.sb_address = {}
self.sb_adjustment = {}
self.bt_id = {}
self.frame = {}
self.hbox_for_frame = {}
self.bt_address = {}
self.bt_table_id = [[1 for x in range(ConfigWindow.iloscbt + 1)] for y in range(ConfigWindow.zmienna + 1)]
self.bt_table = [[1 for bt_x in range(ConfigWindow.iloscbt + 1)] for bt_y in range(ConfigWindow.zmienna + 1)]
'''Uzupełnianie głównego kontenera'''
for num in range(1, ConfigWindow.zmienna + 1):
self.vBox[num] = gtk.VBox(gtk.FALSE, ConfigWindow.zmienna)
#self.vBox[num].set_size_request(1000,300)
self.container.add(self.vBox[num])
self.vBox[num].show()
'''Uzupełnianie kontenera o pionowe elementy'''
for i in range(1, ConfigWindow.zmienna2 + 1):
self.sb_adjustment[i] = gtk.Adjustment(i, 1, 100, 1, 5, 0)
self.sb_address[i] = gtk.SpinButton(self.sb_adjustment[i], 0, 0)
self.setBT(self.sb_address)
self.sb_address[i].show()
self.btBlackout[i] = gtk.ToggleButton("Blackout")
self.btBlackout[i].connect("clicked", self.blackoutclock, i, self.bt_id)
self.btBlackout[i].show()
self.vBox[i].add(self.btBlackout[i])
print self.bt_table
print self.bt_table_id
for bt in range(1, ConfigWindow.iloscbt + 1):
self.btBox[bt] = gtk.ToggleButton("LED" + str(bt))
# self.btBox[bt].connect('clicked',self.click,i,bt)
self.btBox[bt].show()
self.bt_id[bt] = self.btBox[bt].connect('clicked', self.click, i, bt)
self.bt_id[0] = 0
try:
self.bt_table[i][bt] = self.btBox[bt]
except IndexError:
print 'IndexError'
self.bt_table_id[i][bt] = self.bt_id[bt]
print self.btBox[bt]
print self.bt_table
# self.bt_table[i-1][bt-1] = self.btBox[bt]
# for self.vBox in range(1,zmienna2+1):
self.vBox[i].add(self.btBox[bt])
print self.btBox
self.frame[i] = gtk.Frame("Change address")
# self.bt_address[i] = gtk.Button("Change")
self.lel = gtk.Frame()
self.lel.set_border_width(5)
self.bt_address[i] = gtk.Button("Change")
self.bt_address[i].connect("clicked", self.click_change_address, i,self.sb_address[i])
self.frame[i].set_border_width(5)
self.bt_address[i].set_border_width(10)
self.frame[i].add(self.bt_address[i])
self.frame[i].show()
self.bt_address[i].show()
self.vBox[i].add(self.frame[i])
self.sb_adjustment[i].connect('value_changed', self.addressValueChange, i, self.bt_id, self.bt_table)
print self.bt_id
print self.bt_table_id
self.vBox[i].add(self.sb_address[i])
self.printfuckingBT()
'''Uruchomienie kilku ważnych wewnętrznych metod'''
self.printfuckingBT()
self.container.show()
self.vcontainer.show()
self.window.show()
def __init__(self, settings, config, sql, parent):
self.importtimer = 0
self.settings = settings
self.config = config
self.sql = sql
self.parent = parent
imp = self.config.get_import_parameters()
# print "Import parameters"
# print imp
self.input_settings = {}
self.pipe_to_hud = None
self.importer = fpdb_import.Importer(self, self.settings, self.config, self.sql)
self.importer.setCallHud(True)
self.importer.setMinPrint(settings['minPrint'])
self.importer.setQuiet(False)
self.importer.setFailOnError(False)
self.importer.setHandCount(0)
# self.importer.setWatchTime()
self.server = settings['db-host']
self.user = settings['db-user']
self.password = settings['db-password']
self.database = settings['db-databaseName']
self.mainVBox = gtk.VBox(False,1)
hbox = gtk.HBox(True, 0) # contains 2 equal vboxes
self.mainVBox.pack_start(hbox, False, False, 0)
vbox1 = gtk.VBox(True, 0)
hbox.pack_start(vbox1, True, True, 0)
vbox2 = gtk.VBox(True, 0)
hbox.pack_start(vbox2, True, True, 0)
self.intervalLabel = gtk.Label(_("Time between imports in seconds:"))
self.intervalLabel.set_alignment(xalign=1.0, yalign=0.5)
vbox1.pack_start(self.intervalLabel, False, True, 0)
hbox = gtk.HBox(False, 0)
vbox2.pack_start(hbox, False, True, 0)
self.intervalEntry = gtk.Entry()
self.intervalEntry.set_text(str(self.config.get_import_parameters().get("interval")))
hbox.pack_start(self.intervalEntry, False, False, 0)
lbl1 = gtk.Label()
hbox.pack_start(lbl1, expand=False, fill=True)
lbl = gtk.Label('')
vbox1.pack_start(lbl, expand=False, fill=True)
lbl = gtk.Label('')
vbox2.pack_start(lbl, expand=False, fill=True)
self.addSites(vbox1, vbox2)
self.textbuffer = gtk.TextBuffer()
self.textview = gtk.TextView(self.textbuffer)
hbox = gtk.HBox(False, 0)
self.mainVBox.pack_start(hbox, expand=True, padding=3)
hbox = gtk.HBox(False, 0)
self.mainVBox.pack_start(hbox, expand=False, padding=3)
lbl1 = gtk.Label()
hbox.pack_start(lbl1, expand=True, fill=False)
self.doAutoImportBool = False
self.startButton = gtk.ToggleButton(_(" Start _Auto Import "))
self.startButton.connect("clicked", self.startClicked, "start clicked")
hbox.pack_start(self.startButton, expand=False, fill=False)
lbl2 = gtk.Label()
hbox.pack_start(lbl2, expand=True, fill=False)
hbox = gtk.HBox(False, 0)
hbox.show()
self.mainVBox.pack_start(hbox, expand=True, padding=3)
scrolledwindow = gtk.ScrolledWindow()
scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.mainVBox.pack_end(scrolledwindow, expand=True)
scrolledwindow.add(self.textview)
self.mainVBox.show_all()
self.addText(_("Auto Import Ready."))
def __init__(self, parent):
super(JigsawPuzzleUI, self).__init__(border_color=COLOR_FRAME_OUTER)
self._shuffling = False
self._parent = parent
# We want the translatables to be detected but not yet translated
global _
_ = lambda x: x
self.labels_to_translate = []
self._state = GAME_IDLE
self._readonly = False
self._join_time = 0
inner_table = gtk.Table(2, 2, False)
self.add(inner_table)
self.game = JigsawPuzzleWidget()
self.game.connect('picked', self.piece_pick_cb, False)
self.game.connect('dropped', self.piece_drop_cb)
self.game.connect('solved', self.do_solve)
self.game.connect('cutter-changed', self.cutter_change_cb)
self.game.show()
# panel is a holder for everything on the left side down to (not inclusive) the language dropdown
panel = gtk.VBox()
# Logo image
img_logo = gtk.Image()
img_logo.set_from_file("icons/logo.png")
img_logo.show()
panel.pack_start(img_logo, expand=False, fill=False)
# Control panel has the image controls
control_panel = BorderFrame(border=BORDER_ALL_BUT_BOTTOM,
border_color=COLOR_FRAME_CONTROLS,
bg_color=COLOR_BG_CONTROLS)
control_panel_box = gtk.VBox()
scrolled = gtk.ScrolledWindow()
scrolled.props.hscrollbar_policy = gtk.POLICY_NEVER
scrolled.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC
scrolled.show()
scrolled.add_with_viewport(control_panel_box)
scrolled.child.modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse(COLOR_BG_CONTROLS))
control_panel.add(scrolled)
spacer = gtk.Label()
spacer.set_size_request(-1, 5)
control_panel_box.pack_start(spacer, expand=False, fill=False)
btn_box = gtk.Table(2, 5, False)
btn_box.set_col_spacings(5)
btn_box.set_row_spacings(5)
btn_box.attach(gtk.Label(), 0, 1, 0, 2)
# Cut type buttons
self.btn_basic_cut = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'cut_basic.svg')))
self.btn_basic_cut.set_image(i)
btn_box.attach(prepare_btn(self.btn_basic_cut), 1, 2, 0, 1, 0, 0)
self.btn_simple_cut = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'cut_simple.svg')))
self.btn_simple_cut.set_image(i)
btn_box.attach(prepare_btn(self.btn_simple_cut), 2, 3, 0, 1, 0, 0)
self.btn_classic_cut = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'cut_classic.svg')))
self.btn_classic_cut.set_image(i)
# Link cutter buttons with cutter styles
self.btn_cut_mapping = {
'basic': self.btn_basic_cut,
'simple': self.btn_simple_cut,
'classic': self.btn_classic_cut,
}
for k, v in self.btn_cut_mapping.items():
v.connect("released", self.set_piece_cut, k)
btn_box.attach(prepare_btn(self.btn_classic_cut), 3, 4, 0, 1, 0, 0)
# Difficulty level buttons
self.btn_easy_level = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'level_easy.svg')))
self.btn_easy_level.set_active(True)
self.btn_easy_level.set_image(i)
btn_box.attach(prepare_btn(self.btn_easy_level), 1, 2, 1, 2, 0, 0)
self.btn_normal_level = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'level_normal.svg')))
self.btn_normal_level.set_image(i)
btn_box.attach(prepare_btn(self.btn_normal_level), 2, 3, 1, 2, 0, 0)
self.btn_hard_level = gtk.ToggleButton()
i = gtk.Image()
i.set_from_pixbuf(
utils.load_image(os.path.join('icons', 'level_hard.svg')))
self.btn_hard_level.set_image(i)
# Link level buttons with levels
self.btn_level_mapping = {
3: self.btn_easy_level,
5: self.btn_normal_level,
8: self.btn_hard_level,
}
for k, v in self.btn_level_mapping.items():
v.connect("released", self.set_level, k)
btn_box.attach(prepare_btn(self.btn_hard_level), 3, 4, 1, 2, 0, 0)
btn_box.attach(gtk.Label(), 4, 5, 0, 2)
control_panel_box.pack_start(btn_box, expand=False)
self.thumb = ImageSelectorWidget(frame_color=COLOR_FRAME_THUMB,
prepare_btn_cb=prepare_btn,
method=utils.RESIZE_PAD,
image_dir="images",
parent=self._parent)
self.thumb.connect("category_press", self.do_select_category)
self.thumb.connect("image_press", self.do_shuffle)
control_panel_box.pack_start(self.thumb, expand=False)
spacer = gtk.Label()
spacer.set_size_request(-1, 5)
control_panel_box.pack_start(spacer, expand=False, fill=False)
# The game control buttons
btn_box = gtk.Table(3, 4, False)
btn_box.set_row_spacings(2)
btn_box.attach(gtk.Label(), 0, 1, 0, 4)
btn_box.attach(gtk.Label(), 2, 3, 0, 4)
self.btn_solve = prepare_btn(gtk.Button(" "), 200)
self.labels_to_translate.append([self.btn_solve, _("Solve")])
self.btn_solve.connect("clicked", self.do_solve)
btn_box.attach(self.btn_solve, 1, 2, 0, 1, 0, 0)
self.btn_shuffle = prepare_btn(gtk.Button(" "), 200)
self.labels_to_translate.append([self.btn_shuffle, _("Shuffle")])
self.btn_shuffle.connect("clicked", self.do_shuffle)
btn_box.attach(self.btn_shuffle, 1, 2, 1, 2, 0, 0)
self.btn_add = prepare_btn(gtk.Button(" "), 200)
self.labels_to_translate.append([self.btn_add, _("My Picture")])
self.btn_add.connect("clicked", self.do_add_image)
btn_box.attach(self.btn_add, 1, 2, 2, 3, 0, 0)
self.btn_hint = prepare_btn(gtk.ToggleButton(" "), 200)
self.labels_to_translate.append([self.btn_hint, _("Board Hint")])
self.btn_hint.connect("clicked", self.do_show_hint)
btn_box.attach(self.btn_hint, 1, 2, 3, 4, 0, 0)
control_panel_box.pack_start(btn_box, False)
self.control_panel_box = control_panel_box
# Control panel end
panel.pack_start(control_panel, expand=True, fill=True)
inner_table.attach(panel, 0, 1, 0, 1, 0)
self.game_box = BorderFrame(border_color=COLOR_FRAME_GAME)
self.game_box.add(self.game)
self.notebook = gtk.Notebook()
self.notebook.show()
self.notebook.props.show_border = False
self.notebook.props.show_tabs = False
self.notebook.append_page(self.game_box)
inner_table.attach(self.notebook, 1, 2, 0, 1)
lang_combo = prepare_btn(
LanguageComboBox('org.worldwideworkshop.olpc.JigsawPuzzle'))
lang_combo.connect('changed', self.do_select_language)
# Push the gettext translator into the global namespace
del _
lang_combo.install()
lang_box = BorderFrame(bg_color=COLOR_BG_CONTROLS,
border_color=COLOR_FRAME_CONTROLS)
hbox = gtk.HBox(False)
vbox = gtk.VBox(False)
vbox.pack_start(lang_combo, padding=8)
hbox.pack_start(vbox, padding=8)
lang_box.add(hbox)
inner_table.attach(lang_box, 0, 1, 1, 2, gtk.FILL, gtk.FILL)
timer_box = BorderFrame(border=BORDER_ALL_BUT_LEFT,
bg_color=COLOR_BG_CONTROLS,
border_color=COLOR_FRAME_CONTROLS)
timer_hbox = gtk.HBox(False)
self.timer = TimerWidget(bg_color=COLOR_BG_BUTTONS[0][1],
fg_color=COLOR_FG_BUTTONS[0][1],
lbl_color=COLOR_BG_BUTTONS[1][1])
self.timer.set_sensitive(False)
self.timer.set_border_width(3)
self.labels_to_translate.append((self.timer, _("Time: ")))
timer_hbox.pack_start(self.timer, False, padding=8)
self.timer.connect('timer_toggle', self.timer_toggle_cb)
self.msg_label = gtk.Label()
self.msg_label.show()
timer_hbox.pack_start(self.msg_label, True)
self.do_select_language(lang_combo)
self.buddy_panel = BuddyPanel(BUDDYMODE_COLLABORATION)
self.buddy_panel.show()
if not parent._shared_activity:
self.do_select_category(self)
self.set_contest_mode(False)
# Assert consistent state
self.cutter_change_cb(None, self.game.get_cutter(),
self.game.get_target_pieces_per_line())
def new(self):
self.channel = None
# Styling for the label that appears when the list is empty
hildon.hildon_helper_set_logical_font(self.empty_label, \
'LargeSystemFont')
hildon.hildon_helper_set_logical_color(self.empty_label, \
gtk.RC_FG, gtk.STATE_NORMAL, 'SecondaryTextColor')
self.episode_actions = gPodderEpisodeActions(self.main_window, \
episode_list_status_changed=self.episode_list_status_changed, \
episode_is_downloading=self.episode_is_downloading, \
show_episode_shownotes=self.show_episode_shownotes, \
playback_episodes=self.playback_episodes, \
download_episode_list=self.download_episode_list, \
show_episode_in_download_manager=self.show_episode_in_download_manager, \
add_download_task_monitor=self.add_download_task_monitor, \
remove_download_task_monitor=self.remove_download_task_monitor, \
for_each_episode_set_task_status=self.for_each_episode_set_task_status, \
delete_episode_list=self.delete_episode_list)
# Tap-and-hold (aka "long press") context menu
self.touched_episode = None
self.context_menu = gtk.Menu()
# "Emulate" hildon_gtk_menu_new
self.context_menu.set_name('hildon-context-sensitive-menu')
self.context_menu.append(self.action_shownotes.create_menu_item())
self.context_menu.append(self.action_download.create_menu_item())
self.context_menu.append(self.action_delete.create_menu_item())
self.context_menu.append(gtk.SeparatorMenuItem())
self.context_menu.append(self.action_keep.create_menu_item())
self.context_menu.append(self.action_mark_as_old.create_menu_item())
self.context_menu.show_all()
self.treeview.tap_and_hold_setup(self.context_menu)
# Workaround for Maemo bug XXX
self.button_search_episodes_clear.set_name('HildonButton-thumb')
appmenu = hildon.AppMenu()
for action in (self.action_update, \
self.action_rename, \
self.action_login, \
self.action_website, \
self.action_unsubscribe, \
self.action_check_for_new_episodes, \
self.action_delete_episodes):
button = gtk.Button()
action.connect_proxy(button)
appmenu.append(button)
self.pause_sub_button = hildon.CheckButton(
gtk.HILDON_SIZE_FINGER_HEIGHT)
self.pause_sub_button.set_label(_('Pause subscription'))
self.pause_sub_button.connect(
'toggled', self.on_pause_subscription_button_toggled)
appmenu.append(self.pause_sub_button)
self.keep_episodes_button = hildon.CheckButton(
gtk.HILDON_SIZE_FINGER_HEIGHT)
self.keep_episodes_button.set_label(_('Keep episodes'))
self.keep_episodes_button.connect('toggled',
self.on_keep_episodes_button_toggled)
appmenu.append(self.keep_episodes_button)
for filter in (self.item_view_episodes_all, \
self.item_view_episodes_undeleted, \
self.item_view_episodes_downloaded):
button = gtk.ToggleButton()
filter.connect_proxy(button)
appmenu.add_filter(button)
appmenu.show_all()
self.main_window.set_app_menu(appmenu)
def __init__(self, tab_domain):
self.viewport = gtk.Viewport()
self.viewport.set_shadow_type(gtk.SHADOW_NONE)
self.vbox = gtk.VBox(spacing=3)
self.alternate_viewport = gtk.Viewport()
self.alternate_viewport.set_shadow_type(gtk.SHADOW_NONE)
self.alternate_view = False
self.search_window = None
self.search_table = None
self.last_search_text = ''
self.tab_domain = tab_domain or []
self.tab_counter = []
tooltips = common.Tooltips()
self.filter_vbox = gtk.VBox(spacing=0)
self.filter_vbox.set_border_width(0)
hbox = gtk.HBox(homogeneous=False, spacing=0)
self.search_entry = PlaceholderEntry()
self.search_entry.set_placeholder_text(_('Search'))
self.search_entry.set_alignment(0.0)
self.search_entry.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY,
'tryton-find')
self.search_entry.set_icon_tooltip_text(gtk.ENTRY_ICON_PRIMARY,
_('Open filters'))
self.completion = gtk.EntryCompletion()
self.completion.set_model(gtk.ListStore(str))
self.completion.set_text_column(0)
self.completion.props.inline_selection = True
self.completion.props.popup_set_width = False
self.completion.set_match_func(lambda *a: True)
self.completion.connect('match-selected', self.match_selected)
self.search_entry.connect('activate', self.activate)
self.search_entry.set_completion(self.completion)
self.search_entry.connect('key-press-event', self.key_press)
self.search_entry.connect('focus-in-event', self.focus_in)
self.search_entry.connect('icon-press', self.icon_press)
hbox.pack_start(self.search_entry, expand=True, fill=True)
def popup(widget):
menu = widget._menu
for child in menu.get_children():
menu.remove(child)
if not widget.props.active:
menu.popdown()
return
def menu_position(menu, data=None):
widget_allocation = widget.get_allocation()
if hasattr(widget.window, 'get_root_coords'):
x, y = widget.window.get_root_coords(
widget_allocation.x, widget_allocation.y)
else:
x, y = widget.window.get_origin()
x += widget_allocation.x
y += widget_allocation.y
return (x, y + widget_allocation.height, False)
for id_, name, domain in self.bookmarks():
menuitem = gtk.MenuItem(name)
menuitem.connect('activate', self.bookmark_activate, domain)
menu.add(menuitem)
menu.show_all()
menu.popup(None, None, menu_position, 0, 0)
def deactivate(menuitem, togglebutton):
togglebutton.props.active = False
but_bookmark = gtk.ToggleButton()
self.but_bookmark = but_bookmark
tooltips.set_tip(but_bookmark, _('Show bookmarks of filters'))
img_bookmark = gtk.Image()
img_bookmark.set_from_stock('tryton-bookmark',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_bookmark.set_alignment(0.5, 0.5)
but_bookmark.add(img_bookmark)
but_bookmark.set_relief(gtk.RELIEF_NONE)
menu = gtk.Menu()
menu.set_property('reserve-toggle-size', False)
menu.connect('deactivate', deactivate, but_bookmark)
but_bookmark._menu = menu
but_bookmark.connect('toggled', popup)
hbox.pack_start(but_bookmark, expand=False, fill=False)
but_prev = gtk.Button()
self.but_prev = but_prev
tooltips.set_tip(but_prev, _('Previous'))
but_prev.connect('clicked', self.search_prev)
img_prev = gtk.Image()
img_prev.set_from_stock('tryton-go-previous',
gtk.ICON_SIZE_SMALL_TOOLBAR)
img_prev.set_alignment(0.5, 0.5)
but_prev.add(img_prev)
but_prev.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(but_prev, expand=False, fill=False)
but_next = gtk.Button()
self.but_next = but_next
tooltips.set_tip(but_next, _('Next'))
but_next.connect('clicked', self.search_next)
img_next = gtk.Image()
img_next.set_from_stock('tryton-go-next', gtk.ICON_SIZE_SMALL_TOOLBAR)
img_next.set_alignment(0.5, 0.5)
but_next.add(img_next)
but_next.set_relief(gtk.RELIEF_NONE)
hbox.pack_start(but_next, expand=False, fill=False)
hbox.show_all()
hbox.set_focus_chain([self.search_entry])
self.filter_vbox.pack_start(hbox, expand=False, fill=False)
hseparator = gtk.HSeparator()
hseparator.show()
self.filter_vbox.pack_start(hseparator, expand=False, fill=False)
if self.tab_domain:
self.notebook = gtk.Notebook()
try:
self.notebook.props.homogeneous = True
except AttributeError:
# No more supported by GTK+3
pass
self.notebook.set_scrollable(True)
for name, domain, count in self.tab_domain:
hbox = gtk.HBox(spacing=3)
label = gtk.Label('_' + name)
label.set_use_underline(True)
hbox.pack_start(label, expand=True, fill=True)
counter = gtk.Label()
hbox.pack_start(counter, expand=False, fill=True)
hbox.show_all()
self.notebook.append_page(gtk.VBox(), hbox)
self.tab_counter.append(counter)
self.filter_vbox.pack_start(self.notebook, expand=True, fill=True)
self.notebook.show_all()
# Set the current page before connecting to switch-page to not
# trigger the search a second times.
self.notebook.set_current_page(0)
self.notebook.get_nth_page(0).pack_end(self.viewport)
self.notebook.connect('switch-page', self.switch_page)
self.notebook.connect_after('switch-page', self.switch_page_after)
filter_expand = True
else:
self.notebook = None
self.vbox.pack_end(self.viewport)
filter_expand = False
self.vbox.pack_start(self.filter_vbox, expand=filter_expand, fill=True)
self.but_next.set_sensitive(False)
self.but_prev.set_sensitive(False)
tooltips.enable()
def __init__(self):
gtk.EventBox.__init__(self)
self.modify_bg(gtk.STATE_NORMAL, COLORES["contenido"])
self.set_border_width(4)
self.game = False
self.pump = False
self.firstrun = True
self.pygamecanvas = sugargame2.canvas.PygameCanvas(self)
grupo1 = gtk.Alignment(0.5, 1, 0, 0)
separador = gtk.HSeparator()
grupo1.add(separador)
grupo2 = gtk.Alignment(1, 0.5, 0, 0)
grupo2.add(self.pygamecanvas)
grupo3 = gtk.Alignment(1, 1, 0, 0)
vbox = gtk.VBox()
butt = gtk.Button()
img = gtk.Image()
img.set_from_file("Imagenes/go_back_disabled.png")
butt.set_relief(gtk.RELIEF_NONE)
butt.set_image(img)
butt.set_label("")
butt.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"])
butt.connect("clicked", self.__reset_menu)
butt.connect("enter-notify-event", self.__color)
butt.connect("leave-notify-event", self.__decolor)
img.show()
butt.show()
vbox.add(butt)
self.score_label = gtk.Label("SCORE\n0")
self.score_label.set_property("justify", gtk.JUSTIFY_RIGHT)
self.score_label.modify_font(
pango.FontDescription("DejaVu Sans Mono 22"))
self.score_label.modify_fg(gtk.STATE_NORMAL, COLORES["window"])
self.score_label.set_padding(xpad=30, ypad=30)
self.score_label.show()
vbox.add(self.score_label)
butt = gtk.ToggleButton()
butt.set_active(False)
butt.set_relief(gtk.RELIEF_NONE)
butt.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"])
img = gtk.Image()
img.set_from_file("Iconos/stock_volume-max.svg")
butt.set_image(img)
butt.set_label("")
img.show()
butt.show()
butt.connect("toggled", self.update_volume)
self.volbtn = butt
vbox.add(butt)
grupo3.add(vbox)
hb = gtk.HBox()
hb.pack_start(grupo1)
hb.add(grupo2)
hb.pack_end(grupo3)
self.add(hb)
self.connect("size-allocate", self.__reescalar)
self.show_all()
def __init__(self, url, title):
gtk.FileChooserDialog.__init__(self,
title,
None,
gtk.FILE_CHOOSER_ACTION_SAVE,
backend="gnomevfs")
self.set_local_only(False)
self.URI = url
self.uri = self.URI.get_url()
self.select_uri(self.uri)
## self.set_current_folder (self.uri)
## self.set_current_name (self.uri)
accelerator = gtk.AccelGroup()
self.add_accel_group(accelerator)
b = self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT)
b.add_accelerator('clicked', accelerator, gtk.keysyms.Escape, 0, 0)
b = self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
b.add_accelerator('clicked', accelerator, gtk.keysyms.Return, 0, 0)
b = self.add_button(gtk.STOCK_COPY, RESPONSE_COPY)
b.add_accelerator('clicked', accelerator, gtk.keysyms.c,
gtk.gdk.CONTROL_MASK, 0)
b = self.add_button(gtk.STOCK_FIND, RESPONSE_VIEW)
b.add_accelerator('clicked', accelerator, gtk.keysyms.v,
gtk.gdk.CONTROL_MASK, 0)
# added widgets
vbox = gtk.VBox()
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.set_spacing(6)
hbox.set_border_width(6)
self.invalid_w = gtk.ToggleButton(_('Invalid'))
hbox.pack_start(self.invalid_w, expand=False)
tips.set_tip(
self.invalid_w, "Set this to indicate an invalid URL",
"An invalid url may not usually be used, "
"but be kept for historical purposes.")
self.invalid_w.set_active(self.URI.invalid or False)
self.inexact_w = gtk.ToggleButton(_('Inexact'))
hbox.pack_start(self.inexact_w, expand=False)
tips.set_tip(self.inexact_w,
"Indicates an URL that is not the resource proper",
"An inexact URL usually requires manual intervention.")
self.inexact_w.set_active(self.URI.inexact or False)
hbox.pack_start(gtk.Label(_(' Date accessed:')), False)
self.date_w = gtk.Entry()
hbox.pack_start(self.date_w)
tips.set_tip(
self.date_w, "The date (and time) the resource has been accessed.",
"This information is often required"
" by bibliographical standards.")
self.date_w.set_text(self.URI.date or '')
hbox = gtk.HBox()
vbox.pack_start(hbox)
hbox.set_spacing(6)
hbox.set_border_width(6)
hbox.pack_start(gtk.Label(_('Note:')), False)
self.note_w = gtk.Entry()
hbox.pack_start(self.note_w)
tips.set_tip(self.note_w,
"A note e.g. about the resource or its accessability.",
"Information that might help the user")
self.note_w.set_text(self.URI.note or '')
self.set_extra_widget(vbox)
self.show_all()
def __init__(self, session):
'''constructor'''
gtk.VBox.__init__(self)
self.session = session
self.config_dir = session.config_dir
self._enabled = True
Avatar = extension.get_default('avatar')
self.avatar = Avatar(cell_dimension=48)
self.avatarBox = gtk.EventBox()
self.avatarBox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.avatarBox.connect('button-press-event', self.on_avatar_click)
self.avatarBox.add(self.avatar)
self.avatarBox.set_tooltip_text(_('Click here to set your avatar'))
self.avatarBox.set_border_width(4)
self.avatar_path = self.config_dir.get_path("last_avatar")
if not self.session.config_dir.file_readable(self.avatar_path):
path = gui.theme.image_theme.user
else:
path = self.avatar_path
self.avatar.set_from_file(path)
self.nick = TextField.TextField(session.contacts.me.display_name,
session.contacts.me.account, False)
self.nick.set_tooltip_text(_('Click here to set your nick name'))
self.status = StatusButton.StatusButton(session)
self.status.set_tooltip_text(_('Click here to change your status'))
self.status.set_status(session.contacts.me.status)
self.search = gtk.ToggleButton()
self.search.set_tooltip_text(_('Search (Ctrl+F)'))
self.mail = gtk.Button(label="(0)")
self.mail.set_tooltip_text(_('Click here to access your mail'))
self.mail.get_settings().set_property("gtk-button-images", True)
self.mail.set_image(
gtk.image_new_from_file(gui.theme.image_theme.mailbox))
self.mail.set_relief(gtk.RELIEF_NONE)
self.search.set_image(
gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU))
self.search.set_relief(gtk.RELIEF_NONE)
self.empty_message_text = _("Click here to set your message")
self.message = TextField.TextField(
session.contacts.me.message,
'[I]' + self.empty_message_text + '[/I]', True)
self.message.set_tooltip_text(self.empty_message_text)
self.toolbar = gtk.HBox()
hbox = gtk.HBox()
hbox.set_border_width(1)
hbox.pack_start(self.avatarBox, False)
vbox = gtk.VBox()
nick_hbox = gtk.HBox()
nick_hbox.pack_start(self.nick, True, True)
nick_hbox.pack_start(self.mail, False)
nick_hbox.pack_start(self.search, False)
# enable this code and you'll get a nice button which fires a signal
#def do_something_weird(item):
# from e3.base.Event import Event
# session.add_event(Event.EVENT_DISCONNECTED, 'Tested disconnection', 0)
#test_btn=gtk.Button(label="(!)")
#test_btn.connect('clicked', do_something_weird)
#test_btn.show()
#nick_hbox.pack_start(test_btn, False)
vbox.pack_start(nick_hbox, False)
message_hbox = gtk.HBox()
message_hbox.pack_start(self.message, True, True)
message_hbox.pack_start(self.status, False)
vbox.pack_start(message_hbox, False)
hbox.pack_start(vbox, True, True)
self.pack_start(hbox, True, True)
self.pack_start(self.toolbar, False)
hbox.show()
nick_hbox.show()
message_hbox.show()
vbox.show()
self._add_subscriptions()
def __init__(self, gfxwindow):
self.gfxwindow = gfxwindow
buttonrow = gtk.HBox()
# TODO 3D: make better icons for each of these, this is
# complicated, we have to find a way to not use absolute
# paths, and to include the icons in the build....
## select_image = gtk.Image()
## select_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/select.png")
## rotate_image = gtk.Image()
## rotate_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/rotate.png")
## dolly_image = gtk.Image()
## dolly_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/dolly.png")
# Use the "pressed" and "released" signals because the "clicked" signal is
# emitted when the state is changed by setactive
self.selectbutton = gtk.ToggleButton("Select")
#self.selectbutton.set_image(select_image)
buttonrow.pack_start(self.selectbutton)
tooltips.set_tooltip_text(
self.selectbutton, "Select objects according to toolbox behavior")
gtklogger.connect(self.selectbutton, "pressed", self.selectCB)
gtklogger.connect(self.selectbutton, "released", self.selectReleaseCB)
self.tumblebutton = gtk.ToggleButton("Tumble")
#self.tumblebutton.set_image(rotate_image)
buttonrow.pack_start(self.tumblebutton)
tooltips.set_tooltip_text(self.tumblebutton,
"Tumble the view using the mouse")
gtklogger.connect(self.tumblebutton, "pressed", self.tumbleCB)
gtklogger.connect(self.tumblebutton, "released", self.tumbleReleaseCB)
self.dollybutton = gtk.ToggleButton("Dolly")
#self.dollybutton.set_image(dolly_image)
buttonrow.pack_start(self.dollybutton)
tooltips.set_tooltip_text(self.dollybutton,
"Dolly in and out using the mouse")
gtklogger.connect(self.dollybutton, "pressed", self.dollyCB)
gtklogger.connect(self.dollybutton, "released", self.dollyReleaseCB)
self.trackbutton = gtk.ToggleButton("Track")
buttonrow.pack_start(self.trackbutton)
tooltips.set_tooltip_text(
self.trackbutton,
"Move camera and visible objects parallel to focal plane")
gtklogger.connect(self.trackbutton, "pressed", self.trackCB)
gtklogger.connect(self.trackbutton, "released", self.trackReleaseCB)
# TODO 3D: separator between stateful and non-stateful buttons?
self.fillbutton = gtk.Button("Fill")
buttonrow.pack_start(self.fillbutton)
tooltips.set_tooltip_text(
self.fillbutton,
"Dolly in or out such that visible objects approximately fill viewport"
)
gtklogger.connect(self.fillbutton, "clicked", self.fillCB)
clippingscale = gtk.HScale(toolboxGUI.clippingadj)
clippingscale.set_update_policy(gtk.UPDATE_DELAYED)
clippingscale.set_value_pos(gtk.POS_RIGHT)
buttonrow.pack_start(clippingscale)
tooltips.set_tooltip_text(
clippingscale,
"Adjust the near clipping plane to view cross section")
# TODO 3D: more useful things in the toolbar?
self.gtk = buttonrow
# self.selectHandler = SelectMouseHandler(gfxwindow)
self.tumbleHandler = TumbleMouseHandler(gfxwindow)
self.dollyHandler = DollyMouseHandler(gfxwindow)
self.trackHandler = TrackMouseHandler(gfxwindow)
self.selectbutton.set_active(True)
def __init__(self, *args, **kwargs):
super(BrowserTab, self).__init__(*args, **kwargs)
h = History()
row = h.get_bookmark_list()
for r in row:
bookmarks_list.append(r[0])
self.zeronet_button = gtk.ToggleButton()
self.zeronet_button.set_size_request(50, 50)
self.zeronet_button.connect("clicked", self.start_zeronet)
self.bottom_hpan = gtk.HPaned()
self.webview = webkit.WebView()
scrolled_window = gtk.ScrolledWindow()
self.webview.connect("load-finished", self.on_finish_loading)
self.webview.connect("download-requested", self.initiate_download)
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.webview)
self.history_window = gtk.ScrolledWindow()
self.history_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.history_window.set_size_request(200, 10)
self.history_box = gtk.VBox()
header_hbox = gtk.HBox()
header = gtk.Label("History")
close_button = gtk.Button()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
close_button.connect("clicked", self.hide_history)
close_button.set_image(image)
close_button.set_relief(gtk.RELIEF_NONE)
header_hbox.pack_start(header, True, True, 0)
header_hbox.pack_end(close_button, False, False, 0)
self.history_box.pack_start(header_hbox, False, False, 0)
self.history_list_store = gtk.ListStore(str)
self.history_tree_view = gtk.TreeView(self.history_list_store)
self.history_box.pack_start(self.history_window, True, True, 0)
self.history_window.add_with_viewport(self.history_tree_view)
self.bookmarks_window = gtk.ScrolledWindow()
self.bookmarks_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.bookmarks_box = gtk.VBox()
self.bookmarks_window.set_size_request(200, 10)
header_hbox = gtk.HBox()
header = gtk.Label("Bookmarks")
close_button = gtk.Button()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU)
close_button.connect("clicked", self.hide_bookmarks)
close_button.set_image(image)
close_button.set_relief(gtk.RELIEF_NONE)
header_hbox.pack_start(header, True, True, 0)
header_hbox.pack_end(close_button, False, False, 0)
self.bookmarks_box.pack_start(header_hbox, False, False, 0)
self.bookmarks_list_store = gtk.ListStore(str)
self.bookmarks_tree_view = gtk.TreeView(self.bookmarks_list_store)
self.bookmarks_box.pack_start(self.bookmarks_window, True, True, 0)
self.bookmarks_window.add_with_viewport(self.bookmarks_tree_view)
self.find_entry = gtk.Entry()
self.find_entry.connect(
"activate", lambda x: self.webview.search_text(
self.find_entry.get_text(), False, True, True))
find_box = gtk.HBox()
close_button = gtk.Button("Close")
close_button.connect("clicked", lambda x: find_box.hide())
prev_button = gtk.Button("Previous")
next_button = gtk.Button("Next")
prev_button.connect(
"clicked", lambda x: self.webview.search_text(
self.find_entry.get_text(), False, False, True))
next_button.connect(
"clicked", lambda x: self.webview.search_text(
self.find_entry.get_text(), False, True, True))
find_box.pack_start(close_button, False, False, 0)
find_box.pack_start(self.find_entry, False, False, 0)
find_box.pack_start(prev_button, False, False, 0)
find_box.pack_start(next_button, False, False, 0)
self.find_box = find_box
self.pack_end(find_box, False, False, 0)
main_hbox = gtk.HBox(False, 0)
menu_url_vbox = gtk.VBox(False, 0)
menu_hbox = gtk.HBox(False, 0)
url_hbox = gtk.HBox(False, 0)
image = gtk.Image()
self.new_tab_button = gtk.Button()
image.set_from_stock(gtk.STOCK_NEW, gtk.ICON_SIZE_MENU)
self.new_tab_button.set_image(image)
self.new_tab_button.set_relief(gtk.RELIEF_NONE)
self.menu1 = gtk.Button("Create")
self.menu1.connect("clicked", self.create_site)
self.menu2 = gtk.Button("Update")
self.menu2.connect("clicked", self.signSite)
self.menu3 = gtk.Button("Publish")
self.menu3.connect("clicked", self.publish_site)
self.settings = gtk.Button()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_MENU)
self.settings.set_image(image)
self.settings.set_size_request(78, 30)
self.settings.set_relief(gtk.RELIEF_NONE)
self.menu = gtk.Menu()
self.menu_items = ["New Tab", "History", "Bookmarks", "About", "Quit"]
for i in self.menu_items:
menu_item = gtk.MenuItem(i)
self.menu.append(menu_item)
menu_item.connect("activate", self.menuitem_response, i)
menu_item.show()
self.settings.connect("event", self.menu_show)
self.url_textbox = gtk.Entry()
self.go_back = gtk.Button()
image = gtk.Image()
image.set_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_MENU)
self.go_back.set_image(image)
self.go_back.connect("clicked", lambda x: self.webview.go_back())
self.go_back.set_relief(gtk.RELIEF_NONE)
self.url_textbox.connect("activate", self.load_url)
image = gtk.Image()
self.go_forward = gtk.Button()
image.set_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_MENU)
self.go_forward.set_image(image)
self.go_forward.connect("clicked", lambda x: self.webview.go_forward())
self.go_forward.set_relief(gtk.RELIEF_NONE)
image = gtk.Image()
image.set_from_file("not_bookmarked.ico")
self.bookmark_image = gtk.ToggleButton()
self.bookmark_image.set_image(image)
self.bookmark_image.set_active(False)
vertical_line = gtk.VSeparator()
image = gtk.Image()
self.bookmark_button = gtk.Button()
image.set_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_MENU)
self.bookmark_button.set_image(image)
self.bookmark_button.connect("clicked", self.add_bookmark)
self.bookmark_button.set_relief(gtk.RELIEF_NONE)
image = gtk.Image()
self.refresh = gtk.Button()
image.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU)
self.refresh.set_image(image)
self.refresh.connect("clicked", lambda x: self.webview.reload())
self.refresh.set_relief(gtk.RELIEF_NONE)
self.secure_icon = gtk.Image()
self.secure_button = gtk.Button()
self.secure_icon.set_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU)
self.secure_button.set_image(self.secure_icon)
self.dialog = gtk.Dialog(title="ZeroNet")
self.pbar = gtk.ProgressBar()
self.pbar.set_text("Starting Zeronet")
self.dialog.vbox.pack_start(self.pbar, True, True, 0)
self.pbar.show()
self.pack_start(main_hbox, False, False, 0)
main_hbox.pack_start(menu_url_vbox, True, True, 0)
menu_url_vbox.pack_start(menu_hbox, True, True, 0)
menu_hbox.pack_start(self.new_tab_button, False, True, 0)
menu_hbox.pack_start(self.menu1, True, True, 0)
menu_hbox.pack_start(self.menu2, True, True, 0)
menu_hbox.pack_start(self.menu3, True, True, 0)
menu_hbox.pack_end(self.settings, False, False, 0)
menu_url_vbox.pack_start(url_hbox, True, True, 0)
url_hbox.pack_start(self.go_back, False, False, 0)
url_hbox.pack_start(self.secure_button, False, False, 0)
url_hbox.pack_start(self.url_textbox, True, True, 0)
url_hbox.pack_start(self.refresh, False, False, 0)
url_hbox.pack_start(self.go_forward, False, False, 0)
url_hbox.pack_start(self.bookmark_image, False, False, 0)
url_hbox.pack_start(vertical_line, False, False, 2)
url_hbox.pack_start(self.bookmark_button, False, False, 0)
main_hbox.pack_start(self.zeronet_button, False, False, 0)
self.bottom_hpan.add2(scrolled_window)
self.pack_start(self.bottom_hpan, True, True, 0)
scrolled_window.show_all()
main_hbox.show_all()
self.bottom_hpan.show()
image = gtk.Image()
if not pid:
image.set_from_file("2.png")
self.zeronet_button.set_image(image)
self.zeronet_button.set_active(False)
else:
image.set_from_file("1.png")
self.zeronet_button.set_image(image)
self.zeronet_button.set_active(True)
self.show()
def __init__(self):
# Create a TOPLEVEL WINDOW
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
# Set the postion of WINDOW to center
self.window.set_position(gtk.WIN_POS_CENTER)
# Set window title
self.window.set_title("Sample GTK window")
# Set tool tip
self.window.set_tooltip_text("This a sample GTK window")
# Set window size
self.window.set_size_request(600, 100)
# BUTTON1
# Simple sample button with text as EXIT
self.button1 = gtk.Button("EXIT")
# On button EXIT clicked destory the window
self.button1.connect("clicked", self.destroy)
# Set tool tips
self.button1.set_tooltip_text("This button will close this window")
# BUTTON2
# Simple sample button with text as EXIT
self.button2 = gtk.Button("Hide")
# On button EXIT clicked destory the window
self.button2.connect("clicked", self.hideit)
# Set tool tips
self.button2.set_tooltip_text("This button will hide the exit button")
# BUTTON3
# Simple sample button with text as EXIT
self.button3 = gtk.ToggleButton("Show")
# On button EXIT clicked destory the window
self.button3.connect("clicked", self.showit)
# Set tool tips
self.button3.set_tooltip_text("This button will show the exit button")
# BUTTON4
self.button4 = gtk.Button("Relable")
self.button4.connect("clicked", self.relable)
# Create a simple label
self.label1 = gtk.Label("This is a label")
#TEXTBOX, connect textchange method, for the signal changed
self.textbox = gtk.Entry()
self.textbox.set_text("As you type see the window title")
self.textbox.connect("changed", self.textchange)
"""
# A simple container
fixed = gtk.Fixed()
# Put buttons to the container
fixed.put(self.button1,20,30)
fixed.put(self.button2,100,30)
fixed.put(self.button3,150,30)
fixed.put(self.label1,200,100) """
"""
Comment this to section and uncomment fxied container,
to see how Fixed works. One can change VBox to HBox to see th difference """
# Combo box
self.combo = gtk.combo_box_entry_new_text()
self.combo.connect("changed", self.combo_text)
self.combo.append_text("This is some text")
self.combo.append_text("Some more text")
# HBox
self.box1 = gtk.HBox()
self.box1.pack_start(self.button1)
self.box1.pack_start(self.button2)
self.box1.pack_start(self.button3)
self.box1.pack_start(self.button4)
# self.box1.pack_start(self.textbox)
# self.box1.pack_start(self.label1)
# Above was added to VBox to make it better
# VBox
self.box2 = gtk.VBox()
# Pack HBox in VBox
self.box2.pack_start(self.box1)
self.box2.pack_start(self.label1)
self.box2.pack_start(self.textbox)
self.box2.pack_start(self.combo)
# Add fixed container to the main window
# self.window.add(fixed)
# If box enabled, uncomment the above and comment below line
self.window.add(self.box2)
# Show the created window, button...all
self.window.show_all()
# Connect destroy singal of the window to destory method [X]
self.window.connect("destroy", self.destroy)
class ImagesDemo(hildon.Window):
pixbuf_loader = None
load_timeout = None
image_stream = None
def __init__(self, parent=None):
hildon.Window.__init__(self)
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.connect("destroy", self.cleanup_callback)
self.set_title(self.__class__.__name__)
self.set_border_width(8)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.add(scroll)
vbox = gtk.VBox(False, 8)
vbox.set_border_width(8)
scroll.add_with_viewport(vbox)
label = gtk.Label();
label.set_markup("<u>Image loaded from a file</u>")
vbox.pack_start(label, False, False, 0)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
# The alignment keeps the frame from growing when users resize
# the window
align = gtk.Alignment(0.5, 0.5, 0, 0)
align.add(frame)
vbox.pack_start(align, False, False, 0)
image = gtk.Image()
# use the current directory for the file
try:
pixbuf = gtk.gdk.pixbuf_new_from_file(GTKLOGO_IMAGE)
image.set_from_pixbuf(pixbuf)
except gobject.GError, error:
# This code shows off error handling. You can just use
# gtk_image_new_from_file() instead if you don't want to report
# errors to the user. If the file doesn't load when using
# gtk_image_new_from_file(), a "missing image" icon will
# be displayed instead.
dialog = gtk.MessageDialog(self,
gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_CLOSE,
"Unable to open image file 'gtk-logo-rgb.gif': \n%s" % error)
dialog.connect("response", lambda dlg, resp: dlg.destroy())
dialog.show()
frame.add(image)
# Animation
label = gtk.Label()
label.set_markup("<u>Animation loaded from a file</u>")
vbox.pack_start(label, False, False, 0)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
# The alignment keeps the frame from growing when users resize
# the window
align = gtk.Alignment(0.5, 0.5, 0, 0)
align.add(frame)
vbox.pack_start(align, False, False, 0)
image = gtk.Image()
image.set_from_file(BUDDY_IMAGE);
frame.add(image)
# Progressive
label = gtk.Label()
label.set_markup("<u>Progressive image loading</u>")
vbox.pack_start(label, False, False, 0)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
# The alignment keeps the frame from growing when users resize
# the window
align = gtk.Alignment(0.5, 0.5, 0, 0)
align.add(frame)
vbox.pack_start(align, False, False, 0)
# Create an empty image for now; the progressive loader
# will create the pixbuf and fill it in.
image = gtk.Image()
image.set_from_pixbuf(None)
frame.add(image)
self.start_progressive_loading(image)
# Sensitivity control
button = gtk.ToggleButton("_Insensitive");
vbox.pack_start(button, False, False, 0)
button.connect("toggled", self.on_sensitivity_toggled, vbox)
self.show_all()
def initWidget(self, opt, value):
""" Initialize the option widget.
The widget type is selected automatically based in the option type
and the set/range of valid values. """
type = opt.type
if not self.isValid:
type = "invalid"
if type == "bool":
self.widget = gtk.ToggleButton()
self.widget.set_use_stock(True)
# Make sure the button doesn't change size when toggled
self.widget.set_label("gtk-yes")
wYes = self.widget.size_request()[0]
self.widget.set_label("gtk-no")
wNo = self.widget.size_request()[0]
self.widget.set_size_request(max(wYes, wNo), -1)
if value:
self.widget.set_label("gtk-yes")
else:
self.widget.set_label("gtk-no")
self.widget.set_active(value)
self.widget.connect("toggled", self.activateSignal)
elif type == "int" and opt.valid and len(opt.valid) == 1:
self.widget = SlideSpinner(self.activateSignal, opt.valid[0].start,
opt.valid[0].end, True)
self.widget.setValue(value)
elif type == "float" and opt.valid and len(opt.valid) == 1:
self.widget = SlideSpinner(self.activateSignal, opt.valid[0].start,
opt.valid[0].end, False)
self.widget.setValue(value)
elif type == "enum" or \
(type != "invalid" and opt.valid and
reduce (lambda x,y: x and y, map(dri.Range.empty, opt.valid))):
desc = opt.getDesc([lang])
optValList = []
for r in opt.valid:
if type == "enum":
for v in range(r.start, r.end + 1):
vString = dri.ValueToStr(v, type)
if type == "enum" and desc and desc.enums.has_key(v):
string = desc.enums[v]
else:
string = vString
optValList.append((string, vString))
else:
vString = dri.ValueToStr(r.start, type)
optValList.append((vString, vString))
self.widget = WrappingOptionMenu(optValList,
self.activateSignal,
width=180)
self.widget.setValue(str(value))
else:
self.widget = gtk.Entry()
if type == "invalid":
self.widget.set_text(value)
else:
self.widget.set_text(dri.ValueToStr(value, type))
self.widget.connect("changed", self.activateSignal)
self.highlightInvalid()
self.widget.show()
def realize(self):
self.channel = self.mixer.add_channel(self.channel_name, self.stereo)
if self.channel == None:
raise Exception, "Cannot create a channel"
Channel.realize(self)
if self.future_volume_midi_cc != None:
self.channel.volume_midi_cc = self.future_volume_midi_cc
if self.future_balance_midi_cc != None:
self.channel.balance_midi_cc = self.future_balance_midi_cc
if self.future_mute_midi_cc != None:
self.channel.mute_midi_cc = self.future_mute_midi_cc
if self.future_solo_midi_cc != None:
self.channel.solo_midi_cc = self.future_solo_midi_cc
if self.app._init_solo_channels and self.channel_name in self.app._init_solo_channels:
self.channel.solo = True
self.channel.midi_scale = self.slider_scale.scale
self.on_volume_changed(self.slider_adjustment)
self.on_balance_changed(self.balance_adjustment)
# vbox child at upper part
self.vbox = gtk.VBox()
self.pack_start(self.vbox, False)
self.label_name = gtk.Label()
self.label_name.set_text(self.channel_name)
self.label_name.set_size_request(0, -1)
self.label_name_event_box = gtk.EventBox()
self.label_name_event_box.connect("button-press-event",
self.on_label_mouse)
self.label_name_event_box.add(self.label_name)
self.vbox.pack_start(self.label_name_event_box, True)
# self.label_stereo = gtk.Label()
# if self.stereo:
# self.label_stereo.set_text("stereo")
# else:
# self.label_stereo.set_text("mono")
# self.label_stereo.set_size_request(0, -1)
# self.vbox.pack_start(self.label_stereo, True)
self.hbox_mutesolo = gtk.HBox()
self.mute = gtk.ToggleButton()
self.mute.set_label("M")
self.mute.set_active(self.channel.out_mute)
self.mute.connect("toggled", self.on_mute_toggled)
self.hbox_mutesolo.pack_start(self.mute, True)
self.solo = gtk.ToggleButton()
self.solo.set_label("S")
self.solo.set_active(self.channel.solo)
self.solo.connect("toggled", self.on_solo_toggled)
self.hbox_mutesolo.pack_start(self.solo, True)
self.vbox.pack_start(self.hbox_mutesolo, False)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.abspeak)
self.pack_start(frame, False)
# hbox child at lower part
self.hbox = gtk.HBox()
self.hbox.pack_start(self.slider, True)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.meter)
self.hbox.pack_start(frame, True)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.hbox)
self.pack_start(frame, True)
self.volume_digits.set_size_request(0, -1)
self.pack_start(self.volume_digits, False)
self.create_balance_widget()
self.monitor_button = gtk.ToggleButton('MON')
self.monitor_button.connect('toggled', self.on_monitor_button_toggled)
self.pack_start(self.monitor_button, False, False)
def __init__(self,
command,
stdoutfile,
width=400,
height=400,
standalone=False,
ignore_command=False,
title=None):
self.standalone = standalone
self.command = command
self.ignore_command = ignore_command
self.stdout = stdoutfile
self.stdout_updater = None
self.proc = None
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_border_width(5)
if title is None:
self.window.set_title('Command Output')
else:
self.window.set_title(title)
self.window.connect("delete_event", self.quit)
self.window.set_default_size(width, height)
self.window.set_icon(get_icon())
self.quit_already = False
self.find_current = None
self.find_current_iter = None
self.search_warning_done = False
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.show()
self.textview = gtk.TextView()
self.textview.set_editable(False)
self.textview.set_wrap_mode(gtk.WRAP_WORD)
# Use a monospace font. This is safe - by testing - setting an
# illegal font description has no effect.
self.textview.modify_font(pango.FontDescription("monospace"))
tb = self.textview.get_buffer()
self.textview.show()
self.ftag = tb.create_tag(None, background="#70FFA9")
vbox = gtk.VBox()
vbox.show()
if not self.ignore_command:
self.progress_bar = gtk.ProgressBar()
self.progress_bar.set_text(command)
self.progress_bar.set_pulse_step(0.04)
self.progress_bar.show()
vbox.pack_start(self.progress_bar, expand=False)
self.command_label = gtk.Label(self.command)
if self.ignore_command:
self.command_label.show()
vbox.pack_start(self.command_label, expand=False)
sw.add(self.textview)
frame = gtk.Frame()
frame.add(sw)
frame.show()
vbox.add(frame)
save_button = gtk.Button("Save As")
save_button.connect("clicked", self.save, self.textview)
save_button.show()
hbox = gtk.HBox()
hbox.pack_start(save_button, False)
hbox.show()
output_label = gtk.Label('output : ' + stdoutfile.name)
output_label.show()
hbox.pack_start(output_label, expand=True)
self.freeze_button = gtk.ToggleButton("_Disconnect")
self.freeze_button.set_active(False)
self.freeze_button.connect("toggled", self.freeze)
self.freeze_button.show()
searchbox = gtk.HBox()
searchbox.show()
entry = gtk.Entry()
entry.show()
entry.connect("activate", self.enter_clicked)
searchbox.pack_start(entry, True)
b = gtk.Button("Find Next")
b.connect_object('clicked', self.on_find_clicked, entry)
b.show()
searchbox.pack_start(b, False)
searchbox.pack_start(self.freeze_button, False)
close_button = gtk.Button("_Close")
close_button.connect("clicked", self.quit, None, None)
close_button.show()
hbox.pack_end(close_button, False)
vbox.pack_start(searchbox, False)
vbox.pack_start(hbox, False)
self.window.add(vbox)
close_button.grab_focus()
self.window.show()
def realize(self):
self.channel = self.mixer.add_output_channel(self.channel_name,
self.stereo)
if self.channel == None:
raise Exception, "Cannot create a channel"
Channel.realize(self)
if self.future_volume_midi_cc != None:
self.channel.volume_midi_cc = self.future_volume_midi_cc
if self.future_balance_midi_cc != None:
self.channel.balance_midi_cc = self.future_balance_midi_cc
if self.future_mute_midi_cc != None:
self.channel.mute_midi_cc = self.future_mute_midi_cc
self.channel.midi_scale = self.slider_scale.scale
self.on_volume_changed(self.slider_adjustment)
self.on_balance_changed(self.balance_adjustment)
# vbox child at upper part
self.vbox = gtk.VBox()
self.pack_start(self.vbox, False)
self.label_name = gtk.Label()
self.label_name.set_text(self.channel_name)
self.label_name.set_size_request(0, -1)
self.label_name_event_box = gtk.EventBox()
self.label_name_event_box.connect('button-press-event',
self.on_label_mouse)
self.label_name_event_box.add(self.label_name)
if not self.colours:
OutputChannel.colours = available_colours[:]
for color in self.colours:
self.color_tuple = [
gtk.gdk.color_parse(color[x]) for x in range(3)
]
self.colours.remove(color)
break
self.label_name_event_box.modify_bg(gtk.STATE_NORMAL,
self.color_tuple[1])
self.vbox.pack_start(self.label_name_event_box, True)
self.mute = gtk.ToggleButton()
self.mute.set_label("M")
self.mute.set_active(self.channel.out_mute)
self.mute.connect("toggled", self.on_mute_toggled)
self.vbox.pack_start(self.mute, False)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.abspeak)
self.vbox.pack_start(frame, False)
# hbox child at lower part
self.hbox = gtk.HBox()
self.hbox.pack_start(self.slider, True)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.meter)
self.hbox.pack_start(frame, True)
frame = gtk.Frame()
frame.set_shadow_type(gtk.SHADOW_IN)
frame.add(self.hbox)
self.pack_start(frame, True)
self.volume_digits.set_size_request(0, -1)
self.pack_start(self.volume_digits, False)
self.create_balance_widget()
self.monitor_button = gtk.ToggleButton('MON')
self.monitor_button.connect('toggled', self.on_monitor_button_toggled)
self.pack_start(self.monitor_button, False, False)
# add control groups to the input channels, and initialize them
# appropriately
for input_channel in self.app.channels:
ctlgroup = input_channel.add_control_group(self)
if self._init_muted_channels and input_channel.channel.name in self._init_muted_channels:
ctlgroup.mute.set_active(True)
if self._init_solo_channels and input_channel.channel.name in self._init_solo_channels:
ctlgroup.solo.set_active(True)
self._init_muted_channels = None
self._init_solo_channels = None
def __init__(self, policy, widgets, download_only, select_only=False):
self.policy = policy
self.select_only = select_only
def update_ok_state():
self.window.set_response_sensitive(gtk.RESPONSE_OK,
policy.solver.ready)
if policy.solver.ready and self.window.get_focus() is None:
run_button.grab_focus()
policy.watchers.append(update_ok_state)
self.window = widgets.get_widget('main')
self.window.set_default_size(gtk.gdk.screen_width() * 2 / 5, 300)
self.progress = widgets.get_widget('progress')
self.progress_area = widgets.get_widget('progress_area')
self.comment = widgets.get_widget('comment')
widgets.get_widget('stop').connect(
'clicked', lambda b: policy.handler.abort_all_downloads())
self.refresh_button = widgets.get_widget('refresh')
# Tree view
self.browser = InterfaceBrowser(policy, widgets)
prefs = widgets.get_widget('preferences')
self.window.action_area.set_child_secondary(prefs, True)
# Glade won't let me add this to the template!
if select_only:
run_button = dialog.MixedButton(_("_Select"),
gtk.STOCK_EXECUTE,
button=gtk.ToggleButton())
elif download_only:
run_button = dialog.MixedButton(_("_Download"),
gtk.STOCK_EXECUTE,
button=gtk.ToggleButton())
else:
run_button = dialog.MixedButton(_("_Run"),
gtk.STOCK_EXECUTE,
button=gtk.ToggleButton())
self.window.add_action_widget(run_button, gtk.RESPONSE_OK)
run_button.show_all()
run_button.set_flags(gtk.CAN_DEFAULT)
self.run_button = run_button
run_button.grab_focus()
def response(dialog, resp):
if resp in (gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT):
self.window.destroy()
sys.exit(1)
elif resp == gtk.RESPONSE_OK:
if self.cancel_download_and_run:
self.cancel_download_and_run.trigger()
if run_button.get_active():
self.cancel_download_and_run = tasks.Blocker(
"cancel downloads")
self.download_and_run(run_button,
self.cancel_download_and_run)
elif resp == gtk.RESPONSE_HELP:
gui_help.display()
elif resp == SHOW_PREFERENCES:
import preferences
preferences.show_preferences(
policy.config,
notify_cb=lambda: policy.solve_with_downloads())
self.window.connect('response', response)
self.window.realize() # Make busy pointer work, even with --systray
def __init__(self):
gtk.ToolItem.__init__(self)
preview = ColorPreview()
self.dropdown_button = dropdownpanel.DropdownPanelButton(preview)
self.preview_size = ToolbarManager.icon_size
self.connect("toolbar-reconfigured", self._toolbar_reconf_cb)
self.connect("create-menu-proxy", lambda *a: True)
self.set_tooltip_text(_("Color History and other tools"))
self.add(self.dropdown_button)
from application import get_app
app = get_app()
app.brush.observers.append(self._brush_settings_changed_cb)
preview.color = app.brush_color_manager.get_color()
self._app = app
self._main_preview = preview
panel_frame = gtk.Frame()
panel_frame.set_shadow_type(gtk.SHADOW_OUT)
self.dropdown_button.set_property("panel-widget", panel_frame)
panel_vbox = gtk.VBox()
panel_vbox.set_spacing(widgets.SPACING_TIGHT)
panel_vbox.set_border_width(widgets.SPACING)
panel_frame.add(panel_vbox)
def hide_panel_cb(*a):
self.dropdown_button.panel_hide()
def hide_panel_idle_cb(*a):
gobject.idle_add(self.dropdown_button.panel_hide)
# Colour changing
section_frame = widgets.section_frame(_("Change Color"))
panel_vbox.pack_start(section_frame, True, True)
section_table = gtk.Table()
section_table.set_col_spacings(widgets.SPACING)
section_table.set_border_width(widgets.SPACING)
section_frame.add(section_table)
hsv_widget = HSVTriangle()
hsv_widget.set_size_request(175, 175)
hsv_widget.set_color_manager(app.brush_color_manager)
section_table.attach(hsv_widget, 0, 1, 0, 1)
preview_hbox = gtk.HBox()
color_picker = ColorPickerButton()
preview_adj = PreviousCurrentColorAdjuster()
preview_adj.set_color_manager(app.brush_color_manager)
color_picker.set_color_manager(app.brush_color_manager)
preview_hbox.pack_start(color_picker, False, False)
preview_hbox.pack_start(preview_adj, True, True)
side_vbox = gtk.VBox()
side_vbox.set_spacing(widgets.SPACING_TIGHT)
section_table.attach(side_vbox, 1, 2, 0, 1)
def init_proxy(widget, action_name):
action = app.find_action(action_name)
assert action is not None, \
"Must be able to find action %s" % (action_name,)
widget.set_related_action(action)
widget.connect("clicked", hide_panel_cb)
return widget
button = init_proxy(gtk.Button(), "ColorDetailsDialog")
side_vbox.pack_end(button, False, False)
side_vbox.pack_end(preview_hbox, False, False)
side_vbox.pack_end(gtk.Alignment(), True, True)
button = init_proxy(gtk.ToggleButton(), "HCYWheelTool")
button.set_label(_("HCY Wheel"))
side_vbox.pack_end(button, False, False)
button = init_proxy(gtk.ToggleButton(), "PaletteTool")
button.set_label(_("Color Palette"))
side_vbox.pack_end(button, False, False)
# History
section_frame = widgets.section_frame(_("Recently Used"))
panel_vbox.pack_start(section_frame, True, True)
history = ColorHistoryView(app)
history.button_clicked += self._history_button_clicked
section_frame.add(history)
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(self, name="Active %s"%Spacestring,
ordering=71.1,
tip="Modify active %s."%spacestring)
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
# Microstructure widget, centered at the top of the page.
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
self.mswidget = whowidget.WhoWidget(microstructure.microStructures,
scope=self)
centerbox.pack_start(self.mswidget.gtk[0], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Active area status in the left half of the main pane.
vbox = gtk.VBox()
mainpane.pack1(vbox, resize=1, shrink=0)
aasframe = gtk.Frame("Active %s Status"%Spacestring)
aasframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(aasframe, expand=0, fill=0, padding=2)
self.aainfo = gtk.Label()
gtklogger.setWidgetName(self.aainfo, "Status")
## self.aainfo.set_alignment(0.0, 0.5)
aasframe.add(self.aainfo)
naaframe = gtk.Frame("Named Active %ss"%Spacestring)
naaframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(naaframe, expand=1, fill=1)
naabox = gtk.VBox()
naaframe.add(naabox)
self.aalist = chooser.ScrolledChooserListWidget(
callback=self.aalistCB, dbcallback=self.aalistCB2,
name="NamedAreas")
naabox.pack_start(self.aalist.gtk, expand=1, fill=1, padding=2)
bbox = gtk.HBox()
naabox.pack_start(bbox, expand=0, fill=0, padding=2)
self.storebutton = gtk.Button("Store...")
bbox.pack_start(self.storebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.storebutton, "Store")
gtklogger.connect(self.storebutton, 'clicked', self.storeCB)
tooltips.set_tooltip_text(
self.storebutton,
"Save the current active %s for future use."%spacestring)
self.renamebutton = gtk.Button("Rename...")
bbox.pack_start(self.renamebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.renamebutton, "Rename")
gtklogger.connect(self.renamebutton, 'clicked', self.renameCB)
tooltips.set_tooltip_text(self.renamebutton,
"Rename the selected saved active %s."%spacestring)
self.deletebutton = gtk.Button("Delete")
bbox.pack_start(self.deletebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.deletebutton, "Delete")
gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB)
tooltips.set_tooltip_text(self.deletebutton,
"Delete the selected saved active %s."%spacestring)
self.restorebutton = gtk.Button("Restore")
bbox.pack_start(self.restorebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.restorebutton, "Restore")
gtklogger.connect(self.restorebutton, 'clicked', self.restoreCB)
tooltips.set_tooltip_text(self.restorebutton,
"Use the selected saved active %s."%spacestring)
# Active area modification methods in the right half of the main pane
modframe = gtk.Frame("Active %s Modification"%Spacestring)
gtklogger.setWidgetName(modframe, "Modify")
modframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(modframe, resize=0, shrink=0)
modbox = gtk.VBox()
modframe.add(modbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## modbox.pack_start(scroll, expand=1, fill=1)
self.activeareaModFactory = regclassfactory.RegisteredClassFactory(
activeareamod.ActiveAreaModifier.registry, title="Method:",
scope=self, name="Method")
## scroll.add_with_viewport(self.activeareaModFactory.gtk)
modbox.pack_start(self.activeareaModFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.activeareaModFactory.set,
self.sensitizeHistory,
setCBkwargs={'interactive':1})
self.activeareaModFactory.set_callback(self.historian.stateChangeCB)
# Prev, OK, and Next buttons
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevbutton = gtkutils.prevButton()
hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.prevbutton, 'clicked', self.historian.prevCB)
tooltips.set_tooltip_text(
self.prevbutton,
'Recall the previous active %s modification operation.'%spacestring)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=2)
gtklogger.setWidgetName(self.okbutton, "OK")
gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB)
tooltips.set_tooltip_text(
self.okbutton,
'Perform the active %s modification operation defined above.'
%spacestring)
self.nextbutton = gtkutils.nextButton()
hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.nextbutton, 'clicked', self.historian.nextCB)
tooltips.set_tooltip_text(
self.nextbutton,
"Recall the next active %s modification operation."%spacestring)
# Undo, Redo, Override
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
hbox.pack_start(self.undobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
tooltips.set_tooltip_text(self.undobutton,
"Undo the previous operation.")
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.redobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.redobutton, "Redo an undone operation.")
self.overridebutton = gtk.ToggleButton('Override')
hbox.pack_start(self.overridebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.overridebutton, "Override")
self.overridesignal = gtklogger.connect(self.overridebutton,
'clicked', self.overrideCB)
tooltips.set_tooltip_text(self.overridebutton,
"Temporarily activate the entire microstructure.")
# Switchboard signals
self.sbcallbacks = [
switchboard.requestCallback(self.mswidget,
self.mswidgetCB),
switchboard.requestCallback("active area modified",
self.aamodified),
switchboard.requestCallbackMain("stored active areas changed",
self.storedAAChanged),
switchboard.requestCallbackMain(('validity',
self.activeareaModFactory),
self.validityChangeCB)
]
self.built = True
def __init__(self):
gtk.ToolItem.__init__(self)
self.set_homogeneous(False)
self.button_image = gtk.Image()
self.button_image.set_from_stock(self.inactive_stock_id,
ToolbarManager.icon_size)
self.button_shows_modified = False
self.button = dropdownpanel.DropdownPanelButton(self.button_image)
self.vbox = gtk.VBox()
frame = gtk.Frame()
frame.add(self.vbox)
frame.set_shadow_type(gtk.SHADOW_OUT)
self.button.set_property("panel-widget", frame)
self.add(self.button)
self.connect("create-menu-proxy", lambda *a: True)
from application import get_app
app = get_app()
self.app = app
# A limited subset of the available brush settings.
frame = widgets.section_frame(_("Quick Brush Settings"))
table = gtk.Table()
table.set_homogeneous(False)
table.set_row_spacings(widgets.SPACING_TIGHT)
table.set_col_spacings(widgets.SPACING)
table.set_border_width(widgets.SPACING)
frame.add(table)
self.vbox.pack_start(frame, True, True)
sg_row_height = gtk.SizeGroup(gtk.SIZE_GROUP_VERTICAL)
sg_slider_width = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
row = 0
for setting_cname in self.setting_cnames:
scale = gtk.HScale()
scale.set_size_request(128, -1)
scale.set_draw_value(False)
scale.set_can_focus(False)
scale.set_can_default(False)
s = brushsettings.settings_dict[setting_cname]
adj = app.brush_adjustment[setting_cname]
scale.set_adjustment(adj)
scale.set_tooltip_text(s.tooltip)
#scale.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
sg_row_height.add_widget(scale)
sg_slider_width.add_widget(scale)
label = gtk.Label(_("%s:") % s.name)
label.set_alignment(0.0, 0.5)
label.set_tooltip_text(s.tooltip)
sg_row_height.add_widget(label)
reset_button = widgets.borderless_button(
stock_id=gtk.STOCK_CLEAR,
tooltip=_("Restore '%s' to this brush's saved value") % s.name)
reset_button.connect("clicked", self.reset_button_clicked_cb, adj,
setting_cname)
sg_row_height.add_widget(reset_button)
adj.connect("value-changed", self.adjustment_changed_cb,
reset_button, setting_cname)
adj.value_changed()
table.attach(label, 0, 1, row, row + 1, gtk.FILL)
table.attach(scale, 1, 2, row, row + 1, gtk.FILL | gtk.EXPAND)
table.attach(reset_button, 2, 3, row, row + 1, gtk.FILL)
row += 1
table.set_col_spacing(1, widgets.SPACING_TIGHT)
# Access to the brush settings window, and a big reset-all button
# aligned with the settings above.
frame = widgets.section_frame(_("Detailed Brush Settings"))
hbox = gtk.HBox()
hbox.set_spacing(widgets.SPACING)
hbox.set_border_width(widgets.SPACING)
frame.add(hbox)
self.vbox.pack_start(frame, True, True)
widget = gtk.ToggleButton()
action = self.app.find_action("BrushEditorWindow")
widget.set_related_action(action)
#widget.set_label(_("Edit All Settings"))
hbox.pack_start(widget, True, True)
widget.connect("toggled", lambda a: self.button.panel_hide())
sg_slider_width.add_widget(widget)
widget = gtk.ToggleButton()
action = self.app.find_action("BrushIconEditorWindow")
widget.set_related_action(action)
#widget.set_label(_("Edit Icon"))
hbox.pack_start(widget, True, True)
widget.connect("toggled", lambda a: self.button.panel_hide())
sg_slider_width.add_widget(widget)
widget = gtk.Button(_("Restore Saved Settings"))
widget.connect("clicked", self.reset_all_clicked_cb)
widget.set_tooltip_text(
_("Reset all brush settings to the current brush's saved values"))
hbox.pack_start(widget, True, True)
sg_slider_width.add_widget(widget)
self.reset_all_button = widget
# Brush blend modes
vbox = gtk.VBox()
vbox.set_border_width(widgets.SPACING)
vbox.set_spacing(widgets.SPACING_TIGHT)
frame = widgets.section_frame(_("Brush Blend Mode"))
frame.add(vbox)
self.vbox.pack_start(frame, True, True)
table = gtk.Table(2, 2, homogeneous=True)
topts = gtk.EXPAND | gtk.FILL
tpad = 0
table.set_row_spacings(widgets.SPACING_TIGHT)
table.set_col_spacings(widgets.SPACING)
for la, ra, ta, ba, action_name in self.blend_modes_table:
action = self.app.find_action(action_name)
button = gtk.ToggleButton()
button.set_related_action(action)
button.set_can_focus(False)
button.set_can_default(False)
button.set_image_position(gtk.POS_LEFT)
button.set_alignment(0.0, 0.5)
button.set_relief(gtk.RELIEF_HALF)
image = action.create_icon(gtk.ICON_SIZE_BUTTON)
image.set_padding(widgets.SPACING_TIGHT, widgets.SPACING_TIGHT)
button.set_image(image)
table.attach(button, la, ra, ta, ba, topts, topts, tpad, tpad)
button.connect("clicked", self.blendmode_button_clicked_cb)
vbox.pack_start(table, False, False)
self.vbox.set_border_width(widgets.SPACING)
self.vbox.set_spacing(widgets.SPACING)
self.app.brush.observers.append(self.brush_settings_changed_cb)
