def test_scale(self):
import gtk
adjustment = gtk.Adjustment()
assert gtk.HScale()
assert gtk.HScale(adjustment).get_adjustment() == adjustment
adjustment = gtk.Adjustment()
assert gtk.VScale()
assert gtk.VScale(adjustment).get_adjustment() == adjustment
def init_slider(self):
""" Initialize volume scale """
if self.orientation == gtk.ORIENTATION_VERTICAL:
self.slider = gtk.HScale()
else:
self.slider = gtk.VScale()
self.align = gtk.Alignment()
self.slider.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.slider.set_draw_value(self.main.scale_show_value)
self.slider.set_digits(0)
self.slider.set_range(0, 100)
self.slider.set_increments(self.main.scale_increment, 10)
self.slider.add_events(gtk.gdk.SCROLL_MASK)
if isinstance(self.slider, gtk.VScale):
self.align.set_padding(10, 10, 4, 4)
self.slider.set_size_request(-1, 128)
self.slider.set_value_pos(gtk.POS_BOTTOM)
self.slider.set_inverted(True)
else:
self.align.set_padding(4, 4, 10, 10)
self.slider.set_size_request(128, -1)
self.slider.set_value_pos(gtk.POS_LEFT)
self.slider.connect("value_changed", self.main.on_volume_changed)
self.slider.connect("button_press_event",
self.on_scale_button_press_event)
self.slider.connect("button_release_event",
self.on_scale_button_release_event)
self.slider.connect("scroll_event", self.on_scale_scroll_event)
def __init__(self):
ui = "auction-client.glade"
self.widget_tree = glade.XML(ui, "window")
signals = {
"on_quit_clicked": self.quit,
"on_save_clicked": self.save,
"on_load_clicked": self.load,
"on_connect_clicked": self.connect,
"on_buyer_toggled": self.buyer_toggled
}
self.widget_tree.signal_autoconnect(signals)
hbox = self.widget_tree.get_widget("scales")
self.scales = []
for price in range(PRICES):
scale = gtk.VScale(
gtk.Adjustment(TRADE_MAX // 2, 0, TRADE_MAX, 1,
TRADE_MAX // 10))
scale.set_draw_value(True)
scale.set_value_pos(gtk.POS_BOTTOM)
scale.set_inverted(True)
scale.set_digits(0)
scale.connect('value-changed', self.scale_changed)
self.scales.append(scale)
hbox.add(scale)
hbox.show_all()
# Used when changing the scales en-mass
self.enforce_monotonic_scales = True
def slider_window(self):
# Window
self.window = gtk.Window(gtk.WINDOW_POPUP)
self.window.set_size_request(44, 171)
# Frame
frame = gtk.Frame()
frame.set_border_width(1)
# Slider
self.slider = gtk.VScale()
self.slider.set_inverted(True)
self.slider.set_range(0, 100)
self.slider.set_increments(1, 10)
self.slider.set_digits(0)
self.slider.set_size_request(34, 160)
self.slider.set_value_pos(gtk.POS_BOTTOM)
self.slider.set_value(self.get_master_light())
# Events
self.window.connect('destroy', gtk.main_quit)
self.slider.connect('value-changed', self.cb_slider_change)
# Add widgets
fixed_slider = gtk.Fixed()
fixed_slider.put(self.slider, 3, 5)
frame.add(fixed_slider)
self.window.add(frame)
def __init__(self, qty, base, filename, parent, all_effects, vol_adj,
mute_adj):
gtk.Frame.__init__(self)
self.base = base
self.session_filename = filename
hbox = gtk.HBox()
hbox.set_spacing(1)
self.add(hbox)
vbox = gtk.VBox()
hbox.pack_start(vbox)
self.effects = []
self.all_effects = all_effects
count = 0
for row in range(qty):
effect = Effect(base + row, self.all_effects, parent)
self.effects.append(effect)
self.all_effects.append(effect)
vbox.pack_start(effect)
count += 1
level_vbox = gtk.VBox()
hbox.pack_start(level_vbox, False, padding=3)
vol_image = gtk.image_new_from_file(FGlobs.pkgdatadir / "volume2.png")
vol = gtk.VScale(vol_adj)
vol.set_inverted(True)
vol.set_draw_value(False)
set_tip(vol, _('Effects volume.'))
pb = gtk.gdk.pixbuf_new_from_file(FGlobs.pkgdatadir / "headroom.png")
mute_image = gtk.image_new_from_pixbuf(pb)
mute = gtk.VScale(mute_adj)
mute.set_inverted(True)
mute.set_draw_value(False)
set_tip(
mute,
_('Player headroom that is applied when an effect is playing.'))
spc = gtk.VBox()
for widget, expand in zip((vol_image, vol, spc, mute_image, mute),
(False, True, False, False, True)):
level_vbox.pack_start(widget, expand, padding=2)
def init_slider(self, adj, digits=0):
"""Apply defaults to gtk.VScale slider widgets"""
vscale = gtk.VScale(adj)
vscale.set_digits(digits)
vscale.set_update_policy(gtk.UPDATE_CONTINUOUS)
vscale.set_value_pos(gtk.POS_TOP)
vscale.set_draw_value(True)
vscale.set_inverted(True)
return vscale
def __init__(self, window):
self._window = window
self._page_selector_dialog = gtk.Dialog.__init__(self, "Go to page...", window,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.add_buttons(_('_Go'), gtk.RESPONSE_OK,
_('_Cancel'), gtk.RESPONSE_CANCEL,)
self.set_default_response(gtk.RESPONSE_OK)
self.set_has_separator(False)
self.connect('response', self._response)
self.set_resizable(True)
# Start thumbnail generation in case it has been delayed
self._window.thumbnailsidebar.load_thumbnails(True)
self._window.thumbnailsidebar.thumbnail_loaded += self._thumbnail_loaded
self._number_of_pages = self._window.imagehandler.get_number_of_pages()
self._selector_adjustment = gtk.Adjustment(value=self._window.imagehandler.get_current_page(),
lower=1,upper=self._number_of_pages,
step_incr=1, page_incr=1 )
self._selector_adjustment.connect( 'value-changed', self._cb_value_changed )
self._page_selector = gtk.VScale(self._selector_adjustment)
self._page_selector.set_draw_value(False)
self._page_selector.set_digits( 0 )
self._page_spinner = gtk.SpinButton(self._selector_adjustment)
self._page_spinner.connect( 'changed', self._page_text_changed )
self._page_spinner.set_activates_default(True)
self._page_spinner.set_numeric(True)
self._pages_label = gtk.Label(_(' of %s') % self._number_of_pages)
self._pages_label.set_alignment(0, 0.5)
self._image_preview = gtk.Image()
self._set_thumbnail(int(self._selector_adjustment.value) - 1)
# Group preview image and page selector next to each other
preview_box = gtk.HBox()
preview_box.set_border_width(5)
preview_box.set_spacing(5)
preview_box.pack_start(self._image_preview, True)
preview_box.pack_end(self._page_selector, False)
# Below them, group selection spinner and current page label
selection_box = gtk.HBox()
selection_box.set_border_width(5)
selection_box.pack_start(self._page_spinner, True)
selection_box.pack_end(self._pages_label, False)
self.get_content_area().pack_start(preview_box, True)
self.get_content_area().pack_end(selection_box, False)
self.show_all()
# Set focus on the input box.
self._page_spinner.select_region(0, -1)
self._page_spinner.grab_focus()
def __init__(self, name, seq, producer, is_master=False):
gtk.Frame.__init__(self)
self.seq = seq
self.producer = producer
self.is_master = is_master
if is_master:
gain_value = seq.master_audio_gain # tractor master
else:
gain_value = producer.audio_gain # track
gain_value = gain_value * 100
self.adjustment = gtk.Adjustment(value=gain_value, lower=0, upper=100, step_incr=1)
self.slider = gtk.VScale()
self.slider.set_adjustment(self.adjustment)
self.slider.set_size_request(SLOT_W - 10, CONTROL_SLOT_H - 105)
self.slider.set_inverted(True)
self.slider.connect("value-changed", self.gain_changed)
if is_master:
pan_value = seq.master_audio_pan
else:
pan_value = producer.audio_pan
if pan_value == appconsts.NO_PAN:
pan_value = 0.5 # center
pan_value = (pan_value - 0.5) * 200 # from range 0 - 1 to range -100 - 100
self.pan_adjustment = gtk.Adjustment(value=pan_value, lower=-100, upper=100, step_incr=1)
self.pan_slider = gtk.HScale()
self.pan_slider.set_adjustment(self.pan_adjustment)
self.pan_slider.connect("value-changed", self.pan_changed)
self.pan_button = gtk.ToggleButton(_("Pan"))
self.pan_button.connect("toggled", self.pan_active_toggled)
if pan_value == 0.0:
self.pan_slider.set_sensitive(False)
else:
self.pan_button.set_active(True)
self.pan_adjustment.set_value(pan_value) # setting button active sets value = 0, set correct value again
label = guiutils.bold_label(name)
vbox = gtk.VBox(False, 0)
vbox.pack_start(guiutils.get_pad_label(5,5), False, False, 0)
vbox.pack_start(label, False, False, 0)
vbox.pack_start(guiutils.get_pad_label(5,5), False, False, 0)
vbox.pack_start(self.slider, False, False, 0)
vbox.pack_start(self.pan_button, False, False, 0)
vbox.pack_start(self.pan_slider, False, False, 0)
vbox.pack_start(guiutils.get_pad_label(5,5), False, False, 0)
self.add(vbox)
self.set_size_request(SLOT_W, CONTROL_SLOT_H)
def __init__(self):
self.wnd = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.wnd.set_title('"In C" In C (... in Python!)')
self.wnd.set_border_width(5)
self.wnd.connect('destroy', self.destroy)
#self.wnd.set_size_request(300,300)
#self.wnd.set_default_size(300,300)
tempo_adj = gtk.Adjustment(value=120,
lower=40,
upper=300,
step_incr=1,
page_incr=10)
tempo = gtk.VScale(adjustment=tempo_adj)
tempo.set_update_policy(gtk.UPDATE_DELAYED)
tempo.set_inverted(True)
tempo.set_size_request(-1, 120)
tempo_adj.connect('value_changed', self.tempo_changed)
volume_adj, volume = midi_adj()
volume.set_size_request(-1, 120)
volume_adj.connect('value_changed', self.volume_changed)
master_table = gtk.Table(rows=2, columns=2, homogeneous=False)
tempo_lbl = gtk.Label('Tempo')
volume_lbl = gtk.Label('Volume')
master_table.attach(tempo_lbl,
0,
1,
0,
1,
yoptions=gtk.SHRINK,
xoptions=gtk.SHRINK,
xpadding=5,
ypadding=5)
master_table.attach(volume_lbl, 1, 2, 0, 1, xpadding=5, ypadding=5)
master_table.attach(tempo, 0, 1, 1, 2, yoptions=gtk.EXPAND | gtk.FILL)
master_table.attach(volume, 1, 2, 1, 2, yoptions=gtk.EXPAND | gtk.FILL)
self.instr_vbox = gtk.VBox()
self.draw_instruments(self.instr_vbox)
self.add_button = gtk.Button('Add instrument', gtk.STOCK_ADD)
self.add_button.connect('clicked', self.add_instrument)
self.instr_vbox.pack_start(self.add_button)
instr_frame = gtk.Frame(label='Instruments')
instr_frame.add(self.instr_vbox)
master_frame = gtk.Frame(label='Master')
master_frame.add(master_table)
controls_vbox = gtk.VBox()
controls_vbox.pack_start(master_frame, expand=False)
controls_vbox.pack_start(instr_frame)
self.wnd.add(controls_vbox)
self.wnd.show_all()
def __init__(self, nchannels, host, port, instance, external_instance,
local_port):
self.lock = threading.Lock()
self.osc = VolumeOSC(self, host, port, instance, external_instance,
local_port)
self.nchannels = nchannels
print "channels=" + str(self.nchannels)
if self.nchannels == 1:
self.nchannels = 0
self.nchannels += 1
self.vscales = [None] * self.nchannels
self.dbs = [None] * self.nchannels
self.mutes = [None] * self.nchannels
self.muted = [None] * self.nchannels
for i, val in enumerate(self.vscales):
self.vscales[i] = gtk.VScale()
self.vscales[i].set_digits(2)
self.vscales[i].set_draw_value(False)
self.vscales[i].set_range(0, 1)
self.vscales[i].set_value(db_to_fader(0.0))
self.vscales[i].set_inverted(True)
# self.vscales[i].add_mark(100, gtk.POS_RIGHT, "100")
# self.vscales[i].add_mark(75, gtk.POS_RIGHT, "75")
# self.vscales[i].add_mark(50, gtk.POS_RIGHT, "50")
# self.vscales[i].add_mark(25, gtk.POS_RIGHT, "25")
# self.vscales[i].add_mark(0, gtk.POS_RIGHT, "0")
self.vscales[i].connect("change-value", self.scale_event)
self.table.attach(self.vscales[i], i, i + 1, 2, 3)
self.vscales[i].show()
self.mutes[i] = gtk.Button("Mute")
self.set_mute(i, False)
# self.send_channel_mute(i, False)
self.mutes[i].connect("clicked", self.click_mute)
self.table.attach(self.mutes[i], i, i + 1, 0, 1, gtk.SHRINK,
gtk.SHRINK)
self.mutes[i].show()
self.dbs[i] = gtk.Entry(0)
self.dbs[i].set_text("0.0")
self.dbs[i].set_width_chars(4)
self.dbs[i].connect("activate", self.activate_event)
self.dbs[i].show()
self.table.attach(self.dbs[i], i, i + 1, 1, 2, gtk.SHRINK,
gtk.SHRINK)
if (i != self.nchannels - 1):
# self.send_channel_osc(i, db_to_coeff(0.0))
label = gtk.Label("Channel " + str(i + 1))
self.table.attach(label, i, i + 1, 3, 4, gtk.SHRINK, gtk.FILL)
label.show()
def add_drive(key, name, lb, ub, incr=None, page=None):
if incr is None: incr = (ub - lb) / 100
if page is None: page = incr * 10
adj = gtk.Adjustment(0.0, lb, ub, incr, page, 0.0)
self.adjs[key] = adj
scale = gtk.VScale(adj)
scale.set_digits(2)
scale.set_size_request(25, 170)
adj.connect('value_changed', self.drive_changed, key)
drivebox.add(add_gtk_frame(name, scale))
def _create_band_slider(self, on_change):
band = gtk.VScale(gtk.Adjustment(0, -6, 7, 1, 1, 1))
band.set_inverted(True)
def change_value_cb(*args):
x, y, mods = self.get_screen().get_root_window().get_pointer()
# print bool((gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON2_MASK | gtk.gdk.BUTTON3_MASK) & mods)
if not bool(mods):
on_change(band)
band.connect('change-value', change_value_cb)
for i in xrange(-6, 7):
band.add_mark(i, gtk.POS_RIGHT, None)
return band
def midi_adj(vertical=True):
adj = gtk.Adjustment(value=80,
lower=0,
upper=127,
step_incr=1,
page_incr=10)
if vertical:
scale = gtk.VScale(adjustment=adj)
scale.set_inverted(True)
else:
scale = gtk.HScale(adjustment=adj)
scale.set_value_pos(gtk.POS_RIGHT)
scale.set_update_policy(gtk.UPDATE_DELAYED)
return adj, scale
def change_manual_control(self, widget=None, data=None):
self.log.debug("change_manual_control")
if widget.get_active():
self.log.warning("Request to chnage to manual")
widget.set_label("Automatic")
for child in self.table_manualControl.get_children():
if child != widget:
child.show()
if type(child) == gtk.VScale():
child.set_value(self.robot.get_power())
else:
self.log.warning("Request to chnage to automatic")
widget.set_label("Manual")
for child in self.table_manualControl.get_children():
if child != widget:
child.hide()
def __init__(self):
super(app, self).__init__()
self.set_position(gtk.WIN_POS_CENTER)
self.set_title("LED controller")
self.set_decorated(True)
self.set_has_frame(False)
self.set_resizable(False)
self.set_default_size(self.window_width, self.window_height)
self.connect("destroy", gtk.main_quit)
vbox = gtk.VBox(spacing=4)
#Setup the horizontal slider bar
scaleX = gtk.HScale()
scaleX.set_range(self.min_x, self.max_x)
scaleX.set_size_request(500, 25)
scaleX.set_value(self.x_pos)
scaleX.connect("value-changed", self.update_x)
vbox.add(scaleX)
#Setup the vertical slider bar
scaleY = gtk.VScale()
scaleY.set_range(self.min_y, self.max_y)
scaleY.set_size_request(25, 500)
scaleY.set_value(self.y_pos)
scaleY.connect("value-changed", self.update_y)
vbox.add(scaleY)
#Setup the information label
info = gtk.Label()
info.set_label("Move the slider to move the LED")
vbox.add(info)
#Add the image to the display
#new_image = self.process_image()
#converted_image = gtk.gdk.pixbuf_new_from_array(new_image, gtk.gdk.COLORSPACE_RGB, 8)
#image = gtk.Image()
#image.set_from_pixbuf(converted_image)
#image.show()
#vbox.add(image)
gobject.timeout_add(self.refresh_rate, self.refresh)
#self.current_image = image
self.add(vbox)
self.show_all()
def __init__(self, orient='h', ticks=0, **kwds):
self._orient = orient
self._ticks = ticks
self._discrete = False
self._live = True
self._gtk_ticks = None
length = 100
gtk_adjustment = gtk.Adjustment(upper=1.0)
xs = 0.0
ys = 0.0
if orient == 'h':
gtk_scale = gtk.HScale(gtk_adjustment)
gtk_scale.set_size_request(length, -1)
gtk_box = gtk.VBox()
xs = 1.0
elif orient == 'v':
gtk_scale = gtk.VScale(gtk_adjustment)
gtk_scale.set_size_request(-1, length)
gtk_box = gtk.HBox()
ys = 1.0
else:
raise ValueError("Invalid orientation, should be 'h' or 'v'")
gtk_scale.set_draw_value(False)
self._gtk_scale = gtk_scale
gtk_box.pack_start(gtk_scale)
self._gtk_box = gtk_box
if ticks:
self._gtk_create_ticks()
gtk_alignment = gtk.Alignment(xalign=0.5,
yalign=0.5,
xscale=xs,
yscale=ys)
gtk_alignment.add(gtk_box)
gtk_alignment.show_all()
self._gtk_connect(gtk_adjustment, 'value-changed',
self._gtk_value_changed)
self._gtk_connect(gtk_scale, 'change-value', self._gtk_change_value)
self._gtk_connect(gtk_scale, 'button-release-event',
self._gtk_button_release)
self._gtk_scale = gtk_scale
self._gtk_adjustment = gtk_adjustment
self._gtk_enable_action = True
GSlider.__init__(self, _gtk_outer=gtk_alignment, **kwds)
def __init__(self, text, callback, def_value=0):
self.callback = callback
self.text = text
gtk.VBox.__init__(self, False, 0)
self.show()
adjustment = gtk.Adjustment(value=def_value, lower= -12, upper=12, step_incr=1, page_incr=2, page_size=0)
self.scale = gtk.VScale(adjustment)
self.scale.connect("change-value", self.on_change_value)
self.scale.set_size_request(-1, 140)
self.scale.set_draw_value(False)
self.scale.set_inverted(True)
self.scale.show()
"""text under"""
text = gtk.Label(text)
text.show()
self.pack_start(self.scale, False, False, 0)
self.pack_start(text, False, False, 0)
def show_channels(self, entry=None):
if entry == None:
canales = self.entry_canales.get_text().split(",")
else:
canales = entry.split(",")
try:
self.CVbox.destroy()
except:
pass
try:
self.CVbox = gtk.HBox()
self.CVbox.show()
print canales
for i in canales:
i = int(i)
vboz = gtk.VBox()
vboz.show()
lab = gtk.Label("Canal " + str(i))
lab.show()
lab.set_angle(-45)
vboz.pack_start(lab, False)
vscale = gtk.VScale()
vscale.set_digits(0)
vscale.set_range(0, 255)
vscale.set_inverted(True)
vscale.set_value(self.vscales[i])
vscale.connect('change-value', self.on_scale_change_value, i)
vboz.pack_start(vscale, True)
vscale.show()
self.CVbox.pack_start(vboz, True, True, 0)
self.box_control.add(self.CVbox)
except:
self.CVbox.destroy()
print "Posiblemente sintáxis incorecta. Funcionamiento normal, se ignora."
def __init__(self, minval, maxval, scaling=None):
gtk.VBox.__init__(self)
self._min = minval
self._max = maxval
if scaling == None:
self._scaling = self.SCALE_LINEAR
else:
self._scaling = scaling
self._vscale = gtk.VScale()
self._vscale.set_draw_value(False)
self._vscale.set_size_request(50, 100)
self._vscale.set_range(0, 1)
self.pack_start(gtk.Label('%r' % minval), False, False)
self.pack_start(self._vscale, False, False)
self.pack_start(gtk.Label('%r' % maxval), False, False)
self.show_all()
self._vscale.connect('change-value', self._change_value_cb)
def __init__(self, activity):
""" Set up initial toolbars """
gtk.Toolbar.__init__(self)
self.activity = activity
self.show_toolbar = True
self.mode = 'sound'
self.mode_values = {'sound': 3, 'sensor': 2}
self.button_up = ToolButton('amp-high')
self.button_up.set_tooltip(_('Increase amplitude'))
self.button_up.connect('clicked', self._button_up_cb)
self.button_up.show()
self.adjustmenty = gtk.Adjustment(self.mode_values[self.mode],
self.LOWER, self.UPPER, 0.1, 0.1,
0.0)
self.adjustmenty.connect('value_changed', self._yscrollbar_cb,
self.adjustmenty)
self.yscrollbar = gtk.VScale(self.adjustmenty)
self.yscrollbar.set_draw_value(False)
self.yscrollbar.set_inverted(True)
self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.button_down = ToolButton('amp-low')
self.button_down.set_tooltip(_('Decrease amplitude'))
self.button_down.connect('clicked', self._button_down_cb)
self.button_down.show()
self.box1 = gtk.VBox(False, 0)
self.box1.pack_start(self.button_up, False, True, 0)
self.box1.pack_start(self.yscrollbar, True, True, 0)
self.box1.pack_start(self.button_down, False, True, 0)
self.set_show_hide(False)
def __init__(self):
# Standard window-creating stuff
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", lambda w: gtk.main_quit())
self.window.set_title("range controls")
box1 = gtk.VBox(False, 0)
self.window.add(box1)
box1.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
box1.pack_start(box2, True, True, 0)
box2.show()
# value, lower, upper, step_increment, page_increment, page_size
# Note that the page_size value only makes a difference for
# scrollbar widgets, and the highest value you'll get is actually
# (upper - page_size).
adj1 = gtk.Adjustment(0.0, 0.0, 101.0, 0.1, 1.0, 1.0)
self.vscale = gtk.VScale(adj1)
scale_set_default_values(self.vscale)
box2.pack_start(self.vscale, True, True, 0)
self.vscale.show()
box3 = gtk.VBox(False, 10)
box2.pack_start(box3, True, True, 0)
box3.show()
# Reuse the same adjustment
self.hscale = gtk.HScale(adj1)
self.hscale.set_size_request(200, 30)
scale_set_default_values(self.hscale)
box3.pack_start(self.hscale, True, True, 0)
self.hscale.show()
# Reuse the same adjustment again
scrollbar = gtk.HScrollbar(adj1)
# Notice how this causes the scales to always be updated
# continuously when the scrollbar is moved
scrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
box3.pack_start(scrollbar, True, True, 0)
scrollbar.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
box1.pack_start(box2, True, True, 0)
box2.show()
# A checkbutton to control whether the value is displayed or not
button = gtk.CheckButton("Display value on scale widgets")
button.set_active(True)
button.connect("toggled", self.cb_draw_value)
box2.pack_start(button, True, True, 0)
button.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
# An option menu to change the position of the value
label = gtk.Label("Scale Value Position:")
box2.pack_start(label, False, False, 0)
label.show()
opt = gtk.OptionMenu()
menu = gtk.Menu()
item = make_menu_item("Top", self.cb_pos_menu_select, gtk.POS_TOP)
menu.append(item)
item = make_menu_item("Bottom", self.cb_pos_menu_select,
gtk.POS_BOTTOM)
menu.append(item)
item = make_menu_item("Left", self.cb_pos_menu_select, gtk.POS_LEFT)
menu.append(item)
item = make_menu_item("Right", self.cb_pos_menu_select, gtk.POS_RIGHT)
menu.append(item)
opt.set_menu(menu)
box2.pack_start(opt, True, True, 0)
opt.show()
box1.pack_start(box2, True, True, 0)
box2.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
# Yet another option menu, this time for the update policy of the
# scale widgets
label = gtk.Label("Scale Update Policy:")
box2.pack_start(label, False, False, 0)
label.show()
opt = gtk.OptionMenu()
menu = gtk.Menu()
item = make_menu_item("Continuous", self.cb_update_menu_select,
gtk.UPDATE_CONTINUOUS)
menu.append(item)
item = make_menu_item("Discontinuous", self.cb_update_menu_select,
gtk.UPDATE_DISCONTINUOUS)
menu.append(item)
item = make_menu_item("Delayed", self.cb_update_menu_select,
gtk.UPDATE_DELAYED)
menu.append(item)
opt.set_menu(menu)
box2.pack_start(opt, True, True, 0)
opt.show()
box1.pack_start(box2, True, True, 0)
box2.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
# An HScale widget for adjusting the number of digits on the
# sample scales.
label = gtk.Label("Scale Digits:")
box2.pack_start(label, False, False, 0)
label.show()
adj2 = gtk.Adjustment(1.0, 0.0, 5.0, 1.0, 1.0, 0.0)
adj2.connect("value_changed", self.cb_digits_scale)
scale = gtk.HScale(adj2)
scale.set_digits(0)
box2.pack_start(scale, True, True, 0)
scale.show()
box1.pack_start(box2, True, True, 0)
box2.show()
box2 = gtk.HBox(False, 10)
box2.set_border_width(10)
# And, one last HScale widget for adjusting the page size of the
# scrollbar.
label = gtk.Label("Scrollbar Page Size:")
box2.pack_start(label, False, False, 0)
label.show()
adj2 = gtk.Adjustment(1.0, 1.0, 101.0, 1.0, 1.0, 0.0)
adj2.connect("value_changed", self.cb_page_size, adj1)
scale = gtk.HScale(adj2)
scale.set_digits(0)
box2.pack_start(scale, True, True, 0)
scale.show()
box1.pack_start(box2, True, True, 0)
box2.show()
separator = gtk.HSeparator()
box1.pack_start(separator, False, True, 0)
separator.show()
box2 = gtk.VBox(False, 10)
box2.set_border_width(10)
box1.pack_start(box2, False, True, 0)
box2.show()
button = gtk.Button("Quit")
button.connect("clicked", lambda w: gtk.main_quit())
box2.pack_start(button, True, True, 0)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
button.show()
self.window.show()
def __init__(self):
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
wiringpi2.wiringPiSetupGpio()
self.redPin = 23
self.bluePin = 24
self.greenPin = 18
wiringpi2.pinMode(self.redPin, 1)
wiringpi2.pinMode(self.bluePin, 1)
wiringpi2.pinMode(self.greenPin, 1)
wiringpi2.softPwmCreate(self.redPin, 0, 100)
wiringpi2.softPwmCreate(self.bluePin, 0, 100)
wiringpi2.softPwmCreate(self.greenPin, 0, 100)
self.checkBoxBox = gtk.HBox(False, 0)
self.sliderBox = gtk.HBox(False, 0)
self.bigBox = gtk.VBox(False, 0)
self.window.set_border_width(50)
self.red = gtk.CheckButton("Red", False)
self.red.connect("toggled", self.buttonToggled, "red")
self.green = gtk.CheckButton("Green", False)
self.green.connect("toggled", self.buttonToggled, "green")
self.blue = gtk.CheckButton("Blue", False)
self.blue.connect("toggled", self.buttonToggled, "blue")
self.window.connect("delete-event", self.cleanupHandler)
self.window.set_title("Magical Light Box")
self.redIsOn = False
self.blueIsOn = False
self.greenIsOn = False
self.redSlider = gtk.VScale()
self.greenSlider = gtk.VScale()
self.blueSlider = gtk.VScale()
buttonList = [self.red, self.green, self.blue]
sliderList = [self.redSlider, self.greenSlider, self.blueSlider]
for button in buttonList:
self.checkBoxBox.pack_start(button, False, False, 10)
button.show()
for slider in sliderList:
slider.set_range(0, 100)
slider.set_inverted(True)
slider.set_round_digits(0)
slider.set_increments(1, 100)
slider.set_size_request(35, 150)
self.redSlider.connect("value-changed", self.sliderMoved, "red")
self.greenSlider.connect("value-changed", self.sliderMoved, "green")
self.blueSlider.connect("value-changed", self.sliderMoved, "blue")
for slider in sliderList: #I can probs merge these loops
self.sliderBox.pack_start(slider, True, True, 10)
slider.show()
self.bigBox.pack_start(self.checkBoxBox, False, False, 10)
self.checkBoxBox.show()
self.bigBox.pack_start(self.sliderBox, False, False, 10)
self.sliderBox.show()
self.window.add(self.bigBox)
self.bigBox.show()
self.window.show()
def __init__(self, activity, channel=0):
''' Set up initial toolbars '''
gtk.Toolbar.__init__(self)
self.activity = activity
self._channel = channel
if self._channel == 0:
self.show_toolbar = True
else: # Don't show second channel until we need it
self.show_toolbar = False
self.mode = 'sound'
self.mode_values = {'sound': 3, 'sensor': 2}
self._toggle = gtk.CheckButton()
self._toggle.set_active(True)
self._toggle.connect('clicked', self.toggle_cb)
self._toggle.show()
self._toggle_box = gtk.HBox()
self._toggle_box.pack_start(self._toggle, False, True, 18)
self._invert = ToolButton('invert')
self._invert.set_tooltip(_('Invert'))
self._invert.connect('clicked', self.invert_control_cb)
self._invert.show()
self.activity.wave.set_invert_state(False, channel=self._channel)
self.button_up = ToolButton('amp-high')
self.button_up.set_tooltip(_('Increase amplitude'))
self.button_up.connect('clicked', self._button_up_cb)
self.button_up.show()
self.adjustmenty = gtk.Adjustment(self.mode_values[self.mode], LOWER,
UPPER, 0.1, 0.1, 0.0)
self.adjustmenty.connect('value_changed', self._yscrollbar_cb,
self.adjustmenty)
self.yscrollbar = gtk.VScale(self.adjustmenty)
self.yscrollbar.set_draw_value(False)
self.yscrollbar.set_inverted(True)
self.yscrollbar.set_update_policy(gtk.UPDATE_CONTINUOUS)
self.button_down = ToolButton('amp-low')
self.button_down.set_tooltip(_('Decrease amplitude'))
self.button_down.connect('clicked', self._button_down_cb)
self.button_down.show()
self.box1 = gtk.VBox(False, 0)
if self._channel == 0:
self.box1.pack_start(self._color_wave(self.activity.stroke_color),
False, True, 0)
elif self._channel == 1:
self.box1.pack_start(self._color_wave(self.activity.fill_color),
False, True, 0)
else:
self.box1.pack_start(self._color_wave('#FFFFFF'), False, True, 0)
self.box1.pack_start(self._toggle_box, False, True, 0)
self.box1.pack_start(self._invert, False, True, 0)
self.box1.pack_start(self.button_up, False, True, 0)
self.box1.pack_start(self.yscrollbar, True, True, 0)
self.box1.pack_start(self.button_down, False, True, 0)
self.set_show_hide(False)
def __init__(self, ins, param, delay=50):
if type(ins) is types.StringType:
ins = qt.get_instrument_proxy(ins)
self._instrument = ins
self._parameter = param
self._parameter_options = self._instrument.get_shared_parameter_options(
param)
if ins is not None and param in ins.get_parameter_names():
name = '%s.%s' % (ins.get_name(), param)
else:
name = 'Paramter undefined'
title = _L('Parameter: %s') % name
qtwindow.QTWindow.__init__(self, name, title, add_to_main=False)
self.connect('delete-event', self._delete_event_cb)
self._delay = delay
self._value_to_set = None
self._set_hid = None
if self._parameter_options.has_key('minval'):
self._insmin = self._parameter_options['minval']
self._min = self._insmin
else:
logging.warning('Be careful! Parameter has no \
minimum defined!')
self._insmin = -1e20
self._min = self._instrument.get(param)
if self._parameter_options.has_key('maxval'):
self._insmax = self._parameter_options['maxval']
self._max = self._insmax
else:
logging.warning('Be careful! Parameter has no \
maximum defined!')
self._insmax = 1e20
self._max = self._instrument.get(param)
self._range = self._max - self._min
self._value = self._instrument.get(param)
self._get_after_set = True
### start of gui init
### sliders frame
slider = gtk.VScale()
slider.set_inverted(True)
slider.set_size_request(50, -1)
slider.set_range(self._min, self._max)
slider.set_digits(2)
slider.set_draw_value(False)
slider.connect('change-value', self._change_value_cb)
self._main_slider = slider
self._main_slider_label = gtk.Label('x1')
vbox = gtk.VBox()
vbox.pack_start(self._main_slider_label, False, False)
vbox.pack_start(slider, True, True)
self._main_slider_vbox = vbox
self._fine_sliders = []
self._fine_slider_vboxes = []
self._fine_slider_labels = []
for i in range(3):
slider = gtk.VScale()
slider.set_inverted(True)
slider.set_size_request(50, -1)
slider.set_range(-1, 1)
slider.set_digits(2)
slider.set_draw_value(False)
slider.connect('change-value', self._change_value_cb)
self._fine_sliders.append(slider)
label = gtk.Label('x0.%s1' % (i * '0'))
self._fine_slider_labels.append(label)
vbox = gtk.VBox()
vbox.pack_start(label, False, False)
vbox.pack_start(slider, True, True)
self._fine_slider_vboxes.append(vbox)
self._slider_hbox = gui.pack_hbox([
self._main_slider_vbox,
self._fine_slider_vboxes[0],
self._fine_slider_vboxes[1],
self._fine_slider_vboxes[2],
])
self._slframe = gtk.Frame()
self._slframe.add(self._slider_hbox)
### controls frame
self._max_label = gtk.Label('max:')
self._max_value = gtk.Label('%e' % self._max)
self._max_entry = gtk.Entry()
self._max_but = gtk.Button('Set')
self._max_but.connect('clicked', self._set_max_clicked_cb)
self._min_label = gtk.Label('min:')
self._min_value = gtk.Label('%e' % self._min)
self._min_entry = gtk.Entry()
self._min_but = gtk.Button('Set')
self._min_but.connect('clicked', self._set_min_clicked_cb)
self._delay_label = gtk.Label('delay:')
self._delay_value = gtk.Label('%d' % self._delay)
self._delay_entry = gtk.Entry()
self._delay_but = gtk.Button('Set')
self._delay_but.connect('clicked', self._set_delay_clicked_cb)
self._value_label = gtk.Label('value:')
self._value_getbut = gtk.Button('Get')
self._value_getbut.connect('clicked', self._get_value_clicked_cb)
self._value_entry = gtk.Entry()
self._value_but = gtk.Button('Set')
self._value_but.connect('clicked', self._set_value_clicked_cb)
self._ctable = gtk.Table(4, 4, True)
self._ctable.set_homogeneous(False)
self._ctable.attach(self._max_label, 0, 1, 0, 1)
self._ctable.attach(self._max_value, 1, 2, 0, 1)
self._ctable.attach(self._max_entry, 2, 3, 0, 1)
self._ctable.attach(self._max_but, 3, 4, 0, 1)
self._ctable.attach(self._min_label, 0, 1, 1, 2)
self._ctable.attach(self._min_value, 1, 2, 1, 2)
self._ctable.attach(self._min_entry, 2, 3, 1, 2)
self._ctable.attach(self._min_but, 3, 4, 1, 2)
self._ctable.attach(self._delay_label, 0, 1, 2, 3)
self._ctable.attach(self._delay_value, 1, 2, 2, 3)
self._ctable.attach(self._delay_entry, 2, 3, 2, 3)
self._ctable.attach(self._delay_but, 3, 4, 2, 3)
self._ctable.attach(self._value_label, 0, 1, 3, 4)
self._ctable.attach(self._value_getbut, 1, 2, 3, 4)
self._ctable.attach(self._value_entry, 2, 3, 3, 4)
self._ctable.attach(self._value_but, 3, 4, 3, 4)
self._cframe = gtk.Frame()
self._cframe.add(self._ctable)
self._max_value.set_size_request(100, 1)
### value frame
self._vallabel = gtk.Label('')
self._vallabel.set_markup('<span size="xx-large">%e</span>' %
self._value)
self._valframe = gtk.Frame()
self._valframe.add(self._vallabel)
### put together
self._alltable = gtk.Table(2, 2, True)
self._alltable.set_homogeneous(False)
self._alltable.attach(self._cframe, 0, 1, 0, 1)
self._alltable.attach(self._valframe, 0, 1, 1, 2)
self._alltable.attach(self._slframe, 1, 2, 0, 2)
### end of gui init
self._set_sliders()
self.add(self._alltable)
self.show_all()
def __init__(self, nchannels, host, port, protocol, instance, local_port):
self.lock = threading.Lock()
self.osc = VolumeOSC(self, host, port, protocol, instance, local_port)
self.osc.start()
self.nchannels = nchannels
print "channels=" + str(self.nchannels)
if self.nchannels == 1:
self.nchannels = 0
self.nchannels += 1
self.vscales = [None] * self.nchannels
self.dbs = [None] * self.nchannels
self.mutes = [None] * self.nchannels
self.muted = [None] * self.nchannels
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.delete_event)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(10)
self.table = gtk.Table(4, channels)
for i, val in enumerate(self.vscales):
self.vscales[i] = gtk.VScale()
self.vscales[i].set_digits(2)
self.vscales[i].set_draw_value(False)
self.vscales[i].set_range(0, 1)
self.vscales[i].set_value(db_to_fader(0.0))
self.vscales[i].set_inverted(True)
# self.vscales[i].add_mark(100, gtk.POS_RIGHT, "100")
# self.vscales[i].add_mark(75, gtk.POS_RIGHT, "75")
# self.vscales[i].add_mark(50, gtk.POS_RIGHT, "50")
# self.vscales[i].add_mark(25, gtk.POS_RIGHT, "25")
# self.vscales[i].add_mark(0, gtk.POS_RIGHT, "0")
self.vscales[i].connect("change-value", self.scale_event)
self.table.attach(self.vscales[i], i, i + 1, 2, 3)
self.vscales[i].show()
self.mutes[i] = gtk.Button("Mute")
self.set_mute(i, False)
# self.send_channel_mute(i, False)
self.mutes[i].connect("clicked", self.click_mute)
self.table.attach(self.mutes[i], i, i + 1, 0, 1, gtk.SHRINK,
gtk.SHRINK)
self.mutes[i].show()
self.dbs[i] = gtk.Entry(0)
self.dbs[i].set_text("0.0")
self.dbs[i].set_width_chars(4)
self.dbs[i].connect("activate", self.activate_event)
self.dbs[i].show()
self.table.attach(self.dbs[i], i, i + 1, 1, 2, gtk.SHRINK,
gtk.SHRINK)
if (i != self.nchannels - 1):
# self.send_channel_osc(i, db_to_coeff(0.0))
label = gtk.Label("Channel " + str(i + 1))
self.table.attach(label, i, i + 1, 3, 4, gtk.SHRINK, gtk.FILL)
label.show()
#self.table.attach(self.vscales[i], i, i+1, 0, 1)
# self.send_master_osc(db_to_coeff(0.0))
# self.send_master_mute(False)
master = gtk.Label("Master")
self.table.attach(master, self.nchannels - 1, self.nchannels, 3, 4,
gtk.FILL, gtk.FILL)
master.show()
self.window.add(self.table)
self.window.set_size_request(self.nchannels * 90, 300)
self.window.set_position(gtk.WIN_POS_CENTER)
self.table.show()
self.window.show()
def __init__(self, parent, parallaxes, bgColor):
gtk.Dialog.__init__(self, "Backgrounds", parent,
gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT,
gtk.STOCK_APPLY, gtk.RESPONSE_ACCEPT))
self.bgColor = bgColor
self.parallaxes = parallaxes
# Default width and height.
# TODO: tweak this so that it works on the netbook
previewWidth = 1024
previewHeight = 768
previewScale = 1.0
# Left side of dialog: contains the preview and sliders
vs = gtk.VScale(gtk.Adjustment(0, -2000, 2000, 1, 10, 10))
vs.set_digits(0)
vs.set_draw_value(False)
hs = gtk.HScale(gtk.Adjustment(0, -5000, 5000, 1, 10, 10))
hs.set_draw_value(False)
hs.set_digits(0)
t = gtk.Table(2, 2)
self.__preview = parallax.ParallaxViewer(previewWidth, previewHeight,
previewScale)
vs.connect("value-changed", self.previewYChanged)
hs.connect("value-changed", self.previewXChanged)
t.attach(self.__preview, 0, 1, 0, 1)
t.attach(vs, 1, 2, 0, 1)
t.attach(hs, 0, 1, 1, 2)
# Right side of dialog: contains preview size spin buttons, background
# color selector, and list of layers.
# Top portion
builder = HIGTableBuilder()
builder.addSectionHeader("Background")
self.colorButton = gtk.ColorButton(self.bgColor.getGdk())
self.colorButton.connect("color-set", self.colorSet)
builder.addLabeledWidget("Color:", self.colorButton)
self.__preview.setColor(self.bgColor)
builder.addSectionHeader("Preview")
previewWSpin = gtk.SpinButton(
gtk.Adjustment(previewWidth, 0, 1024, 1, 10, 0), 10, 0)
previewWSpin.connect("value-changed", self.previewWidthChanged)
builder.addLabeledWidget("Width:", previewWSpin)
previewHSpin = gtk.SpinButton(
gtk.Adjustment(previewHeight, 0, 768, 1, 10, 0), 10, 0)
previewHSpin.connect("value-changed", self.previewHeightChanged)
builder.addLabeledWidget("Height:", previewHSpin)
previewScale = gtk.SpinButton(
gtk.Adjustment(previewScale, 0.1, 2.0, 0.1, 0.0), 10, 2)
previewScale.connect("value-changed", self.previewScaleChanged)
builder.addLabeledWidget("Zoom", previewScale)
# List view
self.treeModel = gtk.ListStore(bool, str)
self.treeView = gtk.TreeView(self.treeModel)
cto = gtk.CellRendererToggle()
cto.set_property("activatable", True)
cto.connect("toggled", self.visibilityToggle)
self.treeView.append_column(
gtk.TreeViewColumn("Visible", cto, active=0))
cte = gtk.CellRendererText()
self.treeView.append_column(
gtk.TreeViewColumn("Background", cte, text=1))
# Add current parallax information to the tree view
if self.parallaxes is not None:
for p in self.parallaxes:
self.treeModel.prepend(
[p.visible, os.path.basename(p.fileName)])
self.__preview.addBackground(p)
# This has the same effect as clicking the edit button
self.treeView.connect("row-activated", self.rowActivated)
toolbar = gtk.Toolbar()
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_show_arrow(False)
newButton = gtk.ToolButton(gtk.STOCK_NEW)
newButton.connect("clicked", self.newClicked)
toolbar.insert(newButton, -1)
deleteButton = gtk.ToolButton(gtk.STOCK_DELETE)
deleteButton.connect("clicked", self.deleteClicked)
toolbar.insert(deleteButton, -1)
upButton = gtk.ToolButton(gtk.STOCK_GO_UP)
upButton.connect("clicked", self.upClicked)
toolbar.insert(upButton, -1)
downButton = gtk.ToolButton(gtk.STOCK_GO_DOWN)
downButton.connect("clicked", self.downClicked)
toolbar.insert(downButton, -1)
editButton = gtk.ToolButton(gtk.STOCK_EDIT)
editButton.connect("clicked", self.editClicked)
toolbar.insert(editButton, -1)
vBox = gtk.VBox()
vBox.pack_start(builder.getTable(), False, False)
vBox.pack_end(toolbar, False, True)
vBox.pack_end(self.treeView)
hBox = gtk.HBox()
hBox.pack_start(t)
hBox.pack_end(vBox)
self.vbox.add(hBox)
self.set_resizable(False)
self.show_all()
def slider(self,
init,
start,
end,
x,
y,
box,
title="",
vert=True,
linear=True,
dwid=100,
label=""):
"""Creates a slider
init: initial value
start, end: start and end of slider range
x, y: x and y sizes of slider
box: parent box
title: if given, the slider name,
which will also be the bus channel
name. Otherwise a default name is
given, SN, where N is slider number
in order of creation.
vert: vertical slider (True), else horiz.
linear: linear response (True), else exponential (zero or negative
ranges are not allowed)
dwid: display width in pixels
label: if given, the alternative slider name, for display only
returns the widget instance"""
self.slids = self.slids + 1
if title == "":
title = "S%d" % self.slids
a = end - start
if vert:
step = a / y
adj = gtk.Adjustment(init, start, end, step, step, 0)
slider = gtk.VScale(adj)
slider.set_inverted(True)
else:
step = a / x
adj = gtk.Adjustment(init, start, end, step, step, 0)
slider = gtk.HScale(adj)
slider.set_draw_value(False)
if step < 1.0:
slider.set_digits(3)
elif step < 10:
slider.set_digits(2)
elif step < 100:
slider.set_digits(1)
else:
slider.set_digits(0)
entry = gtk.Entry(5)
if vert: entry.set_size_request(dwid, 50)
else: entry.set_size_request(dwid, 50)
entry.set_editable(False)
if not linear:
if (init <= 0) or (start <= 0) or (end <= 0):
linear = True
if not linear:
pos = end * math.log(1, end / start)
slider.set_range(pos, end)
pos = end * math.log(init / start, end / start)
slider.set_value(pos)
if label == "": name = title
else: name = label
entry.set_text("%f" % init)
label = gtk.Label(name)
slider.set_size_request(x, y)
box.pack_start(slider, False, False, 5)
box.pack_start(entry, False, False, 2)
box.pack_start(label, False, False, 2)
self.sliders.append([slider, title, init, entry, linear, start, end])
adj.connect("value_changed", self.slidcallback, slider)
slider.show()
entry.show()
label.show()
self.set_channel(title, init)
return slider
def __init__( self, label, mini ):
Palette.__init__( self, label )
self.connect('popup', self.handlePopup)
self.connect('popdown', self.handlePopdown)
self.mini = mini
self.tooltips = gtk.Tooltips()
self.loopedSound = False
self.soundLength = 1.00
self.start = 0
self.end = 1.00
self.dur = 0.01
self.volume = 1
self.register = 0
self.ok = True
self.mainBox = gtk.VBox()
self.controlsBox = gtk.HBox()
self.GUI = {}
self.soundBox = gtk.HBox()
self.soundLabel = gtk.Label(_('Sound: '))
self.soundMenuBox = BigComboBox()
self.sounds = os.listdir(Config.DATA_DIR)
for sound in self.sounds:
self.soundMenuBox.append_item(self.sounds.index(sound), sound)
self.soundMenuBox.connect('changed', self.handleSound)
self.soundBox.pack_start(self.soundLabel, False, False, padding=10)
self.soundBox.pack_start(self.soundMenuBox, False, False, padding=10)
self.mainBox.pack_start(self.soundBox, False, False, 10)
nameBox = gtk.VBox()
self.nameEntry = gtk.Entry()
entrycolor = gtk.gdk.Color()
self.nameEntry.modify_text(gtk.STATE_NORMAL, entrycolor)
self.nameEntry.set_text("name_of_the_sound")
nameBox.pack_start(self.nameEntry)
self.mainBox.pack_start(nameBox, False, False, 10)
registerBox = gtk.HBox()
self.registerBoxLabel = gtk.Label(_('Register: '))
self.registerMenuBox = BigComboBox()
self.registers = ['LOW', 'MID', 'HIGH', 'PUNCH']
for reg in self.registers:
self.registerMenuBox.append_item(self.registers.index(reg), reg)
self.registerMenuBox.connect('changed', self.handleRegister)
registerBox.pack_start(self.registerBoxLabel, False, False, padding=10)
registerBox.pack_end(self.registerMenuBox, False, False, padding=10)
self.mainBox.pack_start(registerBox, False, False, 10)
loopedBox = gtk.HBox()
loopedLabel = gtk.Label("Looped sound: ")
loopedToggle = ImageToggleButton('checkOff.png', 'checkOn.png')
loopedToggle.connect('button-press-event', self.handleLooped )
loopedBox.pack_start(loopedLabel, False, False, padding=10)
loopedBox.pack_end(loopedToggle, False, False, padding=10)
self.mainBox.pack_start(loopedBox, False, False, 10)
startBox = gtk.VBox()
self.startAdjust = gtk.Adjustment( 0.01, 0, 1., .001, .001, 0)
self.GUI['startSlider'] = gtk.VScale( adjustment = self.startAdjust )
self.startAdjust.connect("value-changed", self.handleStart)
self.GUI['startSlider'].set_inverted(True)
self.GUI['startSlider'].set_size_request(50, 200)
self.GUI['startSlider'].set_digits(3)
self.handleStart( self.startAdjust )
startBox.pack_start(self.GUI['startSlider'], True, True, 5)
self.controlsBox.pack_start(startBox)
endBox = gtk.VBox()
self.endAdjust = gtk.Adjustment( 0.9, 0, 1, .001, .001, 0)
self.GUI['endSlider'] = gtk.VScale( adjustment = self.endAdjust )
self.endAdjust.connect("value-changed", self.handleEnd)
self.GUI['endSlider'].set_inverted(True)
self.GUI['endSlider'].set_size_request(50, 200)
self.GUI['endSlider'].set_digits(3)
self.handleEnd( self.endAdjust )
endBox.pack_start(self.GUI['endSlider'], True, True, 5)
self.controlsBox.pack_start(endBox)
durBox = gtk.VBox()
self.durAdjust = gtk.Adjustment( 0.01, 0, 0.2, .001, .001, 0)
self.GUI['durSlider'] = gtk.VScale( adjustment = self.durAdjust )
self.durAdjust.connect("value-changed", self.handleDur)
self.GUI['durSlider'].set_inverted(True)
self.GUI['durSlider'].set_size_request(50, 200)
self.GUI['durSlider'].set_digits(3)
self.handleDur( self.durAdjust )
durBox.pack_start(self.GUI['durSlider'], True, True, 5)
self.controlsBox.pack_start(durBox)
volBox = gtk.VBox()
self.volAdjust = gtk.Adjustment( 1, 0, 2, .01, .01, 0)
self.GUI['volSlider'] = gtk.VScale( adjustment = self.volAdjust )
self.volAdjust.connect("value-changed", self.handleVol)
self.GUI['volSlider'].set_inverted(True)
self.GUI['volSlider'].set_size_request(50, 200)
self.GUI['volSlider'].set_digits(3)
self.handleVol( self.volAdjust )
volBox.pack_start(self.GUI['volSlider'], True, True, 5)
self.controlsBox.pack_start(volBox)
self.mainBox.pack_start(self.controlsBox, False, False, 10)
previewBox = gtk.VBox()
self.playStopButton = ImageToggleButton('miniplay.png', 'stop.png')
self.playStopButton.connect('button-press-event' , self.handlePlayButton)
previewBox.pack_start(self.playStopButton)
self.mainBox.pack_start(previewBox, False, False, 10)
checkBox = gtk.VBox()
checkButton = ImageButton(Config.TAM_TAM_ROOT + '/icons/accept.svg')
checkButton.connect('clicked' , self.handleCheck)
checkBox.pack_start(checkButton)
self.mainBox.pack_start(checkBox, False, False, 10)
self.mainBox.show_all()
self.set_content(self.mainBox)
def __init__(self):
GetSettings()
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_resizable(True)
self.window.connect("destroy", self.destroy_equalizer)
self.window.set_title(windowtitle + " [" + realstatus + "]")
self.window.set_border_width(0)
icon_theme = gtk.icon_theme_get_default()
icon_theme = gtk.icon_theme_get_default()
if icon_theme.has_icon("multimedia-volume-control"):
icon = icon_theme.load_icon("multimedia-volume-control", 16, 0)
self.window.set_icon(icon)
elif icon_theme.has_icon("gnome-volume-control"):
icon = icon_theme.load_icon("gnome-volume-control", 16, 0)
self.window.set_icon(icon)
elif icon_theme.has_icon("stock_volume"):
icon = icon_theme.load_icon("stock_volume", 16, 0)
self.window.set_icon(icon)
else:
print("No icon found, window will be iconless")
menu = gtk.Menu()
menu_item = gtk.MenuItem('Reset to defaults')
menu_item.connect("activate", self.on_resetsettings)
menu.append(menu_item)
menu_item.show()
menu_item = gtk.MenuItem('Remove user preset...')
menu_item.connect("activate", self.on_removepreset)
menu.append(menu_item)
menu_item.show()
root_menu = gtk.MenuItem("Advanced")
root_menu.show()
root_menu.set_submenu(menu)
vbox1 = gtk.VBox(False, 0)
self.window.add(vbox1)
vbox1.show()
menu_bar = gtk.MenuBar()
vbox1.pack_start(menu_bar, False, False, 2)
menu_bar.show()
menu_bar.append(root_menu)
hbox1 = gtk.HBox(False, 1)
#hbox1.set_border_width(10)
vbox1.add(hbox1)
hbox1.show()
table = gtk.Table(3, 17, False)
table.set_border_width(5)
hbox1.add(table)
# Preamp widget
global preampscale
global preampscalevalue
preampscale = gtk.VScale()
preampscale.set_draw_value(0)
preampscale.set_inverted(1)
preampscale.set_value_pos(gtk.POS_BOTTOM)
preampscale.set_range(0.0, 2.0)
preampscale.set_increments(1, 0.1)
preampscale.set_digits(1)
preampscale.set_size_request(35, 200)
preampscale.set_value(float(preamp))
preampscale.connect("value-changed", self.on_preampscale)
label = gtk.Label()
label.set_markup("<small>Preamp</small>")
preampscalevalue = gtk.Label()
preampscalevalue.set_markup(str(preampscale.get_value()) + "x")
table.attach(label, 1, 2, 0, 1)
table.attach(preampscale, 1, 2, 1, 2)
table.attach(preampscalevalue, 1, 2, 2, 3)
#label.show()
#preampscale.show()
#preampscalevalue.show()
# Separator between preamp and bands
separator = gtk.VSeparator()
table.attach(separator, 2, 3, 1, 2)
#separator.show()
# Equalizer bands
global scale
self.scales = {}
self.labels = {}
self.scalevalues = {}
for x in range(1, num_ladspa_controls + 1):
scale = gtk.VScale()
self.scales[x] = scale
scale.set_draw_value(0)
scale.set_inverted(1)
scale.set_value_pos(gtk.POS_BOTTOM)
scale.set_range(float(ranges[0]), float(ranges[1]))
scale.set_increments(1, 0.1)
scale.set_digits(1)
scale.set_size_request(35, 200)
scale.set_value(float(ladspa_controls[x - 1]))
scale.connect("value-changed", self.on_scale, x)
FormatLabels(x)
label = gtk.Label()
self.labels[x] = label
label.set_markup("<small>" + whitespace1 + c + "\n" + whitespace2 +
suffix + "</small>")
scalevalue = gtk.Label()
self.scalevalues[x] = scalevalue
scalevalue.set_markup("<small>" + str(scale.get_value()) +
"\ndB</small>")
table.attach(label, x + 2, x + 3, 0, 1)
table.attach(scale, x + 2, x + 3, 1, 2)
table.attach(scalevalue, x + 2, x + 3, 2, 3)
label.show()
scale.show()
scalevalue.show()
table.show()
vbox2 = gtk.VBox(True, 1)
vbox2.set_border_width(10)
hbox1.add(vbox2)
vbox2.show()
presetslabel = gtk.Label()
presetslabel.set_markup("<small>Preset:</small>")
vbox2.pack_start(presetslabel, False, False, 0)
presetslabel.show()
global presetsbox
presetsbox = gtk.combo_box_entry_new_text()
vbox2.pack_start(presetsbox, False, False, 0)
presetsbox.get_child().set_text(preset)
for i in range(len(rawpresets)):
presetsbox.append_text(rawpresets[i])
presetsbox.connect("changed", self.on_presetsbox, x)
presetsbox.show()
savepreset = gtk.Button('Save Preset')
vbox2.pack_start(savepreset, False, False, 0)
savepreset.connect("clicked", self.on_savepreset)
savepreset.show()
global eqenabled
eqenabled = gtk.CheckButton("EQ Enabled")
eqenabled.set_active(status)
eqenabled.unset_flags(gtk.CAN_FOCUS)
eqenabled.connect("clicked", self.on_eqenabled)
vbox2.pack_start(eqenabled, False, False, 0)
eqenabled.show()
global keepsettings
keepsettings = gtk.CheckButton('Keep Settings')
keepsettings.set_active(persistence)
keepsettings.unset_flags(gtk.CAN_FOCUS)
keepsettings.connect("clicked", self.on_keepsettings)
vbox2.pack_start(keepsettings, False, False, 0)
keepsettings.show()
applysettings = gtk.Button('Apply Settings')
vbox2.pack_start(applysettings, False, False, 0)
applysettings.connect("clicked", self.on_applysettings)
applysettings.show()
quitbutton = gtk.Button('Quit')
vbox2.pack_start(quitbutton, False, False, 0)
quitbutton.connect("clicked", lambda w: gtk.main_quit())
quitbutton.show()
separator = gtk.HSeparator()
vbox2.pack_start(separator, False, False, 0)
separator.set_size_request(100, 10)
#separator.show()
self.window.show()
def __init__(self,
channel,
option_mask,
option_value,
show_value,
card_index,
label=None):
"""
Create a volume control widget
'channel' specifies the audio device mixer channel.
'option_mask' configures the widget while 'option_value' sets the actual
value of the corresponding mask (e.g. 'option_mask |= _MUTE' shows the mute
checkbox while 'option_value |= _MUTE' causes it to be checked by default)
'show_value' controls whether the volume text is displayed or not.
'card_index' is the index of the sound card
'label' is the name of the channel (e.g. 'PCM).
The widget supports two signals 'volume_changed' and 'volume_setting_toggled'.
'volume_changed' always sends left and right volume settings
regardless of whether the control is locked or mono.
'volume_setting_toggled' notifies the parent of changes
in the optional checkboxes.
"""
gtk.Frame.__init__(self, label)
self.card_index = card_index
self.rec = self.lock = self.stereo = self.mute = False
if option_mask & _LOCK:
self.lock = True
self.channel_locked = option_value & _LOCK
if option_mask & _REC:
self.rec = True
self.channel_rec = option_value & _REC
if option_mask & _MUTE:
self.mute = True
self.channel_muted = option_value & _MUTE
if option_mask & _STEREO:
self.stereo = True
self.channel = channel
self.vol_left = self.vol_right = 0
vbox = gtk.VBox()
control_box = gtk.HBox(True, 0)
option_box = gtk.HBox(True, 0)
align = gtk.Alignment(xscale=1, yscale=1)
align.set_padding(5, 5, 5, 5)
self.set_label_align(0.5, 0.8)
align.add(vbox)
self.add(align)
self.volume1 = gtk.Adjustment(0.0, 0.0, 100.0, 1.0, 10.0, 0.0)
if self.stereo:
self.volume1_handler_id = self.volume1.connect(
'value_changed', self.value_changed, channel, CHANNEL_LEFT,
card_index)
else:
self.volume1_handler_id = self.volume1.connect(
'value_changed', self.value_changed, channel, CHANNEL_MONO,
card_index)
volume1_control = gtk.VScale(self.volume1)
volume1_control.set_inverted(True)
volume1_control.set_draw_value(show_value)
volume1_control.set_digits(0)
volume1_control.set_size_request(-1, 250)
volume1_control.set_value_pos(gtk.POS_TOP)
control_box.pack_start(volume1_control, True, True)
if self.stereo:
self.volume2 = gtk.Adjustment(0.0, 0.0, 100.0, 1.0, 10.0, 0.0)
self.volume2_handler_id = self.volume2.connect(
'value_changed', self.value_changed, channel, CHANNEL_RIGHT,
card_index)
volume2_control = gtk.VScale(self.volume2)
volume2_control.set_inverted(True)
volume2_control.set_draw_value(show_value)
volume2_control.set_digits(0)
volume2_control.set_size_request(-1, 300)
volume2_control.set_value_pos(gtk.POS_TOP)
control_box.pack_start(volume2_control, True, True)
if self.rec:
self.rec_element = self.toggle_element(self.channel_rec, channel,
_REC)
option_box.pack_start(self.rec_element, False, False)
if self.mute:
mute_element = self.toggle_element(self.channel_muted, channel,
_MUTE)
option_box.pack_start(mute_element, False, False)
if self.stereo and self.lock:
lock_element = self.toggle_element(self.channel_locked, channel,
_LOCK)
option_box.pack_start(lock_element, False, False)
self.control1 = volume1_control
if self.stereo:
self.control2 = volume2_control
vbox.pack_start(control_box, True, True)
vbox.pack_start(option_box, False, False, 5)
self.show_all()
