def __init__(self):
Widget.__init__(self)
self.set_widget(gtk.VolumeButton())
self.wrapped_widget_connect('value-changed', self.on_value_changed)
self._widget.get_popup().connect("hide", self.on_hide)
self.create_signal('changed')
self.create_signal('released')
def __init__(self, vertical = False):
gtk.Box.__init__(self)
builder = gtk.Builder()
guifile=get_ui_path('audiobarv.glade')
builder.add_from_file(guifile)
self.bar = builder.get_object("audiobar")
box = builder.get_object("vbox")
self.volume = gtk.VolumeButton()
self.volume.set_value(0.5)
box.pack_end(self.volume,False,True,0)
builder.connect_signals(self)
self.vumeter=builder.get_object("vumeter")
def __init__(self, gui):
super(PlayerSlot, self).__init__(1, 15, True)
self.gmgb_gui = gui
self.mediaPlayer = gmgbPlayer(self)
self.fb_needs_reload = False # workaround flag for gtk drag-drop bug
self.fb = gtk.FileChooserButton("select a audio file", backend=None)
self.fileFilter = gtk.FileFilter()
self.fileFilter.set_name("Audio Files")
self.fileFilter.add_pattern("*.ogg")
self.fileFilter.add_pattern("*.mp3")
self.fileFilter.add_pattern("*.wav")
self.fb.set_filter(self.fileFilter)
self.fb.connect("file-set", self.load_file)
#self.fb.connect("drag-motion",self.load_file_drag_motion)
#self.fb.connect("drag-leave",self.load_file_drag_leave)
self.attach(self.fb, 0, 4, 0, 1)
self.playButton = gtk.ToggleToolButton(gtk.STOCK_MEDIA_PLAY)
self.playButton.set_sensitive(False)
self.playButton.connect("toggled", self.toggle_play)
self.attach(self.playButton, 4, 5, 0, 1)
self.loopButton = gtk.ToggleToolButton(gtk.STOCK_UNDO)
self.loopButton.set_sensitive(False)
self.loopButton.connect("toggled", self.toggle_loop)
self.attach(self.loopButton, 5, 6, 0, 1)
self.playbackSlider = gtk.HScale()
self.playbackSlider.set_sensitive(False)
self.playbackSlider.set_draw_value(False)
self.playbackSlider.set_update_policy(gtk.UPDATE_DISCONTINUOUS)
self.playbackSlider_dragged = False
self.playbackSlider.connect("button-press-event",
self.slider_button_press)
self.playbackSlider.connect("button-release-event",
self.slider_button_release)
self.attach(self.playbackSlider, 6, 14, 0, 1)
self.volumeButton = gtk.VolumeButton()
self.volumeButton.set_sensitive(False)
self.volumeButton.connect("value-changed", self.volume_change)
self.attach(self.volumeButton, 14, 15, 0, 1)
def __init__(self, controls, on_hide_callback):
self.controls = controls
ChildTopWindow.__init__(self, "movie")
self.set_hide_on_escape(False)
self.on_hide_callback = on_hide_callback
self.layout = gtk.VBox(False)
self.drow = AdvancedDrawingArea(controls)
self.drow.action_function = on_hide_callback
self.set_resizable(True)
self.set_border_width(0)
self.layout.pack_start(self.drow, True)
self.text_label = gtk.Label("foobnix")
self.volume_button = gtk.VolumeButton()
self.volume_button.connect("value-changed", self.volume_changed)
line = gtk.HBox(False)
line.pack_start(
ImageButton(gtk.STOCK_FULLSCREEN, on_hide_callback,
_("Exit Fullscrean")), False)
line.pack_start(PlaybackControls(controls), False)
line.pack_start(controls.seek_bar_movie, True)
line.pack_start(gtk.SeparatorToolItem(), False)
line.pack_start(self.text_label, False)
line.pack_start(gtk.SeparatorToolItem(), False)
line.pack_start(self.volume_button, False)
self.layout.pack_start(line, False)
self.add(self.layout)
self.set_opacity(1)
def my_event(w, e):
if e.y > gtk.gdk.screen_height() - 50: #@UndefinedVariable
line.show()
else:
line.hide()
self.connect("motion-notify-event", my_event)
def __init__(self, exname, name, sizegroup):
gtk.VBox.__init__(self)
cfg.ConfigUtils.__dict__['__init__'](self, exname)
self.m_name = name
hbox = gu.bHBox(self)
hbox.set_spacing(gu.PAD_SMALL)
self.g_button = gtk.Button(
soundcard.instrument_names[self.get_int(self.m_name)])
self.g_button.connect('clicked', self.on_btnclick)
hbox.pack_start(self.g_button)
g = gtk.VolumeButton()
g.props.value = self.get_int('%s_volume' % name) / MAX_VOLUME
def ff(volumebutton, value):
self.set_int('%s_volume' % name, int(value * MAX_VOLUME))
g.connect('value-changed', ff)
hbox.pack_start(g, False)
self.g_menu = MidiInstrumentMenu(self.on_instrument_selected)
self.m_instrument = self.get_int('preferred_instrument')
hbox = gtk.HBox()
hbox.set_spacing(6)
self.pack_start(hbox)
def __init__(self, ui, sltv):
self.sltv = sltv
self.button = gtk.VolumeButton()
self.button.set_value(0.5)
self.button.connect("value-changed", self.set_volume)
def __init__(self, project, mainview):
"""
Creates a new instance of TimeLineBar
Parameters:
project -- reference to Project (Project.py).
mainview -- reference to MainApp (JokosherApp.py).
"""
gtk.HBox.__init__(self)
self.project = project
self.mainview = mainview
self.timeline = TimeLine.TimeLine(self.project, mainview)
self.Updating = False
# add click / bpm / signature box
self.clickbutton = gtk.VolumeButton()
self.clickbutton.set_value(0)
self.clickbutton.set_relief(gtk.RELIEF_NORMAL)
self.clickbutton.set_property("size", gtk.ICON_SIZE_BUTTON)
self.clickbutton_metronome_image = gtk.Image()
self.clickbutton_metronome_image.set_from_file(
os.path.join(Globals.IMAGE_PATH, "icon_click.png"))
# use get_child() not get_image here because GtkScaleButton
# uses gtk_container_add() in its internal implementation
self.clickbutton_volume_image = self.clickbutton.get_child()
self.clickbutton.set_image(self.clickbutton_metronome_image)
image_size_group = gtk.SizeGroup(gtk.SIZE_GROUP_BOTH)
image_size_group.add_widget(self.clickbutton_metronome_image)
image_size_group.add_widget(self.clickbutton_volume_image)
self.clickbutton.set_tooltip_text(_("Adjust volume of click track"))
self.bpmeventbox = gtk.EventBox()
self.bpmframe = gtk.Frame()
self.bpmeventbox.set_tooltip_text(_("Beats per minute"))
self.bpmframe.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.bpmlabel = gtk.Label()
self.bpmlabel.set_use_markup(True)
self.bpmlabel.set_markup("<b>%s</b>" % (self.project.bpm))
self.bpmlabel.set_padding(5, 5)
self.bpmeventbox.add(self.bpmlabel)
self.bpmframe.add(self.bpmeventbox)
self.bpmedit = gtk.SpinButton()
self.bpmedit.set_range(1, 400)
self.bpmedit.set_increments(1, 5)
self.bpmedit.set_value(self.project.bpm)
self.bpmedit.connect("activate", self.OnAcceptEditBPM)
self.bpmedit.connect("key_press_event", self.OnEditBPMKey)
self.bpmedit.connect_after("button-release-event", self.OnEditBPMClick)
self.sigeventbox = gtk.EventBox()
self.sigeventbox.set_tooltip_text(_("Time signature"))
self.sigframe = gtk.Frame()
self.sigframe.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
self.siglabel = gtk.Label()
self.siglabel.set_use_markup(True)
self.siglabel.set_markup(
"<b>%d/%d</b>" %
(self.project.meter_nom, self.project.meter_denom))
self.siglabel.set_padding(5, 5)
self.sigeventbox.add(self.siglabel)
self.sigframe.add(self.sigeventbox)
self.sigeditPacked = False
# set events
self.clickbutton.connect("value-changed", self.OnClickTrackVolume)
self.clickbutton.connect("enter_notify_event", self.OnClickButtonEnter)
self.clickbutton.connect("leave_notify_event", self.OnClickButtonEnter)
self.bpmeventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.bpmeventbox.connect("button_release_event", self.OnEditBPM)
self.bpmeventbox.connect("enter_notify_event", self.OnMouseMoveBPM)
self.bpmeventbox.connect("leave_notify_event", self.OnMouseMoveBPM)
self.sigeventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK)
self.sigeventbox.connect("button_press_event", self.OnEditSig)
self.sigeventbox.connect("enter_notify_event", self.OnMouseMoveTimeSig)
self.sigeventbox.connect("leave_notify_event", self.OnMouseMoveTimeSig)
self.project.connect("bpm", self.OnProjectBPMChange)
self.project.connect("time-signature", self.OnProjectSigChange)
self.project.connect("click-track", self.OnProjectClickTrackChange)
self.sigDialog = None
# ###########################################################
self.headerhbox = gtk.HBox()
self.headerhbox.set_border_width(2)
self.headerhbox.set_spacing(5)
self.headerhbox.pack_start(self.clickbutton, True, True)
self.headerhbox.pack_start(self.bpmframe, True, True)
self.headerhbox.pack_start(self.sigframe, True, True)
self.headerVBox = gtk.VBox()
self.headerVBox.pack_start(self.headerhbox, True, True)
self.headerVBox.pack_start(gtk.HSeparator(), False, False)
self.timelineVBox = gtk.VBox()
self.timelineVBox.pack_start(self.timeline, True, True)
separator = EventLaneHSeparator.EventLaneHSeparator(
self.project, self.project.transport)
self.timelineVBox.pack_start(separator, False, False)
self.pack_start(self.headerVBox, False, False)
self.pack_start(self.timelineVBox)
def build_widget(self):
vbox = gtk.VBox()
self.player = self.controller.playerfactory.get_player()
self.player.sound_mute()
self.drawable = gtk.Socket()
def handle_remove(socket):
# Do not kill the widget if the application exits
return True
self.drawable.connect('plug-removed', handle_remove)
black = gtk.gdk.Color(0, 0, 0)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL, gtk.STATE_SELECTED,
gtk.STATE_INSENSITIVE, gtk.STATE_PRELIGHT):
self.drawable.modify_bg(state, black)
self.drawable.set_size_request(320, 200)
self.toolbar = gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
# Append the volume control to the toolbar
def volume_change(scale, value):
if self.player.sound_get_volume() != int(value * 100):
self.player.sound_set_volume(int(value * 100))
return True
self.audio_volume = gtk.VolumeButton()
self.audio_volume.set_value(self.player.sound_get_volume() / 100.0)
ti = gtk.ToolItem()
ti.add(self.audio_volume)
self.audio_volume.connect('value-changed', volume_change)
self.toolbar.insert(ti, -1)
sync_button = gtk.ToolButton(gtk.STOCK_CONNECT)
sync_button.set_tooltip_text(_("Synchronize"))
sync_button.connect('clicked', self.synchronize)
self.toolbar.insert(sync_button, -1)
def offset_changed(spin):
self.offset = long(spin.get_value())
return True
ti = gtk.ToolItem()
self.offset_spin = gtk.SpinButton(
gtk.Adjustment(value=self.offset,
lower=-24 * 60 * 60 * 1000,
upper=24 * 60 * 60 * 1000,
step_incr=1000 /
config.data.preferences['default-fps'],
page_incr=1000))
self.offset_spin.get_adjustment().connect('value-changed',
offset_changed)
ti.add(self.offset_spin)
self.offset_spin.set_tooltip_text(_("Offset in ms"))
self.toolbar.insert(ti, -1)
self.label = gtk.Label()
self.label.set_alignment(0, 0)
self.label.modify_font(pango.FontDescription("sans 10"))
timestamp_button = get_pixmap_button('set-to-now.png')
timestamp_button.set_tooltip_text(
_("Drag and drop to get player time"))
enable_drag_source(
timestamp_button,
lambda: long(self.player.get_stream_information().position),
self.controller)
# Cannot use a gtk.ToolButton since it cannot be drag_source
ti = gtk.ToolItem()
ti.add(timestamp_button)
self.toolbar.insert(ti, -1)
black = gtk.gdk.color_parse('black')
white = gtk.gdk.color_parse('white')
eb = gtk.EventBox()
eb.add(self.label)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL, gtk.STATE_SELECTED,
gtk.STATE_INSENSITIVE, gtk.STATE_PRELIGHT):
self.label.modify_bg(state, black)
eb.modify_bg(state, black)
self.label.modify_fg(state, white)
vbox.add(self.drawable)
vbox.pack_start(eb, expand=False)
vbox.pack_start(self.toolbar, expand=False)
self.drawable.connect_after('realize', self.register_drawable)
# Accept annotation/timestamp drop, to adjust time offset
vbox.connect('drag-data-received', self.drag_received_cb)
vbox.drag_dest_set(
gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT
| gtk.DEST_DEFAULT_ALL, config.data.drag_type['annotation'] +
config.data.drag_type['timestamp'],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_LINK | gtk.gdk.ACTION_MOVE)
vbox.show_all()
return vbox
def __init__(self, sink, config):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.set_title(NAME)
try:
self.set_icon(mygtk.iconfactory.get_icon("playitslowly", 128))
except gobject.GError:
print "could not load playitslowly icon"
self.set_default_size(500, 200)
self.set_border_width(5)
self.vbox = gtk.VBox()
self.accel_group = gtk.AccelGroup()
self.add_accel_group(self.accel_group)
self.pipeline = Pipeline(sink)
self.filedialog = mygtk.FileChooserDialog(None, self,
gtk.FILE_CHOOSER_ACTION_OPEN)
self.filedialog.connect("response", self.filechanged)
self.filedialog.set_local_only(False)
filechooserhbox = gtk.HBox()
self.filechooser = gtk.FileChooserButton(self.filedialog)
self.filechooser.set_local_only(False)
filechooserhbox.pack_start(self.filechooser, True, True)
self.recentbutton = gtk.Button(_("Recent"))
self.recentbutton.connect("clicked", self.show_recent)
filechooserhbox.pack_end(self.recentbutton, False, False)
self.speedchooser = mygtk.TextScaleReset(
gtk.Adjustment(1.00, 0.10, 4.0, 0.05, 0.05))
self.speedchooser.scale.connect("value-changed", self.speedchanged)
self.speedchooser.scale.connect("button-press-event", self.speedpress)
self.speedchooser.scale.connect("button-release-event",
self.speedrelease)
self.speedchangeing = False
self.pitchchooser = mygtk.TextScaleReset(
gtk.Adjustment(0.0, -24.0, 24.0, 1.0, 1.0, 1.0))
self.pitchchooser.scale.connect("value-changed", self.pitchchanged)
self.pitchchooser_fine = mygtk.TextScaleReset(
gtk.Adjustment(0.0, -50, 50, 1.0, 1.0, 1.0))
self.pitchchooser_fine.scale.connect("value-changed",
self.pitchchanged)
self.positionchooser = mygtk.ClockScale(gtk.Adjustment(
0.0, 0.0, 100.0))
self.positionchooser.scale.connect("button-press-event",
self.start_seeking)
self.positionchooser.scale.connect("button-release-event",
self.positionchanged)
self.seeking = False
self.startchooser = mygtk.TextScaleWithCurPos(
self.positionchooser, gtk.Adjustment(0.0, 0, 100.0))
self.startchooser.scale.connect("button-press-event",
self.start_seeking)
self.startchooser.scale.connect("button-release-event", self.seeked)
self.startchooser.add_accelerator("clicked", self.accel_group,
ord('['), gtk.gdk.CONTROL_MASK, ())
self.startchooser.add_accelerator("clicked", self.accel_group,
ord('['), 0, ())
self.endchooser = mygtk.TextScaleWithCurPos(
self.positionchooser, gtk.Adjustment(1.0, 0, 100.0, 0.01, 0.01))
self.endchooser.scale.connect("button-press-event", self.start_seeking)
self.endchooser.scale.connect("button-release-event", self.seeked)
self.endchooser.add_accelerator("clicked", self.accel_group, ord(']'),
gtk.gdk.CONTROL_MASK, ())
self.endchooser.add_accelerator("clicked", self.accel_group, ord(']'),
0, ())
self.vbox.pack_start(filechooserhbox)
self.vbox.pack_start(self.positionchooser)
self.vbox.pack_start(
mygtk.form([(_(u"Speed (times)"), self.speedchooser),
(_(u"Pitch (semitones)"), self.pitchchooser),
(_(u"Fine Pitch (cents)"), self.pitchchooser_fine),
(_(u"Start Position (seconds)"), self.startchooser),
(_(u"End Position (seconds)"), self.endchooser)]),
False, False)
buttonbox = gtk.HButtonBox()
self.vbox.pack_end(buttonbox, False, False)
self.play_button = gtk.ToggleButton(gtk.STOCK_MEDIA_PLAY)
self.play_button.connect("toggled", self.play)
self.play_button.set_use_stock(True)
self.play_button.set_sensitive(False)
buttonbox.pack_start(self.play_button)
# make SPACE a shortcut for play/pause (CTRL-SPC would be better?)
self.play_button.add_accelerator("clicked", self.accel_group, ord(' '),
0, ())
self.back_button = gtk.Button(gtk.STOCK_MEDIA_REWIND)
self.back_button.connect("clicked", self.back)
self.back_button.set_use_stock(True)
self.back_button.set_sensitive(False)
buttonbox.pack_start(self.back_button)
self.volume_button = gtk.VolumeButton()
self.volume_button.set_value(1.0)
self.volume_button.set_relief(gtk.RELIEF_NORMAL)
self.volume_button.connect("value-changed", self.volumechanged)
buttonbox.pack_start(self.volume_button)
self.save_as_button = gtk.Button(stock=gtk.STOCK_SAVE_AS)
self.save_as_button.connect("clicked", self.save)
self.save_as_button.set_sensitive(False)
buttonbox.pack_start(self.save_as_button)
button_about = gtk.Button(stock=gtk.STOCK_ABOUT)
button_about.connect("clicked", self.about)
buttonbox.pack_end(button_about)
self.connect("key-release-event", self.key_release)
self.add(self.vbox)
self.connect("destroy", gtk.main_quit)
self.config = config
self.config_saving = False
self.load_config()
