Commit 9b161ed20f0bf928b40479a0f01565ff16f3784e

Kshitij Kumar
Sun Jan 13 01:36:13 EST 2013

Tree SHA1: e5b451e
Parent SHA1: 1dbdaaf (PyGI changes)
raw diff | raw patch

few more changes

Diff rendering mode:
inline
side by side


1	1	import gi
2		pygtk.require( '2.0' )
3		import gtk
	2	pyGtk.require( '2.0' )
4	3	from gi.repository import GObject
	4	from gi.repository import Gtk
5	5
6	6	from RythmGenerator import *
7	7	from common.Util.CSoundClient import new_csound_client
…	…
32	32
33	33	def setBeats( self, nbeats ):
34	34	if self.playBackTimeout != None:
35		gobject.source_remove( self.playBackTimeout )
	35	GObject.source_remove( self.playBackTimeout )
36	36
37	37	self.nbeats = nbeats
38	38	self.clear()
…	…
41	41	def setTempo( self, tempo ):
42	42	self.tempo = tempo
43	43	if self.playBackTimeout != None:
44		gobject.source_remove( self.playBackTimeout )
	44	GObject.source_remove( self.playBackTimeout )
45	45	self.play()
46	46
47	47	def setReverb( self, reverb ):
…	…
52	52
53	53	def play( self ):
54	54	if self.playBackTimeout == None:
55		self.playbackTimeout = gobject.timeout_add( int(60000/self.tempo/8), self.handleClock )
	55	self.playbackTimeout = GObject.timeout_add( int(60000/self.tempo/8), self.handleClock )
56	56	self.handleClock()
57	57
58	58	def stop( self ):
59	59	if self.playBackTimeout != None:
60		gobject.source_remove( self.playBackTimeout )
	60	GObject.source_remove( self.playBackTimeout )
61	61	self.clear()
62	62
63	63	def clear( self ):


1	1	import gi
2		pygtk.require( '2.0' )
	2	pyGtk.require( '2.0' )
3	3	from gi.repository import Gtk
4	4
5	5	import time
…	…
17	17	Tooltips = Config.Tooltips
18	18
19	19
20		class InstrumentPanel( gtk.EventBox ):
	20	class InstrumentPanel( Gtk.EventBox ):
21	21	def __init__(self,setInstrument=None):
22		gtk.EventBox.__init__(self)
	22	Gtk.EventBox.__init__(self)
23	23
24	24	self._scrolled_window = None
25	25
…	…
68	68	if Config.DEBUG > 4: print "InstrumentPanel load", self.loadStage
69	69
70	70	if self.loadStage[0] == 0:
71		color = gtk.gdk.color_parse(Config.PANEL_BCK_COLOR)
72		self.modify_bg(gtk.STATE_NORMAL, color)
	71	color = Gdk.color_parse(Config.PANEL_BCK_COLOR)
	72	self.modify_bg(Gtk.STATE_NORMAL, color)
73	73	self.loadStage[0] = 1
74	74	if timeout >= 0 and time.time() > timeout: return False
75	75
76	76	if self.loadStage[0] == 1:
77		self.tooltips = gtk.Tooltips()
	77	self.tooltips = Gtk.Tooltips()
78	78	self.loadStage[0] = 2
79	79	if timeout >= 0 and time.time() > timeout: return False
80	80
…	…
83	83	self.recstate = False
84	84	self.lastInstrumentWidget = None
85	85
86		self.mainVBox = gtk.VBox()
	86	self.mainVBox = Gtk.VBox()
87	87	self.loadStage[0] = 3
88	88	if timeout >= 0 and time.time() > timeout: return False
89	89
…	…
166	166
167	167	def loadToolbar( self, timeout = -1, loadStage = [0,0,0] ):
168	168	if loadStage[1] == 0:
169		self.toolbarBox = gtk.HBox()
	169	self.toolbarBox = Gtk.HBox()
170	170
171		scrollbox = HScrolledBox(scroll_policy=gtk.POLICY_NEVER)
	171	scrollbox = HScrolledBox(scroll_policy=Gtk.POLICY_NEVER)
172	172	scrollbox.set_viewport(self.toolbarBox)
173		scrollbox.modify_bg(gtk.STATE_NORMAL, style.Color(Config.PANEL_BCK_COLOR).get_gdk_color())
	173	scrollbox.modify_bg(Gtk.STATE_NORMAL, style.Color(Config.PANEL_BCK_COLOR).get_Gdk_color())
174	174	self.mainVBox.pack_start(scrollbox, False, False)
175	175
176	176	self.firstTbBtn = None
…	…
262	262	return True
263	263
264	264	def loadInstrumentViewport( self ):
265		self.instBox = gtk.Alignment(0.5, 0, 0, 1)
	265	self.instBox = Gtk.Alignment(0.5, 0, 0, 1)
266	266
267		box = gtk.EventBox()
268		color = gtk.gdk.color_parse(Config.INSTRUMENT_GRID_COLOR)
269		box.modify_bg(gtk.STATE_NORMAL, color)
	267	box = Gtk.EventBox()
	268	color = Gdk.color_parse(Config.INSTRUMENT_GRID_COLOR)
	269	box.modify_bg(Gtk.STATE_NORMAL, color)
270	270	box.add(self.instBox)
271	271
272		scrollwin = gtk.ScrolledWindow()
273		scrollwin.set_policy(gtk.POLICY_NEVER,gtk.POLICY_AUTOMATIC)
	272	scrollwin = Gtk.ScrolledWindow()
	273	scrollwin.set_policy(Gtk.POLICY_NEVER,Gtk.POLICY_AUTOMATIC)
274	274	scrollwin.add_with_viewport(box)
275		box.get_parent().set_shadow_type(gtk.SHADOW_NONE)
	275	box.get_parent().set_shadow_type(Gtk.SHADOW_NONE)
276	276	self.mainVBox.pack_end(scrollwin, True, True, 0)
277	277
278	278	self.show_all()
…	…
300	300	if instrumentNum % cols is not 0: #S'il y a un reste
301	301	rows = rows + 1
302	302
303		self.instTable = gtk.Table(rows,cols,True)
	303	self.instTable = Gtk.Table(rows,cols,True)
304	304	self.instTable.set_row_spacings(0)
305	305	self.instTable.set_col_spacings(0)
306	306
…	…
311	311	break
312	312	inst = instruments[i]
313	313	if self.instDic.has_key(inst):
314		self.instTable.attach(self.instDic[inst], col, col+1, row, row+1, gtk.SHRINK, gtk.SHRINK, 0, 0)
	314	self.instTable.attach(self.instDic[inst], col, col+1, row, row+1, Gtk.SHRINK, Gtk.SHRINK, 0, 0)
315	315
316	316	self.instBox.add(self.instTable)
317	317	self.instTable.show_all()
…	…
326	326	def handleInstrumentButtonClick(self,widget,instrument):
327	327	if widget.get_active() is True and self.recstate == False:
328	328	if self.setInstrument:
329		widget.event( gtk.gdk.Event( gtk.gdk.LEAVE_NOTIFY ) ) # fake the leave event
	329	widget.event( Gdk.Event( Gdk.LEAVE_NOTIFY ) ) # fake the leave event
330	330	self.setInstrument(instrument)
331	331	time.sleep(0.05)
332	332	if self.playInstrument: self.playInstrument(instrument)
…	…
341	341	if self._scrolled_window is None:
342	342	parent = widget.parent
343	343	while parent is not None:
344		if isinstance(parent, gtk.ScrolledWindow):
	344	if isinstance(parent, Gtk.ScrolledWindow):
345	345	self._scrolled_window = parent
346	346	break
347	347	parent = parent.parent
…	…
377	377	btn.handler_unblock(btn.clickedHandler)
378	378
379	379
380		class DrumPanel( gtk.EventBox ):
	380	class DrumPanel( Gtk.EventBox ):
381	381	def __init__(self, setDrum = None):
382		gtk.EventBox.__init__(self)
383		color = gtk.gdk.color_parse(Config.PANEL_BCK_COLOR)
384		self.modify_bg(gtk.STATE_NORMAL, color)
	382	Gtk.EventBox.__init__(self)
	383	color = Gdk.color_parse(Config.PANEL_BCK_COLOR)
	384	self.modify_bg(Gtk.STATE_NORMAL, color)
385	385
386	386	self.setDrum = setDrum
387	387	self.instrumentList = []
…	…
413	413	def setDrums(self,widget,data):
414	414	if widget.get_active():
415	415	if self.setDrum:
416		widget.event( gtk.gdk.Event( gtk.gdk.LEAVE_NOTIFY ) ) # fake the leave event
	416	widget.event( Gdk.Event( Gdk.LEAVE_NOTIFY ) ) # fake the leave event
417	417	self.setDrum(data)
418	418
419	419	def set_activeInstrument( self, instrument, state ):
…	…
424	424	btn.handler_unblock(btn.clickedHandler)
425	425
426	426	if __name__ == "__main__":
427		win = gtk.Window()
	427	win = Gtk.Window()
428	428	wc = DrumPanel(None)
429	429	win.add(wc)
430	430	win.show()
431		#start the gtk event loop
432		gtk.main()
	431	#start the Gtk event loop
	432	Gtk.main()


1	1	import gi
2		pygtk.require( '2.0' )
	2	pyGtk.require( '2.0' )
3	3	from gi.repository import Gtk
4	4
5	5	import common.Config as Config
…	…
102	102	playkey(36,100, self.instrumentDB.instNamed[instrumentName].kit[pitch])
103	103
104	104	else:
105		if event.get_state() == gtk.gdk.MOD1_MASK:
	105	if event.get_state() == Gdk.MOD1_MASK:
106	106	pitch += 5
107	107
108	108	instrument = self.instrumentDB.instNamed[ instrumentName ]


1	1	import gi
2		pygtk.require( '2.0' )
	2	pyGtk.require( '2.0' )
3	3	from gi.repository import Gtk
4	4	from gi.repository import GObject
5	5	import time
…	…
31	31
32	32	def setTempo( self, tempo ):
33	33	self.tempo = tempo
34		gobject.source_remove( self.playBackTimeout )
	34	GObject.source_remove( self.playBackTimeout )
35	35	self.playState = 0
36	36
37	37	def handleRecordButton( self, widget, data=None ):
…	…
63	63
64	64	def startPlayback( self ):
65	65	if not self.playState:
66		self.playbackTimeout = gobject.timeout_add( int(60000/self.tempo/12), self.handleClock )
	66	self.playbackTimeout = GObject.timeout_add( int(60000/self.tempo/12), self.handleClock )
67	67	self.handleClock()
68	68	self.playState = 1
69	69
70	70	def stopPlayback( self ):
71	71	if self.playbackTimeout != None:
72		gobject.source_remove( self.playbackTimeout )
	72	GObject.source_remove( self.playbackTimeout )
73	73	self.playbackTimeout = None
74	74	self.playState = 0
75	75


1	1	import gi
2		pygtk.require( '2.0' )
	2	pyGtk.require( '2.0' )
3	3	from gi.repository import Gtk
4	4	from gi.repository import GObject
5	5	import os
…	…
43	43
44	44	Tooltips = Config.Tooltips
45	45
46		class miniTamTamMain(gtk.EventBox):
	46	class miniTamTamMain(Gtk.EventBox):
47	47
48	48	def __init__(self, activity):
49		gtk.EventBox.__init__(self)
	49	Gtk.EventBox.__init__(self)
50	50
51	51	self.instrumentPanel = None
52	52	self.activity = activity
…	…
89	89	self.csnd.setMasterVolume(self.volume)
90	90	self.sequencer.beat = self.beat
91	91	self.loop.beat = self.beat
92		self.tooltips = gtk.Tooltips()
	92	self.tooltips = Gtk.Tooltips()
93	93
94		self.mainWindowBox = gtk.HBox()
95		self.leftBox = gtk.VBox()
96		self.rightBox = gtk.VBox()
	94	self.mainWindowBox = Gtk.HBox()
	95	self.leftBox = Gtk.VBox()
	96	self.rightBox = Gtk.VBox()
97	97	self.mainWindowBox.pack_start(self.rightBox, False, True)
98	98	self.mainWindowBox.pack_start(self.leftBox, True, True)
99	99	self.add(self.mainWindowBox)
…	…
131	131	#-- handle forced networking ---------------------------------------
132	132	if self.network.isHost():
133	133	self.updateSync()
134		self.syncTimeout = gobject.timeout_add( 1000, self.updateSync )
	134	self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
135	135	elif self.network.isPeer():
136	136	self.sendTempoQuery()
137		self.syncTimeout = gobject.timeout_add( 1000, self.updateSync )
	137	self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
138	138	#-------------------------------------------------------------------
139	139
140	140	# Toolbar
…	…
198	198	slidersBox = RoundVBox(fillcolor = Config.PANEL_COLOR, bordercolor = Config.PANEL_BCK_COLOR, radius = Config.PANEL_RADIUS)
199	199	slidersBox.set_border_width(Config.PANEL_SPACING)
200	200
201		geneSliderBox = gtk.VBox()
202		self.geneSliderBoxImgTop = gtk.Image()
	201	geneSliderBox = Gtk.VBox()
	202	self.geneSliderBoxImgTop = Gtk.Image()
203	203	self.geneSliderBoxImgTop.set_from_file(imagefile('complex6.png'))
204		self.geneAdjustment = gtk.Adjustment(value=self.regularity, lower=0, upper=1, step_incr=0.01, page_incr=0, page_size=0)
	204	self.geneAdjustment = Gtk.Adjustment(value=self.regularity, lower=0, upper=1, step_incr=0.01, page_incr=0, page_size=0)
205	205	self.geneSlider = ImageVScale('sliderbutbleu.png',
206	206	self.geneAdjustment, 5)
207	207	self.geneSlider.set_inverted(False)
…	…
211	211	geneSliderBox.pack_start(self.geneSlider, True, 20)
212	212	self.tooltips.set_tip(self.geneSlider,Tooltips.COMPL)
213	213
214		beatSliderBox = gtk.VBox()
215		self.beatSliderBoxImgTop = gtk.Image()
	214	beatSliderBox = Gtk.VBox()
	215	self.beatSliderBoxImgTop = Gtk.Image()
216	216	self.beatSliderBoxImgTop.set_from_file(imagefile('beat3.png'))
217		self.beatAdjustment = gtk.Adjustment(value=self.beat, lower=2,
	217	self.beatAdjustment = Gtk.Adjustment(value=self.beat, lower=2,
218	218	upper=12, step_incr=1, page_incr=0, page_size=0)
219	219	self.beatSlider = ImageVScale('sliderbutjaune.png',
220	220	self.beatAdjustment, 5, snap=1)
…	…
228	228	self.delayedTempo = 0 # used to store tempo updates while the slider is active
229	229	self.tempoSliderActive = False
230	230
231		tempoSliderBox = gtk.VBox()
232		self.tempoSliderBoxImgTop = gtk.Image()
	231	tempoSliderBox = Gtk.VBox()
	232	self.tempoSliderBoxImgTop = Gtk.Image()
233	233	self.tempoSliderBoxImgTop.set_from_file(imagefile('tempo5.png'))
234		self.tempoAdjustment = gtk.Adjustment(value=self.tempo, lower=Config.PLAYER_TEMPO_LOWER, upper=Config.PLAYER_TEMPO_UPPER, step_incr=1, page_incr=1, page_size=1)
	234	self.tempoAdjustment = Gtk.Adjustment(value=self.tempo, lower=Config.PLAYER_TEMPO_LOWER, upper=Config.PLAYER_TEMPO_UPPER, step_incr=1, page_incr=1, page_size=1)
235	235	tempoSlider = ImageVScale('sliderbutvert.png', self.tempoAdjustment, 5)
236	236	tempoSlider.set_inverted(True)
237	237	self.tempoAdjustmentHandler = self.tempoAdjustment.connect("value_changed" , self.handleTempoSliderChange)
…	…
241	241	tempoSliderBox.pack_start(tempoSlider, True)
242	242	self.tooltips.set_tip(tempoSlider,Tooltips.TEMPO)
243	243
244		volumeSliderBox = gtk.VBox()
245		self.volumeSliderBoxImgTop = gtk.Image()
	244	volumeSliderBox = Gtk.VBox()
	245	self.volumeSliderBoxImgTop = Gtk.Image()
246	246	self.volumeSliderBoxImgTop.set_from_file(imagefile('volume2.png'))
247		self.volumeAdjustment = gtk.Adjustment(value=self.volume, lower=0, upper=200, step_incr=1, page_incr=1, page_size=1)
	247	self.volumeAdjustment = Gtk.Adjustment(value=self.volume, lower=0, upper=200, step_incr=1, page_incr=1, page_size=1)
248	248	volumeSlider = ImageVScale('sliderbutbleu.png',
249	249	self.volumeAdjustment, 5)
250	250	volumeSlider.set_inverted(True)
…	…
255	255	self.tooltips.set_tip(volumeSlider,Tooltips.VOL)
256	256
257	257
258		slidersBoxSub = gtk.HBox()
	258	slidersBoxSub = Gtk.HBox()
259	259	slidersBoxSub.pack_start(beatSliderBox, True, True, 0)
260	260	slidersBoxSub.pack_start(geneSliderBox, True, True, 0)
261	261	slidersBoxSub.pack_start(tempoSliderBox, True, True, 0)
…	…
268	268	radius=Config.PANEL_RADIUS)
269	269	generateBtnSub.set_border_width(Config.PANEL_SPACING)
270	270
271		#playImg = gtk.Image()
272		#playImg.set_from_icon_name('media-playback-start', gtk.ICON_SIZE_LARGE_TOOLBAR)
	271	#playImg = Gtk.Image()
	272	#playImg.set_from_icon_name('media-playback-start', Gtk.ICON_SIZE_LARGE_TOOLBAR)
273	273	self.playButton = ImageToggleButton('miniplay.png', 'stop.png')
274		#self.playButton.set_relief(gtk.RELIEF_NONE)
	274	#self.playButton.set_relief(Gtk.RELIEF_NONE)
275	275	#self.playButton.set_image(playImg)
276	276	self.playButton.connect('clicked',self.handlePlayButton)
277	277	generateBtnSub.pack_start(self.playButton, True, True, 0)
…	…
289	289	bordercolor=Config.PANEL_BCK_COLOR,
290	290	radius=Config.PANEL_RADIUS)
291	291
292		drum_scroll = VScrolledBox(scroll_policy=gtk.POLICY_NEVER)
	292	drum_scroll = VScrolledBox(scroll_policy=Gtk.POLICY_NEVER)
293	293	drum_scroll.set_viewport(drum_box)
294		drum_scroll.modify_bg(gtk.STATE_NORMAL,
295		style.Color(Config.PANEL_BCK_COLOR).get_gdk_color())
	294	drum_scroll.modify_bg(Gtk.STATE_NORMAL,
	295	style.Color(Config.PANEL_BCK_COLOR).get_Gdk_color())
296	296	drum_i = 0
297	297	drum_group = None
298	298
299	299	for row in range(DRUMCOUNT/2 + DRUMCOUNT%2):
300		row_box = gtk.HBox()
	300	row_box = Gtk.HBox()
301	301	drum_box.pack_start(row_box, False)
302	302
303	303	for col in range(2):
…	…
351	351	self.instrumentPanel = InstrumentPanel()
352	352	self.leftBox.pack_start(self.instrumentPanel, True, True, 0)
353	353
354		width = gtk.gdk.screen_width() - self.rightBox.get_size_request()[0]
	354	width = Gdk.screen_width() - self.rightBox.get_size_request()[0]
355	355	self.instrumentPanel.configure(self.setInstrument,
356	356	self.playInstrumentNote, False, self.micRec, width=width)
357	357
…	…
360	360	def micRec(self, widget, mic):
361	361	self.csnd.inputMessage("i5600 0 4")
362	362	OS.arecord(4, "crop.csd", mic)
363		self.micTimeout = gobject.timeout_add(200, self.loadMicInstrument, mic)
	363	self.micTimeout = GObject.timeout_add(200, self.loadMicInstrument, mic)
364	364	self.instrumentPanel.set_activeInstrument(mic,True)
365	365	self.setInstrument(mic)
366	366
…	…
576	576
577	577	def enableKeyboard( self ):
578	578	self.keyboardStandAlone = KeyboardStandAlone( self.sequencer.recording, self.sequencer.adjustDuration, self.csnd.loopGetTick, self.sequencer.getPlayState, self.loop )
579		self.add_events(gtk.gdk.BUTTON_PRESS_MASK)
	579	self.add_events(Gdk.BUTTON_PRESS_MASK)
580	580
581	581	def setInstrument( self , instrument ):
582	582	self.instrument = instrument
…	…
673	673	self.activity._shared_activity.connect( "buddy-left", self.buddy_left )
674	674	self.network.setMode( Net.MD_HOST )
675	675	self.updateSync()
676		self.syncTimeout = gobject.timeout_add( 1000, self.updateSync )
	676	self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
677	677
678	678	def joined( self, activity ):
679	679	print "miniTamTam:: joined activity!!"
…	…
727	727	def networkStatusWatcher( self, mode ):
728	728	if mode == Net.MD_OFFLINE:
729	729	if self.syncTimeout:
730		gobject.source_remove( self.syncTimeout )
	730	GObject.source_remove( self.syncTimeout )
731	731	self.syncTimeout = None
732	732	if mode == Net.MD_PEER:
733	733	self.updateSync()
734	734	if not self.syncTimeout:
735		self.syncTimeout = gobject.timeout_add( 1000, self.updateSync )
	735	self.syncTimeout = GObject.timeout_add( 1000, self.updateSync )
736	736	self.sendTempoQuery()
737	737
738	738	def processHT_SYNC_REPLY( self, sock, message, data ):
…	…
828	828
829	829	if __name__ == "__main__":
830	830	MiniTamTam = miniTamTam()
831		#start the gtk event loop
832		gtk.main()
	831	#start the Gtk event loop
	832	Gtk.main()


10	10	from sugar3.graphics.palette import Palette
11	11	from gettext import gettext as _
12	12
13		class playToolbar(gtk.Toolbar):
	13	class playToolbar(Gtk.Toolbar):
14	14	def __init__(self, miniTamTam):
15		gtk.Toolbar.__init__(self)
	15	Gtk.Toolbar.__init__(self)
16	16
17	17	def _insertSeparator(x = 1):
18	18	for i in range(x):
19		self.separator = gtk.SeparatorToolItem()
	19	self.separator = Gtk.SeparatorToolItem()
20	20	self.separator.set_draw(True)
21	21	self.insert(self.separator,-1)
22	22	self.separator.show()
23	23
24	24	self.miniTamTam = miniTamTam
25	25
26		self.tooltips = gtk.Tooltips()
	26	self.tooltips = Gtk.Tooltips()
27	27
28		self.balanceSliderImgLeft = gtk.Image()
29		self.balanceSliderImgRight = gtk.Image()
	28	self.balanceSliderImgLeft = Gtk.Image()
	29	self.balanceSliderImgRight = Gtk.Image()
30	30	self.balanceSliderImgLeft.set_from_file(imagefile('dru2.png'))
31	31	self.balanceSliderImgRight.set_from_file(imagefile('instr2.png'))
32		self.balanceSliderImgLeftTool = gtk.ToolItem()
	32	self.balanceSliderImgLeftTool = Gtk.ToolItem()
33	33	self.balanceSliderImgLeftTool.add(self.balanceSliderImgLeft)
34		self.balanceSliderImgRightTool = gtk.ToolItem()
	34	self.balanceSliderImgRightTool = Gtk.ToolItem()
35	35	self.balanceSliderImgRightTool.add(self.balanceSliderImgRight)
36		self.balanceSliderAdj = gtk.Adjustment(value=50, lower=0, upper=100, step_incr=1, page_incr=0, page_size=0)
	36	self.balanceSliderAdj = Gtk.Adjustment(value=50, lower=0, upper=100, step_incr=1, page_incr=0, page_size=0)
37	37	self.balanceSliderAdj.connect("value_changed" , self.miniTamTam.handleBalanceSlider)
38		self.balanceSlider = gtk.HScale(adjustment = self.balanceSliderAdj)
	38	self.balanceSlider = Gtk.HScale(adjustment = self.balanceSliderAdj)
39	39	self.balanceSlider.set_size_request(250,15)
40	40	self.balanceSlider.set_inverted(False)
41	41	self.balanceSlider.set_draw_value(False)
42		self.balanceSliderTool = gtk.ToolItem()
	42	self.balanceSliderTool = Gtk.ToolItem()
43	43	self.balanceSliderTool.add(self.balanceSlider)
44	44	self.insert(self.balanceSliderImgLeftTool, -1)
45	45	self.insert(self.balanceSliderTool, -1)
…	…
54	54
55	55	_insertSeparator(1)
56	56
57		self.reverbSliderImgRight = gtk.Image()
	57	self.reverbSliderImgRight = Gtk.Image()
58	58	self.reverbSliderImgRight.set_from_file(imagefile('reverb0.png'))
59		self.reverbSliderImgRightTool = gtk.ToolItem()
	59	self.reverbSliderImgRightTool = Gtk.ToolItem()
60	60	self.reverbSliderImgRightTool.add(self.reverbSliderImgRight)
61	61
62		self.reverbSliderAdj = gtk.Adjustment(value=0.1, lower=0, upper=1, step_incr=0.1, page_incr=0, page_size=0)
	62	self.reverbSliderAdj = Gtk.Adjustment(value=0.1, lower=0, upper=1, step_incr=0.1, page_incr=0, page_size=0)
63	63	self.reverbSliderAdj.connect("value_changed" , self.miniTamTam.handleReverbSlider)
64		self.reverbSlider = gtk.HScale(adjustment = self.reverbSliderAdj)
	64	self.reverbSlider = Gtk.HScale(adjustment = self.reverbSliderAdj)
65	65	self.reverbSlider.set_size_request(250,15)
66	66	self.reverbSlider.set_inverted(False)
67	67	self.reverbSlider.set_draw_value(False)
68		self.reverbSliderTool = gtk.ToolItem()
	68	self.reverbSliderTool = Gtk.ToolItem()
69	69	self.reverbSliderTool.add(self.reverbSlider)
70	70	self.insert(self.reverbSliderTool, -1)
71	71	self.insert(self.reverbSliderImgRightTool, -1)
…	…
78	78	self.show_all()
79	79
80	80
81		class recordToolbar(gtk.Toolbar):
	81	class recordToolbar(Gtk.Toolbar):
82	82	def __init__(self, miniTamTam):
83		gtk.Toolbar.__init__(self)
	83	Gtk.Toolbar.__init__(self)
84	84
85	85	def _insertSeparator(x = 1):
86	86	for i in range(x):
87		self.separator = gtk.SeparatorToolItem()
	87	self.separator = Gtk.SeparatorToolItem()
88	88	self.separator.set_draw(True)
89	89	self.insert(self.separator,-1)
90	90	self.separator.show()
…	…
152	152
153	153	self.mini = mini
154	154
155		self.tooltips = gtk.Tooltips()
	155	self.tooltips = Gtk.Tooltips()
156	156	self.loopedSound = False
157	157	self.soundLength = 1.00
158	158	self.start = 0
…	…
162	162	self.register = 0
163	163	self.ok = True
164	164
165		self.mainBox = gtk.VBox()
	165	self.mainBox = Gtk.VBox()
166	166
167		self.controlsBox = gtk.HBox()
	167	self.controlsBox = Gtk.HBox()
168	168
169	169	self.GUI = {}
170	170
171		self.soundBox = gtk.HBox()
172		self.soundLabel = gtk.Label(_('Sound: '))
	171	self.soundBox = Gtk.HBox()
	172	self.soundLabel = Gtk.Label(_('Sound: '))
173	173	self.soundMenuBox = BigComboBox()
174	174	self.sounds = os.listdir(Config.DATA_DIR)
175	175	for sound in self.sounds:
…	…
180	180
181	181	self.mainBox.pack_start(self.soundBox, False, False, 10)
182	182
183		nameBox = gtk.VBox()
184		self.nameEntry = gtk.Entry()
185		entrycolor = gtk.gdk.Color()
186		self.nameEntry.modify_text(gtk.STATE_NORMAL, entrycolor)
	183	nameBox = Gtk.VBox()
	184	self.nameEntry = Gtk.Entry()
	185	entrycolor = Gdk.Color()
	186	self.nameEntry.modify_text(Gtk.STATE_NORMAL, entrycolor)
187	187	self.nameEntry.set_text("name_of_the_sound")
188	188	nameBox.pack_start(self.nameEntry, True, True, 0)
189	189	self.mainBox.pack_start(nameBox, False, False, 10)
190	190
191		registerBox = gtk.HBox()
192		self.registerBoxLabel = gtk.Label(_('Register: '))
	191	registerBox = Gtk.HBox()
	192	self.registerBoxLabel = Gtk.Label(_('Register: '))
193	193	self.registerMenuBox = BigComboBox()
194	194	self.registers = ['LOW', 'MID', 'HIGH', 'PUNCH']
195	195	for reg in self.registers:
…	…
199	199	registerBox.pack_end(self.registerMenuBox, False, False, padding=10)
200	200	self.mainBox.pack_start(registerBox, False, False, 10)
201	201
202		loopedBox = gtk.HBox()
203		loopedLabel = gtk.Label("Looped sound: ")
	202	loopedBox = Gtk.HBox()
	203	loopedLabel = Gtk.Label("Looped sound: ")
204	204	loopedToggle = ImageToggleButton('checkOff.png', 'checkOn.png')
205	205	loopedToggle.connect('button-press-event', self.handleLooped )
206	206	loopedBox.pack_start(loopedLabel, False, False, padding=10)
207	207	loopedBox.pack_end(loopedToggle, False, False, padding=10)
208	208	self.mainBox.pack_start(loopedBox, False, False, 10)
209	209
210		startBox = gtk.VBox()
211		self.startAdjust = gtk.Adjustment( 0.01, 0, 1., .001, .001, 0)
212		self.GUI['startSlider'] = gtk.VScale( adjustment = self.startAdjust )
	210	startBox = Gtk.VBox()
	211	self.startAdjust = Gtk.Adjustment( 0.01, 0, 1., .001, .001, 0)
	212	self.GUI['startSlider'] = Gtk.VScale( adjustment = self.startAdjust )
213	213	self.startAdjust.connect("value-changed", self.handleStart)
214	214	self.GUI['startSlider'].set_inverted(True)
215	215	self.GUI['startSlider'].set_size_request(50, 200)
…	…
218	218	startBox.pack_start(self.GUI['startSlider'], True, True, 5)
219	219	self.controlsBox.pack_start(startBox, True, True, 0)
220	220
221		endBox = gtk.VBox()
222		self.endAdjust = gtk.Adjustment( 0.9, 0, 1, .001, .001, 0)
223		self.GUI['endSlider'] = gtk.VScale( adjustment = self.endAdjust )
	221	endBox = Gtk.VBox()
	222	self.endAdjust = Gtk.Adjustment( 0.9, 0, 1, .001, .001, 0)
	223	self.GUI['endSlider'] = Gtk.VScale( adjustment = self.endAdjust )
224	224	self.endAdjust.connect("value-changed", self.handleEnd)
225	225	self.GUI['endSlider'].set_inverted(True)
226	226	self.GUI['endSlider'].set_size_request(50, 200)
…	…
229	229	endBox.pack_start(self.GUI['endSlider'], True, True, 5)
230	230	self.controlsBox.pack_start(endBox, True, True, 0)
231	231
232		durBox = gtk.VBox()
233		self.durAdjust = gtk.Adjustment( 0.01, 0, 0.2, .001, .001, 0)
234		self.GUI['durSlider'] = gtk.VScale( adjustment = self.durAdjust )
	232	durBox = Gtk.VBox()
	233	self.durAdjust = Gtk.Adjustment( 0.01, 0, 0.2, .001, .001, 0)
	234	self.GUI['durSlider'] = Gtk.VScale( adjustment = self.durAdjust )
235	235	self.durAdjust.connect("value-changed", self.handleDur)
236	236	self.GUI['durSlider'].set_inverted(True)
237	237	self.GUI['durSlider'].set_size_request(50, 200)
…	…
240	240	durBox.pack_start(self.GUI['durSlider'], True, True, 5)
241	241	self.controlsBox.pack_start(durBox, True, True, 0)
242	242
243		volBox = gtk.VBox()
244		self.volAdjust = gtk.Adjustment( 1, 0, 2, .01, .01, 0)
245		self.GUI['volSlider'] = gtk.VScale( adjustment = self.volAdjust )
	243	volBox = Gtk.VBox()
	244	self.volAdjust = Gtk.Adjustment( 1, 0, 2, .01, .01, 0)
	245	self.GUI['volSlider'] = Gtk.VScale( adjustment = self.volAdjust )
246	246	self.volAdjust.connect("value-changed", self.handleVol)
247	247	self.GUI['volSlider'].set_inverted(True)
248	248	self.GUI['volSlider'].set_size_request(50, 200)
…	…
253	253
254	254	self.mainBox.pack_start(self.controlsBox, False, False, 10)
255	255
256		previewBox = gtk.VBox()
	256	previewBox = Gtk.VBox()
257	257	self.playStopButton = ImageToggleButton('miniplay.png', 'stop.png')
258	258	self.playStopButton.connect('button-press-event' , self.handlePlayButton)
259	259	previewBox.pack_start(self.playStopButton, True, True, 0)
260	260	self.mainBox.pack_start(previewBox, False, False, 10)
261	261
262		checkBox = gtk.VBox()
	262	checkBox = Gtk.VBox()
263	263	checkButton = ImageButton(Config.TAM_TAM_ROOT + '/icons/accept.svg')
264	264	checkButton.connect('clicked' , self.handleCheck)
265	265	checkBox.pack_start(checkButton, True, True, 0)
…	…
291	291	self.set_values(soundLength)
292	292	self.startAdjust.set_all( 0.01, 0, soundLength, .001, .001, 0)
293	293	self.endAdjust.set_all( soundLength-0.01, 0, soundLength, .001, .001, 0)
294		self.timeoutLoad = gobject.timeout_add(2000, self.loopSettingsDelay)
	294	self.timeoutLoad = GObject.timeout_add(2000, self.loopSettingsDelay)
295	295
296	296	def loopSettingsDelay(self):
297	297	self.mini.load_ls_instrument(self.sndname)
298		gobject.source_remove( self.timeoutLoad )
	298	GObject.source_remove( self.timeoutLoad )
299	299
300	300	def handleCheck(self, widget):
301	301	if self.nameEntry.get_text() != self.sndname:
…	…
370	370	if self.ok:
371	371	self.mini.loopSettingsPlayStop(widget.get_active(), self.loopedSound)
372	372	if self.loopedSound == False and widget.get_active() == False:
373		self.timeoutStop = gobject.timeout_add(int(self.soundLength * 1000)+500, self.playButtonState)
	373	self.timeoutStop = GObject.timeout_add(int(self.soundLength * 1000)+500, self.playButtonState)
374	374
375	375	def setButtonState(self):
376	376	self.ok = False
…	…
380	380	def playButtonState(self):
381	381	self.ok = False
382	382	self.playStopButton.set_active(False)
383		gobject.source_remove(self.timeoutStop)
	383	GObject.source_remove(self.timeoutStop)
384	384	self.ok = True

Commit 9b161ed20f0bf928b40479a0f01565ff16f3784e

Gitorious