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()