def _create_advanced_search(self):
self.label_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.combo_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
add = SearchFilterButton(label=_('Filter'), stock=gtk.STOCK_ADD)
add.connect('clicked', self._on_add_field_clicked)
add.show()
self.hbox.pack_end(add, False, False, 0)
self.add_filter_button = add
self.menu = gtk.Menu()
for column in self._columns:
if not isinstance(column, SearchColumn):
continue
if column.data_type not in (datetime.date, Decimal, int, currency,
str):
continue
title = column.long_title or column.title
menu_item = gtk.MenuItem(title)
menu_item.set_data('column', column)
menu_item.show()
menu_item.connect('activate', self._on_menu_item_activate)
self.menu.append(menu_item)
if not len(self.menu):
self.add_filter_button.hide()
def __init_page(self):
box = gtk.VBox()
self.__page = box
s1 = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
s2 = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.__name_label = gtk.Label()
box.pack_start(self.__name_label, expand=False)
self.__name_label.set_alignment(0, 0.5)
box2 = gtk.HBox(spacing=6)
box.pack_start(box2, expand=False, padding=6)
lb_command = gtk.Label()
box2.pack_start(lb_command, expand=False)
lb_command.set_markup(DEF_MU % 'Command Line')
s1.add_widget(lb_command)
lb_command.set_alignment(0, 0.5)
self.__command_entry = gtk.Entry()
box2.pack_start(self.__command_entry)
s2.add_widget(self.__command_entry)
box2 = gtk.HBox(spacing=6)
box.pack_start(box2, expand=False, padding=6)
lb_glob = gtk.Label()
box2.pack_start(lb_glob, expand=False)
lb_glob.set_markup(DEF_MU % 'Glob')
s1.add_widget(lb_glob)
lb_glob.set_alignment(0, 0.5)
self.__glob_entry = gtk.Entry()
box2.pack_start(self.__glob_entry)
s2.add_widget(self.__glob_entry)
return box
def setup_layout (self):
"""
Setup the layout of the dialog.
Create size groups for ensuring widgets have the same horizontal size.
"""
self.vbox.set_spacing (6)
self.left_group = gtk.SizeGroup (gtk.SIZE_GROUP_HORIZONTAL)
self.right_group = gtk.SizeGroup (gtk.SIZE_GROUP_HORIZONTAL)
def _setSizeGroup(self): # too bad we can't do this in the glade file
sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
for w in ("nameLabel", "descriptionLabel", "baseurlRadio",
"mirrorRadio", "advancedLabel"):
sg.add_widget(self.xml.get_widget(w))
sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
for w in ("nameEntry", "descriptionEntry", "baseurlEntry",
"mirrorEntry", "nameEntryLabel"):
sg.add_widget(self.xml.get_widget(w))
def create_bug_view(self, bug_id):
"""Creates a view for individual bug"""
bug = self.crawler.get_bug(bug_id)
dialog = gtk.Dialog(_("Reporting a bug"), self.window, 0,
(gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL,
gtk.RESPONSE_CANCEL))
sizegroup1 = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
sizegroup2 = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
# building bug view id
field_pairs = {
"bug_id": {
"text": ("Bugzilla id"),
"value_widget": None,
},
"creation_ts": {
"text": _("Date reported"),
"value_widget": None,
},
"product": {
"text": ("Product"),
"value_widget": None,
},
"version": {
"text": ("Version"),
"value_widget": None,
},
"resolution": {
"text": ("Resolution"),
"value_widget": None,
},
"reporter": {
"text": ("Reporter"),
"value_widget": None,
},
"assigned_to": {
"text": ("Assigned to"),
"value_widget": None,
},
}
for field in field_pairs:
hbox, value_widget = self.build_value_pair(
sizegroup1,
field_pairs[field]["text"],
bug[field],
value_sizegroup=sizegroup2,
editable=False)
dialog.vbox.pack_start(hbox, False, False, 2)
field_pairs[field]["value_widget"] = value_widget
dialog.vbox.show_all()
ret = dialog.run()
dialog.destroy()
def __build_datawidgets(self, page):
self.__datawidgets = {}
size = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
lsize = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
#size.set_orientation(gtk.SIZE_GROUP_HORIZONTAL)
for name, rtype, default, doc in self.__schema:
option = rtype(name, doc, default)
widget_type = registrywidgets.get_widget(rtype)
widget = widget_type(option)
page.pack_start(widget.win, expand=False)
size.add_widget(widget.widget)
lsize.add_widget(widget.name_l)
self.__datawidgets[name] = widget
def add_page(self, group, title, stock_id, description, attrs):
holder = gtk.ScrolledWindow()
holder.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
page = gtk.VBox()
page.set_border_width(12)
holder.add_with_viewport(page)
page.pack_start(self.create_title_label(title, description, stock_id),
expand=False)
lsizer = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
vsizer = gtk.SizeGroup(gtk.SIZE_GROUP_VERTICAL)
self._pages[tuple(attrs)] = page, lsizer, vsizer
self._nb.append_page(holder,
tab_label=self.create_tab_label(title, stock_id))
def __init__(self, exname, num, labeltext):
gtk.VBox.__init__(self)
#cfg.ConfigUtils.__init__(self, exname)
cfg.ConfigUtils.__dict__['__init__'](self, exname)
assert num in (2, 3)
self.m_num = num
self.g_override_default_instrument_checkbutton \
= gu.nCheckButton(exname, 'override_default_instrument',
labeltext,
callback=self.update_instrument_override)
self.pack_start(self.g_override_default_instrument_checkbutton,
False)
hbox = gu.bVBox(self)
hbox.set_spacing(gu.PAD_SMALL)
sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.g_instrsel_high = FramedInstrumentSelector(_("Highest:"), exname, 'highest_instrument',sizegroup)
hbox.pack_start(self.g_instrsel_high, False)
if num == 3:
self.g_instrsel_middle = FramedInstrumentSelector(_("Middle:"),
exname, 'middle_instrument', sizegroup)
hbox.pack_start(self.g_instrsel_middle, False)
else:
self.g_instrsel_middle = None
self.g_instrsel_low = FramedInstrumentSelector(_("Lowest:"),
exname, 'lowest_instrument', sizegroup)
hbox.pack_start(self.g_instrsel_low, False)
self.update_instrument_override()
def __init__(self, glade_file_name, title, name_validator_func,
name='', hours=0, minutes=0, seconds=0, command='',
next_timer='', auto_start=False):
self._valid_name_func = name_validator_func
glade_widgets = glade.XML(glade_file_name, 'add_edit_preset_dialog')
self._dialog = glade_widgets.get_widget('add_edit_preset_dialog')
self._ok_button = glade_widgets.get_widget('ok_button')
self._cancel_button = glade_widgets.get_widget('cancel_button')
self._name_entry = glade_widgets.get_widget('name_entry')
duration_chooser_container = glade_widgets.get_widget('duration_chooser_container')
self._duration_chooser = DurationChooser(gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL))
self._command_entry = glade_widgets.get_widget('command_entry')
self._next_timer_entry = glade_widgets.get_widget('next_timer_entry')
self._auto_start_check = glade_widgets.get_widget('auto_start_check')
duration_chooser_container.pack_start(self._duration_chooser)
self._dialog.set_title(title)
self._dialog.set_default_response(gtk.RESPONSE_OK)
self._name_entry.set_text(name)
self._command_entry.set_text(command)
self._duration_chooser.set_duration(hours, minutes, seconds)
self._next_timer_entry.set_text(next_timer)
self._auto_start_check.set_active(auto_start)
self._name_entry.connect('changed', lambda entry: self._check_for_valid_save_preset_input())
self._duration_chooser.connect('duration-changed',
lambda chooser: self._check_for_valid_save_preset_input())
self._duration_chooser.show()
def login(self):
dialog = gtk.Dialog('Kobita Login', self,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL,
gtk.STOCK_OK, gtk.RESPONSE_OK))
sgroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
hbox = gtk.HBox(False, 5)
label = gtk.Label("User")
sgroup.add_widget(label)
hbox.add(label)
user = gtk.Entry()
hbox.add(user)
dialog.vbox.add(hbox)
label = gtk.Label("Password")
sgroup.add_widget(label)
hbox = gtk.HBox(False, 5)
hbox.add(label)
password = gtk.Entry()
password.set_visibility(False)
hbox.add(password)
dialog.vbox.add(hbox)
dialog.show_all()
try:
if dialog.run() == gtk.RESPONSE_OK:
return {
'url_name': user.get_text(),
'password': password.get_text()
}
finally:
dialog.destroy()
return None
class TimelineView():
size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
first_unread = None
def __init__(self):
self.notice_boxes = []
self.notices = self.fetch_notices()
self.box = self.create_timeline()
if self.first_unread is None:
if len(self.notice_boxes) > 0:
self.first_unread = self.notice_boxes[-1].box
else:
self.first_unread = self.box
def create_timeline(self):
vbox = gtk.VBox(False, 0)
found = False
previous = None
for notice in self.notices:
notice_box = NoticeBox(notice=notice,
parent=self,
previous=previous,
size_group=self.size_group)
vbox.pack_start(notice_box.box, False, False, 0)
previous = notice_box
self.notice_boxes.append(notice_box)
if not found and notice.read == False:
self.first_unread = notice_box.box
found = True
if len(self.notices) == 0:
label = gtk.Label("No new notices.")
vbox.pack_start(label)
return vbox
def fetch_notices(self):
loader = NoticeLoader()
return loader.notices
def find_first_unread(self):
for notice_box in self.notice_boxes:
if not notice_box.notice.read:
self.first_unread = notice_box.box
break
return None
def remove_read_notices(self):
for notice_box in self.notice_boxes:
if notice_box.notice.read and not notice_box.notice.highlighted:
notice_box.box.destroy()
self.notice_boxes[:] = [nb for nb in self.notice_boxes
if not nb.notice.read
or notice_box.notice.highlighted]
def __create_frame(self, title):
''' This function is used both for creating the "Display" and
"Screen" frames, since they have a similar structure. The
caller hooks up the right context for the value returned
in tree_view, and packs any relevant buttons into button_vbox.
'''
frame = gtk.Frame(title)
hbox = gtk.HBox(False, 8)
hbox.set_border_width(8)
frame.add(hbox)
scrollwin = gtk.ScrolledWindow()
scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrollwin.set_shadow_type(gtk.SHADOW_IN)
hbox.pack_start(scrollwin, True, True, 0)
tree_view = gtk.TreeView()
tree_view.set_headers_visible(False)
scrollwin.add(tree_view)
selection = tree_view.get_selection()
selection.set_mode(gtk.SELECTION_BROWSE)
button_vbox = gtk.VBox(False, 5)
hbox.pack_start(button_vbox, False, False, 0)
if self.size_group is None:
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.size_group.add_widget(button_vbox)
return (frame, tree_view, button_vbox)
def addZfcpDrive(anaconda):
(dxml, dialog) = gui.getGladeWidget("zfcp-config.glade", "zfcpDialog")
gui.addFrame(dialog)
dialog.show_all()
sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
for w in ["devnumEntry", "wwpnEntry", "fcplunEntry"]:
sg.add_widget(dxml.get_widget(w))
while True:
dialog.present()
rc = dialog.run()
if rc != gtk.RESPONSE_APPLY:
break
devnum = dxml.get_widget("devnumEntry").get_text().strip()
wwpn = dxml.get_widget("wwpnEntry").get_text().strip()
fcplun = dxml.get_widget("fcplunEntry").get_text().strip()
try:
anaconda.id.storage.zfcp.addFCP(devnum, wwpn, fcplun)
except ValueError as e:
anaconda.intf.messageWindow(_("Error"), str(e))
continue
break
dialog.destroy()
return rc
def __init__(self, source, messages_file, settings_file):
self._source = source
self._messages_file = messages_file
self._fms_control = wasp.fms.ControlManager(source, messages_file, settings_file)
#build the UI
self.widget = gtk.VBox()
self._control_widget = gtk.VBox(spacing=5)
self.widget.pack_start(self._control_widget, True, True)
self.widget.pack_start(gtk.HSeparator(), False, False)
self._status_widget = gtk.Label("")
self._status_widget.props.xalign = 0.0
self._status_widget.props.xpad = 5
self.widget.pack_start(self._status_widget, False, True)
gobject.timeout_add(1000/10, self._refresh_label)
#FMS mode
hb = gtk.HBox()
lbl = _make_left_fancy_label("<b>FMS Mode: </b>")
hb.pack_start(lbl, False, False)
self._fms_mode_label = _make_left_fancy_label("", False, 0)
hb.pack_start(self._fms_mode_label, True, True)
self.widget.pack_start(hb, False, True)
#each axis gets a widget that manages its value and enabled state
sg = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self._axis_id_widget_map = {}
for _id in wasp.fms.ID_LIST_FMS_ATTITUDE:
widget = _FMSAxisWidget(sg, wasp.fms.ID_NAMES[_id], _id, self._fms_axis_enable_toggled)
self.widget.pack_start(widget, False, True)
self._axis_id_widget_map[_id] = widget
def toggle_drag_begin(self, toggle, context):
toggle.set_active(False)
#Literally drag the toggle around!
#(Since Gtk 2.14)
try:
toggle.drag_source_set_icon(toggle.get_screen().get_rgba_colormap(), \
toggle.parent.get_snapshot(), None)
except:
pass
if len(self.toggles) > 1:
for other_toggle in self.toggles:
if other_toggle != toggle:
break
toggle.hide()
toggle.web.hide()
toggle.placeholder = classes.PlaceHolder()
toggle.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_BOTH)
toggle.size_group.add_widget(other_toggle.parent)
toggle.size_group.add_widget(toggle.placeholder)
toggle.parent.pack_start(toggle.placeholder)
toggle.placeholder.show()
self.dragged_toggle = toggle
def setup(self):
self.pattern.data_type = int
self.framerate.data_type = float
patterns = [('SMPTE Color bars', 0, 'pattern_smpte.png'),
('Random (television snow)', 1, 'pattern_snow.png'),
('100% Black', 2, 'pattern_black.png'),
('Blink', 12, 'pattern_blink.png')]
self.pattern_icons = dict()
for description, number, image in patterns:
self.pattern.append_item(_(description), number)
if image:
self.pattern_icons[number] = os.path.join(
configure.imagedir, 'wizard', image)
self.pattern.connect('changed', self._change_image)
self.add_proxy(self.model.properties,
['pattern', 'width', 'height', 'framerate'])
sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
sizegroup.add_widget(self.width)
sizegroup.add_widget(self.height)
sizegroup.add_widget(self.framerate)
def align_labels(glade, names):
"""Add the list of widgets identified by names in glade to a horizontal
sizegroup."""
group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
widget = [
group.add_widget(get_widget_checked(glade, name)) for name in names
]
def __init__(self, parent, error_text):
gtk.Dialog.__init__(self, _("Make bug report"), parent,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT))
self.m_error_text = error_text
self.add_button(_("_Send"), RESPONSE_SEND)
self.set_default_size(400, 400)
sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
l = gtk.Label(_("Information about the version of GNU Solfege, your operating system and Python version, and the Python traceback (error message) will be sent to the crash database. Your email will not be published or shared, but we might contact you by email if we have further questions about your crash report."))
l.set_line_wrap(True)
l.show()
self.vbox.pack_start(l, False)
self.g_email = gtk.Entry()
self.vbox.pack_start(
gu.hig_label_widget(_("_Email:"), self.g_email, sizegroup),
False)
self.g_email.set_text(cfg.get_string('user/email'))
# 140 is max in the solfege.org database
self.g_description = gtk.Entry(max=140)
self.vbox.pack_start(
gu.hig_label_widget(_("S_hort description:"), self.g_description,
sizegroup), False)
label = gtk.Label(_("_Describe how to produce the error message:"))
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
self.vbox.pack_start(label, False)
self.g_tw = gtk.TextView()
self.g_tw.set_wrap_mode(gtk.WRAP_WORD)
self.g_tw.set_border_width(10)
label.set_mnemonic_widget(self.g_tw)
self.vbox.pack_start(self.g_tw)
self.show_all()
def __init__(self, *args, **kwargs):
gtk.Dialog.__init__(self, *args, **kwargs)
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
self.controls = {}
for ID in [S_A, S_X, S_Y, S_SP, S_PC]:
self.add_line(ID)
def update_select_elements_buttons(self):
"""
(Re)create the checkbuttons used to select which rhythm elements
to be used when creating questions. We only need to do this if
we are in m_custom_mode.
"""
for but in self.soltogglebuttons:
but.destroy()
self.soltogglebuttons = []
gs = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
for i, v in enumerate((
[1, 4, -1, 8, 11, -1, 15, 18, 21, -1, 25, 28, -1, 32],
[0, 3, 6, 7, 10, 13, 14, 17, 20, 23, 24, 27, 30, 31, 34],
[2, 5, -1, 9, 12, -1, 16, 19, 22, -1, 26, 29, -1, 33])):
hbox = gtk.HBox(True, 0)
for k in v:
b = self.soltogglebutton(k)
gs.add_widget(b)
for n in self.m_t.m_P.header.solmisation_elements:
if k == n:
b.set_active(True)
hbox.pack_start(b, False)
self.soltogglebuttons.append(b)
spacing = gtk.Alignment()
if i in (0, 2):
spacing.set_property('left-padding', 16)
spacing.add(hbox)
self.g_select_rhythms_box.pack_start(spacing)
spacing.show_all()
def createWidgets(self):
self.transactionWidgets = {}
self.pipes = {}
self.scroll = ScrollContainer()
self.scroll.hAdjust[0].set_property("step-increment", 20)
self.cursor = Types.Observable(-1)
# The ruler at the top is in charge of our time scale
self.ruler = Ruler()
TimeCursor(self.ruler, self.ruler, self.cursor)
self.ruler.canvas.set_hadjustment(self.scroll.hAdjust[0])
# The top heading holds the ruler, and a spacer aligned with the left heading
leftHeadingWidth = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
spacer = gtk.Label()
leftHeadingWidth.add_widget(spacer)
topHeading = gtk.HBox(False)
topHeading.pack_start(spacer, False, padding=self.labelPadding)
topHeading.pack_start(gtk.VSeparator(), False)
topHeading.pack_start(self.ruler.canvas, True)
# Everything except the top heading scrolls vertically using a viewport
viewport = gtk.Viewport(None, self.scroll.vAdjust[0])
viewport.set_shadow_type(gtk.SHADOW_NONE)
viewport.set_size_request(1, 1)
viewportBox = gtk.VBox(False)
viewportBox.pack_start(topHeading, False)
viewportBox.pack_start(gtk.HSeparator(), False)
viewportBox.pack_start(viewport, True)
self.scroll.add(viewportBox)
# Gnome Canvas has really silly event grabbing semantics. To work around
# all this, we'll just grab all events before gnome-canvas sees them.
for widget in (viewport, self.ruler.canvas):
widget.add_events(gtk.gdk.POINTER_MOTION_HINT_MASK
| gtk.gdk.POINTER_MOTION_MASK
| gtk.gdk.BUTTON_PRESS_MASK)
for event in ('motion-notify-event', 'button-press-event',
'scroll-event'):
widget.connect_after(event, self.mouseEvent)
self.scroll.attachEvent(widget, horizontal=True)
# The left heading holds labels for each canvas in the stack
self.leftHeading = gtk.VBox(False)
leftHeadingWidth.add_widget(self.leftHeading)
# The viewport holds the left heading, then the main canvas stack
scrolledBox = gtk.HBox(False)
self.canvasList = []
self.canvasStack = gtk.VBox(False)
scrolledBox.pack_start(self.leftHeading,
False,
padding=self.labelPadding)
scrolledBox.pack_start(gtk.VSeparator(), False)
scrolledBox.pack_start(self.canvasStack, True)
viewport.add(scrolledBox)
return self.scroll
def _newline_show_widgets(self):
sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
hbox = bHBox(self, True)
for n in self.m_todo_widgets:
if n == 'newline':
hbox = bHBox(self, False)
else:
hbox.pack_start(n, False)
sizegroup.add_widget(n)
def __init__(self):
"""
Retorna: un nuevo 'Menu'.
Crea un nuevo 'Menu'.
"""
gtk.Menu.__init__(self)
self.__size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
def init(self):
self.widget.set_border_width(6)
title = gtk.Label()
self.widget.pack_start(title, expand=False, padding=6)
title.set_markup('<big><b>Create new project</b></big>')
title.set_alignment(0, 0.5)
lsz = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
wsz = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
hb = gtk.HBox()
self.widget.pack_start(hb, expand=False, padding=3)
name_label = gtk.Label('Name')
hb.pack_start(name_label, expand=False, padding=3)
lsz.add_widget(name_label)
name_label.set_alignment(0, 0.5)
self.__name_entry = gtk.Entry()
hb.pack_start(self.__name_entry)
wsz.add_widget(self.__name_entry)
hb = gtk.HBox()
self.widget.pack_start(hb, expand=False, padding=3)
file_label = gtk.Label('Save in')
hb.pack_start(file_label, expand=False, padding=3)
lsz.add_widget(file_label)
file_label.set_alignment(0, 0.5)
self.__file_chooser = filedialogs.FolderButton()
hb.pack_start(self.__file_chooser)
wsz.add_widget(self.__file_chooser)
#self.__file_chooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
hb = gtk.HBox()
self.widget.pack_start(hb, expand=False, padding=3)
type_label = gtk.Label('Type')
hb.pack_start(type_label, expand=False, padding=3)
lsz.add_widget(type_label)
type_label.set_alignment(0, 0.5)
self.__type_combo = gtk.combo_box_new_text()
hb.pack_start(self.__type_combo)
wsz.add_widget(self.__type_combo)
bb = gtk.HButtonBox()
self.widget.pack_start(bb, expand=False)
self.__ok_but = gtk.Button(stock=gtk.STOCK_OK)
bb.pack_start(self.__ok_but, padding=6)
self.__ok_but.connect('clicked', self.on_ok_button__clicked)
self.__cancel_but = gtk.Button(stock=gtk.STOCK_CANCEL)
bb.pack_start(self.__cancel_but, padding=6)
self.__cancel_but.connect('clicked', self.on_cancel_button__clicked)
def __init__(self, glade_file_name, name_validator_func, presets_store, preset_display_func):
gobject.GObject.__init__(self)
self._valid_name_func = name_validator_func;
self._presets_store = presets_store
self._preset_display_func = preset_display_func
self._presets_list = ScrollableButtonList()
labels_size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self._duration_chooser = DurationChooser(labels_size_group)
glade_widgets = glade.XML(glade_file_name, 'start_timer_dialog')
self._dialog = glade_widgets.get_widget('start_timer_dialog')
self._ok_button = glade_widgets.get_widget('ok_button')
name_label = glade_widgets.get_widget('name_label')
self._name_entry = glade_widgets.get_widget('name_entry')
self._save_button = glade_widgets.get_widget('save_button')
duration_chooser_container = glade_widgets.get_widget('duration_chooser_container')
presets_chooser_container = glade_widgets.get_widget('presets_chooser_container')
self._presets_section = glade_widgets.get_widget('presets_section')
#: The TextEntry control for running a custom command
self._command_entry = glade_widgets.get_widget('command_entry')
#: The "Invalid Command" label
self._invalid_cmd_label = glade_widgets.get_widget('invalid_command_label')
#: The next timer combo box
self._next_timer_combo = glade_widgets.get_widget('next_timer_combo_entry')
self._next_timer_combo.set_model(self._presets_store)
self._next_timer_combo.set_text_column(0) # The column to be shown
#: The auto-start check button.
self._auto_start_check = glade_widgets.get_widget('auto_start_check')
labels_size_group.add_widget(name_label)
self._dialog.set_default_response(gtk.RESPONSE_OK)
duration_chooser_container.pack_start(self._duration_chooser)
presets_chooser_container.pack_start(self._presets_list)
self._dialog.connect('response', self._on_dialog_response)
self._dialog.connect('delete-event', self._dialog.hide_on_delete)
self._dialog.add_events(gdk.BUTTON_PRESS_MASK)
self._duration_chooser.connect('duration-changed', self._on_duration_changed)
self._name_entry.connect('changed', self._on_name_entry_changed)
self._save_button.connect('clicked', self._on_save_button_clicked)
# Check that executable is valid while inserting text
self._command_entry.connect('changed', self._check_is_valid_command)
self._next_timer_combo.child.connect("changed",
self._on_next_timer_combo_entry_child_changed)
glade_widgets.get_widget('manage_presets_button').connect('clicked',
self._on_manage_presets_button_clicked)
self._presets_store.connect('row-deleted',
lambda model, row_path: self._update_presets_list())
self._presets_store.connect('row-changed',
lambda model, row_path, row_iter: self._update_presets_list())
self._update_presets_list()
self._duration_chooser.show()
self._presets_list.show()
def setup_slaves(self):
self.password_slave = PasswordEditorSlave(self.store,
self.model,
visual_mode=self.visual_mode)
self.attach_slave('password_holder', self.password_slave)
self._sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self._sizegroup.add_widget(self.current_password_lbl)
self._sizegroup.add_widget(self.password_slave.password_lbl)
self._sizegroup.add_widget(self.password_slave.confirm_password_lbl)
def setup_layout(self):
"""
Setup the introduction layout and create a size group to ensure
widgets have the same horizontal size.
"""
self.set_border_width(16)
self.vbox = gtk.VBox(homogeneous=True)
self.vbox.show()
self.add(self.vbox)
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
def enable_advanced_search(self):
"""
Enables an advanced search
"""
self.label_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.combo_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.menu = gtk.Menu()
for column in self.columns:
if not isinstance(column, SearchColumn):
continue
if column.data_type not in (datetime.date, decimal.Decimal, int,
currency, str, bool):
continue
attr = column.search_attribute or column.attribute
self.add_filter_option(attr, column.get_search_label(),
column.data_type, column.valid_values,
column.search_func, column.use_having)
def __init__(self, parent=None):
gtk.Dialog.__init__(self, "Size Groups", parent,
0,
(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE))
try:
self.set_screen(parent.get_screen())
except AttributeError:
self.connect('destroy', lambda *w: gtk.main_quit())
self.connect('response', lambda d, r: d.destroy())
self.set_resizable(False)
vbox = gtk.VBox(False, 5)
self.vbox.pack_start(vbox, True, True, 0)
vbox.set_border_width(5)
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
# Create one frame holding color options
frame = gtk.Frame("Color options")
vbox.pack_start(frame, True, True, 0)
table = gtk.Table(2, 2, False)
table.set_border_width(5)
table.set_row_spacings(5)
table.set_col_spacings(10)
frame.add(table)
color_options = ("Red", "Green", "Blue")
self.__add_row(table, 0, "_Foreground", color_options)
self.__add_row(table, 1, "_Background", color_options)
# And another frame holding line style options
frame = gtk.Frame("Line options")
vbox.pack_start(frame, False, False, 0)
table = gtk.Table(2, 2, False)
table.set_border_width(5)
table.set_row_spacings(5)
table.set_col_spacings(10)
frame.add(table)
dash_options = ("Solid", "Dashed", "Dotted")
end_options = ("Square", "Round", "Arrow")
self.__add_row(table, 0, "_Dashing", dash_options)
self.__add_row(table, 1, "_Line ends", end_options)
# And a check button to turn grouping on and off
check_button = gtk.CheckButton("_Enable grouping")
vbox.pack_start(check_button, False, False, 0)
check_button.set_active(True)
check_button.connect('toggled', self.on_toggle_grouping)
self.show_all()
def _attach_slaves(self):
self.password_slave = PasswordEditorSlave(self.store)
self.attach_slave('password_holder', self.password_slave)
self._sizegroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self._sizegroup.add_widget(self.username_lbl)
self._sizegroup.add_widget(self.role_lbl)
self._sizegroup.add_widget(self.profile)
self._sizegroup.add_widget(self.role)
self._sizegroup.add_widget(self.password_slave.password_lbl)
self._sizegroup.add_widget(self.password_slave.confirm_password_lbl)
