# SongWrite # Copyright (C) 2001-2004 Jean-Baptiste LAMY -- jibalamy@free.fr # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import nested_scopes import sys, time, getpass, copy, string, os, os.path, thread import globdef, song, player, ui import editobj.cancel as cancel, editobj.treewidget as treewidget from editobj.observe import * icons = treewidget.IconsDir(globdef.DATADIR) NO_MODE = 0 SELECTION_MODE = 1 DRAGGING_NOTES_MODE = 2 # The clipboard / selection selection = [] selection_cloned = 0 # 1 if the selection has already be cloned nb_apps = 0 from Tkinter import * # Create, if needed, the root Tk. try: from Tkinter import tkroot except ImportError: tkroot = Tk(baseName = "songwrite", className = "Songwrite") import Tkinter Tkinter.tkroot = tkroot tkroot.withdraw() # Better Tk look tkroot.option_add("*Entry.relief" , "flat") tkroot.option_add("*Entry.background" , "#FFFFFF") tkroot.option_add("*Text.relief" , "flat") tkroot.option_add("*Text.background" , "#FFFFFF") tkroot.option_add("*Listbox.relief" , "flat") tkroot.option_add("*Listbox.background", "#FFFFFF") #def set_window_icon(window): # t = Tkinter.Toplevel() # Tkinter.Label(t, image = icons["songwrite_64x64.gif"]).pack() # window.iconwindow(t) def edit_songbook(songbook): global nb_apps nb_apps = nb_apps + 1 def on_ok(): songbook.save() global nb_apps if nb_apps == 1: globdef.config.save() sys.exit() else: nb_apps = nb_apps - 1 import init_editobj init_editobj.edit(songbook, command = on_ok) class App(Toplevel): def __init__(self, filename = None, edit_song = None): global nb_apps nb_apps = nb_apps + 1 from Tkinter import tkroot menubar = Menu(tkroot) file_menu = Menu(menubar) file_menu.add_command(label = _("New") , command = self.on_new) file_menu.add_command(label = _("New window...") , command = self.on_new_app) file_menu.add_command(label = _("New songbook..."), command = self.on_new_songbook) file_menu.add_command(label = _("Open...") , command = self.on_open) file_menu.add_command(label = _("Save") , command = self.on_save, accelerator = "C-s") file_menu.add_command(label = _("Save as...") , command = self.on_save_as) file_menu.add_separator() import_menu = Menu(menubar) import_menu.add_command(label = _("Midi...") , command = self.on_import_midi) import_menu.add_command(label = _("Ascii tablature..."), command = self.on_import_ascii) import_menu.add_command(label = _("Guitar pro 3-4...") , command = self.on_import_gp) file_menu.add_cascade (label = _("Import"), menu = import_menu) export_menu = Menu(menubar) export_menu.add_command(label = _("Midi...") , command = self.on_export_midi) export_menu.add_command(label = _("Rich tablature Midi...") , command = self.on_export_rich_tablature_midi) export_menu.add_command(label = _("Ascii tablature...") , command = self.on_export_ascii) export_menu.add_command(label = _("Lilypond (no lyrics)..."), command = self.on_export_lily) export_menu.add_command(label = _("LaTeX+Lilypond...") , command = self.on_export_latex) export_menu.add_command(label = _("Postscipt...") , command = self.on_export_ps) # export_menu.add_command(label = _("AbcTab...") , command = self.on_export_abctab) file_menu.add_cascade (label = _("Export"), menu = export_menu) file_menu.add_command(label = _("preview_print") , command = self.on_preview_print) file_menu.add_separator() file_menu.add_command(label = _("Exit") , command = self.on_close, accelerator = "q") file_menu.add_separator() for file in globdef.config.PREVIOUS_FILES: def on_open_recent(file = file): if self.check_save(): return self.open_filename(file) file_menu.add_command(label = file, command = on_open_recent) menubar.add_cascade (label = _("File"), menu = file_menu) edit_menu = Menu(menubar) edit_menu.add_command(label = _("Cancel"), command = self.on_cancel, accelerator = "C-_ / C-z") edit_menu.add_command(label = _("Redo") , command = self.on_redo , accelerator = "C-r") edit_menu.add_separator() edit_menu.add_command(label = _("Insert/remove times...") , command = self.on_insert_times) edit_menu.add_command(label = _("Insert/remove bars...") , command = self.on_insert_mesures) edit_menu.add_separator() edit_menu.add_command(label = _("Preferences..."), command = self.on_preferences) menubar.add_cascade (label = _("Edit"), menu = edit_menu) song_menu = Menu(menubar) song_menu.add_command(label = _("Play") , command = self.on_play) song_menu.add_command(label = _("Play from here"), command = self.on_play_from_here, accelerator = _("Space")) song_menu.add_command(label = _("Play in loop") , command = self.on_play_in_loop) song_menu.add_command(label = _("Stop playing") , command = self.on_stop_playing) song_menu.add_separator() song_menu.add_command(label = _("Rhythm...") , command = self.on_rythm_prop) song_menu.add_command(label = _("Repeat...") , command = self.on_repeat) song_menu.add_command(label = _("Properties...") , command = self.on_song_prop) menubar.add_cascade (label = _("Song"), menu = song_menu) partition_menu = Menu(menubar) self.partition_add_menu = Menu(menubar) import view, tablature, drum, staff view.view_types.sort(lambda a, b: cmp(a.group, b.group)) prev_group = "" for view_type in view.view_types: if not view_type.group: continue if view_type.group != prev_group: prev_group = view_type.group cur_menu = Menu(menubar) partition_menu.add_cascade(label = _("New " + prev_group), menu = cur_menu) def on_click(view_type = view_type): partition = song.Partition(self.song) partition.instrument = view_type.instrument partition.setviewtype(view_type) partition.header = view_type.name self.add_partition(partition) self.ensure_visible_y(100000) cur_menu.add_command(label = view_type.name, command = on_click) self.partition_add_menu.add_command(label = view_type.name, command = on_click) self.partition_add_menu.add_separator() self.partition_add_menu.add_command(label = _("New lyrics"), command = self.on_new_lyrics2) partition_menu.add_command(label = _("New lyrics"), command = self.on_new_lyrics2) partition_menu.add_separator() partition_menu.add_command(label = _("Move up") , command = self.on_partition_moveup) partition_menu.add_command(label = _("Move down") , command = self.on_partition_movedown) partition_menu.add_command(label = _("Delete") , command = self.on_partition_delete) partition_menu.add_command(label = _("Properties..."), command = self.on_partition_prop) menubar.add_cascade (label = _("Partition"), menu = partition_menu) note_menu = Menu(menubar) note_menu.add_command(label = _("Paste") , command = self.on_note_paste, accelerator = _("Middle click")) note_menu.add_command(label = _("Arrange at fret..."), command = self.on_note_arrange) note_menu.add_command(label = _("Properties...") , command = self.on_note_prop) menubar.add_cascade (label = _("Note"), menu = note_menu) help_menu = Menu(menubar) help_menu.add_command(label = _("About...") , command = self.on_about) help_menu.add_command(label = _("Manual...") , command = self.on_manual) help_menu.add_separator() help_menu.add_command(label = _("Dump") , command = self.on_dump) help_menu.add_command(label = _("Dump clipboard") , command = self.on_dump_clipboard) help_menu.add_command(label = _("GC") , command = self.on_gc) help_menu.add_command(label = _("Python console..."), command = self.on_console) menubar.add_cascade (label = _("Help"), menu = help_menu) Toplevel.__init__(self, tkroot, menu = menubar, class_ = "Songwrite") self.doted_duration = self.triplet_duration = 0 self.default_note = song.Note(96, 96, 0) self.mode = NO_MODE self.selection_box = self.drag_box = self.last_cancelable = None self.old_x1 = 0.0 self.columnconfigure(0, weight = 1) self.rowconfigure(0, weight = 0) self.rowconfigure(1, weight = 1) toolbar = Frame(self, borderwidth = 2, relief = "raised") toolbar.grid(sticky = "nsew") col = 0 self.duration = IntVar() self.duration_buttons = [] durs = song.DURATIONS.items() durs.sort() durs.reverse() for duration, duration_label in durs: button = Button(toolbar, text = _(duration_label), padx = 5, relief = "flat")#, image = icons["round.pgm"]) button.grid(row = 0, column = col, sticky = "nsew") button.duration = duration button["command"] = lambda button = button: self.on_note_duration(button) self.duration_buttons.append(button) col = col + 1 self.base_duration = 96 self.old_duration_button = self.duration_buttons[2] self.old_duration_button["relief"] = "sunken" self.doted_button = Button(toolbar, command = self.on_note_doted, padx = 5, text = _("Doted"), relief = "flat") self.doted_button.grid(row = 0, column = col, sticky = "nsew"); col = col + 1 self.triplet_button = Button(toolbar, command = self.on_note_triplet, padx = 5, text = _("Triplet"), relief = "flat") self.triplet_button.grid(row = 0, column = col, sticky = "nsew"); col = col + 1 self.stressed_button = Button(toolbar, command = self.on_note_stressed, padx = 5, text = _("Stressed"), relief = "flat") self.stressed_button.grid(row = 0, column = col, sticky = "nsew"); col = col + 1 Label(toolbar, text = _("Zoom")).grid(row = 0, column = col + 3, sticky = "nsew") Button(toolbar, text = "-", padx = 5, relief = "flat", command = lambda : self.incr_zoom(-1)).grid(row = 0, column = col + 2) Button(toolbar, text = "+", padx = 5, relief = "flat", command = lambda : self.incr_zoom( 1)).grid(row = 0, column = col + 4) toolbar.columnconfigure(col + 1, weight = 1) frame = Frame(self) frame.grid(sticky = "nsew") frame.rowconfigure (0, weight = 1) frame.columnconfigure(0, weight = 1) self.canvas = Canvas(frame, bg = "white", highlightthickness = 0, height = 260) self.canvas.grid(sticky = "nsew") self.canvas.bind("" , self.on_button_press1) self.canvas.bind("" , self.on_button_press2) self.canvas.bind("" , self.on_button_press3) self.canvas.bind("" , self.on_button_release1) self.canvas.bind("" , self.on_button_release2) self.canvas.bind("" , self.on_button_release3) self.canvas.bind("" , self.on_note_prop) self.canvas.bind("" , self.on_motion) self.canvas.bind("" , self.on_key_press) self.canvas.bind("" , self.on_note_stressed) self.canvas.bind("" , self.on_note_stressed) self.canvas.bind("" , self.on_space) self.canvas.bind("" , self.on_save) self.canvas.bind("", self.on_cancel) self.canvas.bind("" , self.on_cancel) self.canvas.bind("" , self.on_redo) self.canvas.bind("" , self.on_close) self.canvas.focus_set() self.vbar = Scrollbar(frame, takefocus = 0, orient = VERTICAL) self.hbar = Scrollbar(frame, takefocus = 0, orient = HORIZONTAL) self.vbar.grid(row = 0, column = 1, sticky = "nsew") self.hbar.grid(row = 1, column = 0, sticky = "nsew") self.vbar['command'] = self.canvas.yview self.hbar['command'] = self.canvas_xview self.canvas['yscrollcommand'] = self.vbar.set self.canvas['xscrollcommand'] = self.hbar.set self.bar = ui.LinksBar(self.canvas, 0, 0, ((_("Play") , self.on_play), (_("Save") , self.on_save), (_("preview_print"), self.on_preview_print), (_("Properties") , self.on_song_prop), ), tag = "noscroll", ) self.partition_focus = self.canvas.create_rectangle(10, 10, 100, 100, outline = "#AAAADD", fill = "#FFF8FF", width = 2) self.cancel = cancel.Context() self.canvas.draw = self.draw # HACK self.canvas.app = self self.zoom = 0.66667 self.width = self.height = 0 self.bind("" , self.on_expose) self.wm_protocol("WM_DELETE_WINDOW", self.on_close) self.wm_command("songwrite") self.song = None if filename: self.open_filename(filename) elif edit_song: self.set_song(edit_song) else: self.on_new() #set_window_icon(self) def on_new_songbook(self): filename = self.prompt_filename(defaultextension = ".sw.xml", filetypes = ((_("XML files"), "*.sw.xml"),)) if not filename: return globdef.config.add_previous_file(filename) import songbook songbook = songbook.Songbook(filename) songbook.authors = unicode(getpass.getuser().title(), "latin") songbook.title = _("%s's songbook") % songbook.authors songbook.save() edit_songbook(songbook) def on_repeat(self): import init_editobj init_editobj.edit(self.song.playlist, cancel = self.cancel) def play_bar_idle(self, from_time, info): if not info: return start = time.time() bar = self.canvas.create_rectangle(0, self.y, 0, self.height, outline = "#AAAADD", width = 2) next2, next = info.pop(0) first = next playing = 0 while 1: current = time.time() - start if current >= self.time_to_second(next - first): x = self.time_to_x(from_time + next2) self.canvas.coords(bar, x - 10, self.y, x + 10, self.height) self.ensure_visible_x(x) if not info: time.sleep(0.5) break next2, next = info.pop(0) else: time.sleep(0.05) if not player.is_playing(): # May not have started yet if playing: break else: playing = 1 self.canvas.delete(bar) def on_expose(self, event): width = self.canvas.winfo_width() if width != self.width: self.width = width self.set_scroll_region() self.ensure_drawn() def canvas_xview(self, *args): self.canvas.xview(*args) x1 = self.canvas.canvasx(0) self.canvas.move("noscroll", x1 - self.old_x1, 0) self.old_x1 = x1 self.ensure_drawn() def ensure_drawn(self, time1 = None, time2 = None): if time1 is None: time1 = int(self.x_to_time(self.old_x1)) time2 = int(self.x_to_time(self.old_x1 + self.width)) #print "ensure_drawn", time1, time2 for partition in self.song.partitions: if hasattr(partition.view, "ensure_drawn"): partition.view.ensure_drawn(time1, time2) def set_scroll_region(self): self.max_x = self.time_to_x_vec(self.song.mesures[-1].endtime() + self.song.mesures[-1].duration) self.canvas.configure(scrollregion = (0, 0, self.max_x, self.height)) self.set_partition(self.partition, 1) def ensure_visible_x(self, x): offx = self.canvas.canvasx(0) if x - 30 < offx: self.canvas_xview("moveto", max(x - 35, 0) / self.max_x) else: w = int(self.canvas.winfo_width()) if x + 60 > offx + w: self.canvas_xview("moveto", (x + 65 - w) / self.max_x) def ensure_visible_y(self, y): offy = self.canvas.canvasy(0) if y - 30 < offy: self.canvas.yview_moveto(max(y - 35, 0) / self.canvas.bbox(ALL)[3]) else: h = self.canvas.winfo_height() if y + 30 > offy + h: self.canvas.yview_moveto((y + 35 - h) / self.height) def on_new_app(self): App() def on_close(self, event = None): if self.check_save(): return unobserve_tree(self.song, self.on_song_changed) unobserve_tree(self.song.playlist, self.on_playlist_changed) # Turn the song to a ref song import songbook self.song.__class__ = songbook.SongRef self.song.__dict__ = { "title" : self.song.title, "filename" : self.song.filename, "songbook" : getattr(self.song, "songbook", None) } global nb_apps if nb_apps == 1: globdef.config.save() sys.exit() else: nb_apps = nb_apps - 1 self.destroy() def set_song(self, song_): if self.song: self.canvas_xview("moveto", 0.0) self.canvas.yview("moveto", 0.0) for partition in self.song.partitions: partition.view.destroy() unobserve_tree(self.song, self.on_song_changed) unobserve_tree(self.song.playlist, self.on_playlist_changed) self.song = song_ self.song.app = self scan() # Hack for speedup : avoid that "song.app = ..." cause a redraw. self.filename = song_.filename if song_.partitions: self.partition = song_.partitions[0] for partition in song_.partitions: if not hasattr(partition, "view"): if isinstance(partition, song.Lyrics2): import lyric2 partition.setviewtype(lyric2.lyric_view_type) else: import tablature partition.setviewtype(tablature.guitar_view_type) else: self.partition = None self.show_info() self.draw() import init_editobj observe_tree(song_, self.on_song_changed) observe_tree(song_.playlist, self.on_playlist_changed) def on_playlist_changed(self, obj, type, new, old): self.song.playlist.analyse() self.rythm_changed() def on_song_changed(self, obj, type, new, old): if (type is object) and (obj is self.song): print "song changed !", diffdict(new, old) self.show_info() self.draw() elif (type is list) and (obj is self.song.partitions): for partition in old: if not partition in new: partition.view.destroy() self.draw() elif isinstance(obj, song.TemporalData): #print (u"partition %s changed !" % unicode(obj)).encode("latin") self.draw() elif type is list: for partition in self.song.partitions: if hasattr(partition.view, "strings") and (obj is partition.view.strings): partition.view.destroy() self.draw() elif (type is object) and (obj.__class__.__name__ == "String") and ((new["basenote"] != old["basenote"]) or (new["notationpos"] != old["notationpos"])): for partition in self.song.partitions: if hasattr(partition.view, "strings") and (obj in partition.view.strings): partition.view.destroy() self.draw() def show_info(self): "Shows the title, the authors and the comments." self.wm_title((u"Songwrite -- " + self.song.title).encode("latin")) self.canvas.delete("info") title = self.canvas.create_text(10, 5, text = (self.song.title + u" (" + self.song.authors + u")").encode("latin"), font = "helvetica 20", anchor = "nw", tag = ("info", "noscroll")) self.canvas.create_text(13, 35, text = self.song.comments, anchor = "nw", tag = ("info", "noscroll")) self.bar.coords(self.canvas.bbox(title)[2] + 10, 23) x1, y1, x2, y2 = self.canvas.bbox("info") self.y = 20 + y2 - y1 def set_partition(self, partition, force = 0): if force or (not self.partition is partition): self.partition = partition if partition: self.canvas.coords(self.partition_focus, 8, partition.view.y1, max(self.max_x - 2, self.canvas.winfo_width() + 2), partition.view.y2) def on_cancel(self, event = None): if not self.cancel.cancel(): self.bell() def on_redo (self, event = None): if not self.cancel.redo(): self.bell() def on_new(self): if self.song and self.check_save(): return # Else, it is the fisrt time. s = song.Song() s.authors = unicode(getpass.getuser().title(), "latin") s.title = _("%s's song") % s.authors s.copyright = u"Copyright %s by %s" % (time.localtime(time.time())[0], s.authors) s.partitions.append(song.Partition(s)) import tablature s.partitions[0].setviewtype(tablature.guitar_view_type) s.partitions[0].header = tablature.guitar_view_type.name self.set_song(s) self.filename = None self.last_cancelable = self.cancel.get_last_cancelable() def on_open(self): if self.check_save(): return import tkFileDialog filename = tkFileDialog.askopenfilename(filetypes = ((_("Songwrite files"), "*.sw.xml *.sw *.gtab"),)) if not filename: return if isinstance(filename, unicode): filename = filename.encode("latin") self.open_filename(filename) def open_filename(self, filename): self.filename = filename if filename.endswith(".xml"): import stemml _song = stemml.parse(filename) if isinstance(_song, song.Song): self.set_song(_song) else: edit_songbook(_song) else: import cPickle as pickle self.set_song(pickle.load(open(filename))) globdef.config.add_previous_file(filename) def on_save_as(self, event = None): filename = self.prompt_filename(defaultextension = ".sw.xml", filetypes = ((_("XML files"), "*.sw.xml"),)) if not filename: return if not filename.endswith(".sw.xml"): filename += ".sw.xml" globdef.config.add_previous_file(filename) self.filename = self.song.filename = filename self.on_save() def prompt_filename(self, **opts): import tkFileDialog filename = tkFileDialog.asksaveasfilename(**opts) if not filename: return if isinstance(filename, unicode): filename = filename.encode("latin") return filename def on_save(self, event = None): if not self.filename: return self.on_save_as() globdef.config.add_previous_file(self.filename) import codecs self.song.__xml__(codecs.lookup("utf8")[3](open(self.filename, "w"))) #.getvalue() self.last_cancelable = self.cancel.get_last_cancelable() def check_save(self): last_cancelable = self.cancel.get_last_cancelable() if last_cancelable and (not self.last_cancelable is last_cancelable): # The last cancelable action has changed => the song need to save. import tkMessageBox x = tkMessageBox._show(_("Confirmation"), _("The current song has been changed. Continue ?"), tkMessageBox.QUESTION, tkMessageBox.YESNO) if (x != "yes") and (not x is True): #if not tkMessageBox.askyesno(_("Confirmation"), _("The current song has been changed. Continue ?")): return 1 self.cancel = cancel.Context() return 0 def on_import_midi(self): if self.check_save(): return import midi_import, tablature, tkFileDialog filename = tkFileDialog.askopenfilename() if not filename: return if isinstance(filename, unicode): filename = filename.encode("latin") self.filename = filename _song = midi_import.parse(open(filename)) for partition in _song.partitions: if not hasattr(partition, "view"): partition.setviewtype(tablature.guitar_view_type) self.set_song(_song) def on_import_ascii(self): if self.check_save(): return import asciitab, tkFileDialog filename = tkFileDialog.askopenfilename() if not filename: return if isinstance(filename, unicode): filename = filename.encode("latin") self.filename = filename self.set_song(asciitab.parse(open(filename).read())) def on_import_gp(self): if self.check_save(): return import gp3_loader, tkFileDialog filename = tkFileDialog.askopenfilename() if not filename: return if isinstance(filename, unicode): filename = filename.encode("latin") self.filename = filename self.set_song(gp3_loader.load_guitar_pro(filename)) def on_export_midi(self): filename = self.prompt_filename() if not filename: return open(filename, "w").write(self.song.midi()[0]) def on_export_rich_tablature_midi(self): filename = self.prompt_filename() if not filename: return open(filename, "w").write(self.song.midi(rich_midi_tablature = 1)[0]) def on_export_ascii(self): import asciitab filename = self.prompt_filename() if not filename: return open(filename, "w").write(asciitab.asciitab(self.song)) def on_export_lily(self): import lilypond filename = self.prompt_filename() if not filename: return try: open(filename, "w").write(lilypond.lilypond(self.song)) except: self._treat_lily_error() def _treat_lily_error(self): error_class, error, trace = sys.exc_info() sys.excepthook(error_class, error, trace) print import tkMessageBox if isinstance(error, song.SongwriteError): tkMessageBox.showerror(_(error.__class__.__name__), unicode(error)) if isinstance(error, song.TimeError): if error.note: error.partition.view.select_at(error.note.time, getattr(error.note, "stringid", 0)) elif error.partition and error.time: error.partition.view.select_at(error.time) elif error.time and self.partition: self.partition.view.select_at(error.time) else: tkMessageBox.showerror(_(error.__class__.__name__), _("__UnknownError__")) def on_export_latex(self): import latex filename = self.prompt_filename() if not filename: return try: open(filename, "w").write(latex.latexify(self.song)) except: self._treat_lily_error() def on_export_ps(self): import latex filename = self.prompt_filename() if not filename: return try: latex.export2ps(self.song, filename) except: self._treat_lily_error() # def on_export_abctab(self): # import abctab # reload(abctab) # print abctab.abctab(self.song) def on_preview_print(self, event = None): import latex try: latex.preview(self.song, globdef.config.PREVIEW_COMMAND) except: self._treat_lily_error() def on_about(self): t = Toplevel() text = Text(t, wrap = "word", width = 50, height = 18, highlightthickness = 0, font = "Helvetica -12", selectbackground = "#CCCCFF") text.insert("end", _("__about__") % song.VERSION) text.pack(expand = 1, fill = BOTH) ok = Button(t, text = "OK", command = lambda : t.destroy()) ok.pack(fill = X) def on_manual(self): import webbrowser, locale DOCDIR = os.path.join(globdef.APPDIR, "doc") if not os.path.exists(DOCDIR): import glob DOCDIR = glob.glob(os.path.join(globdef.APPDIR, "..", "doc", "Songwrite*"))[0] DOC = os.path.join(DOCDIR, locale.getdefaultlocale()[0][:2], "doc.html") if not os.path.exists(DOC): DOC = os.path.join(DOCDIR, "en", "doc.html") DOC = os.path.abspath(DOC) webbrowser.open_new("file://" + DOC) def on_song_prop(self, event = None): import init_editobj init_editobj.edit(self.song, cancel = self.cancel) def on_rythm_prop(self, event = None): import init_editobj, editobj mesures = self.selected_mesures() or self.song.mesures mesures_old_rythms = map(lambda mesure: (mesure, mesure.rythm1, mesure.rythm2), mesures) def on_ok(): rythm1 = mesures[0].rythm1 rythm2 = mesures[0].rythm2 if not((rythm2 == 4) or ((rythm2 == 8) and (rythm1 % 3 == 0))): import tkMessageBox tkMessageBox.showwarning(_("__unsupported-rythm__"), _("__unsupported-rythm-message__") % (rythm1, rythm2)) for mesure in mesures: mesure.compute_duration() time = 0 for mesure in self.song.mesures: mesure.time = time time = time + mesure.duration self.rythm_changed() mesures_new_rythms = map(lambda mesure: (mesure, mesure.rythm1, mesure.rythm2), mesures) if mesures_old_rythms != mesures_new_rythms: for partition in self.song.partitions: partition.view.destroy() self.draw() init_editobj.edit(editobj.MultiEdit(mesures), command = on_ok, cancel = self.cancel, grab = 1) def on_partition_prop(self): self.partition.view.on_prop() def on_note_prop(self, event = None): import init_editobj, editobj graphic_notes = filter(lambda graphic_note: isinstance(graphic_note.note, song.Note), self.selected_notes()) if not graphic_notes: return notes = map(lambda graphic_note: graphic_note.note, graphic_notes) for note in notes: note.special_effect_name = note.__class__.__name__ if note.special_effect_name == "LinkedNote": note.special_effect_name = "Note" def on_ok(): for graphic_note in graphic_notes: if hasattr(graphic_note.note, "special_effect_name"): if (graphic_note.note.special_effect_name != graphic_note.note.__class__.__name__) and not((graphic_note.note.special_effect_name == "Note") and (graphic_note.note.__class__.__name__ == "LinkedNote")): graphic_note.set_effect(getattr(song, graphic_note.note.special_effect_name)) del graphic_note.note.special_effect_name graphic_note.get_self().update() init_editobj.edit(editobj.MultiEdit(notes), command = on_ok, cancel = self.cancel, grab = 1) def on_new_lyrics2(self): import lyric2 lyrics = song.Lyrics2(self.song) lyrics.header = _("Lyrics") lyrics.setviewtype(lyric2.lyric_view_type) self.add_partition(lyrics) self.ensure_visible_y(100000) def add_partition(self, partition): def do_it(): self.song.partitions.append(partition) self.draw() self.cancel.add_cancel(cancel_it) def cancel_it(): partition.view.destroy() self.song.partitions.remove(partition) self.draw() self.cancel.add_redo(do_it) do_it() def on_partition_moveup (self): self.move_partition(self.partition, -1) def on_partition_movedown(self): self.move_partition(self.partition, 1) def move_partition(self, partition, dir): index = self.song.partitions.index(partition) if 0 <= index + dir <= len(self.song.partitions) - 1: def do_it(): del self.song.partitions[index] self.song.partitions.insert(index + dir, partition) self.draw() self.cancel.add_cancel(cancel_it) def cancel_it(): del self.song.partitions[index + dir] self.song.partitions.insert(index, partition) self.draw() self.cancel.add_redo(do_it) do_it() def on_partition_delete(self, partition = None): if not partition: partition = self.partition index = self.song.partitions.index(partition) def do_it(): partition.view.destroy() self.song.partitions.remove(partition) self.draw() self.canvas.coords(self.partition_focus, -10, -10, -10, -10) if self.partition is partition: self.partition = None self.cancel.add_cancel(cancel_it) def cancel_it(): self.song.partitions.insert(index, partition) self.draw() self.canvas.coords(self.partition_focus, -10, -10, -10, -10) self.cancel.add_redo(do_it) do_it() def on_preferences (self): globdef.config.edit() def on_play (self, event = None): midi, playbar_info = self.song.midi() player.play_async(midi, globdef.config.PLAY_LOOP) if globdef.config.DISPLAY_PLAY_BAR: thread.start_new_thread(self.play_bar_idle, (0, playbar_info,)) def on_play_in_loop (self): midi, playbar_info = self.song.midi() player.play_async(midi, 1) if globdef.config.DISPLAY_PLAY_BAR: thread.start_new_thread(self.play_bar_idle, (0, playbar_info,)) def on_play_from_here(self): selected_notes = self.selected_notes() if selected_notes: from_time = min(map(lambda graphic_note: graphic_note.note.time, selected_notes)) else: from_time = 0 midi, playbar_info = self.song.midi(from_time) player.play_async(midi) if globdef.config.DISPLAY_PLAY_BAR: thread.start_new_thread(self.play_bar_idle, (from_time, playbar_info,)) def on_stop_playing (self): player.stop() def on_play_loop (self): globdef.config.PLAY_LOOP = self.play_loop.active def incr_zoom(self, incr): x = self.x_to_time(self.canvas.canvasx(self.width / 2.0)) if incr == 1: self.zoom = self.zoom * 2.0 else: self.zoom = self.zoom / 2.0 for partition in self.song.partitions: partition.view.zoom = self.zoom partition.view.destroy() self.draw() x = self.time_to_x(x) - self.width / 2.0 self.canvas_xview("moveto", x / self.max_x) def on_space(self, event = None): # space : play from the current position if player.is_playing(): player.stop() else: self.on_play_from_here() def on_key_press(self, event): #print event.keycode, event.state, event.char need_pop_cancel = 0 char = event.char if not event.keycode in (23, 97, 98, 99, 100, 102, 103, 104, 105): # Deplacement key, handled by partitions' views self.cancel.push() need_pop_cancel = 1 # Propagate the event, and then pop the cancel stack if char == "*": graphic_notes = self.selected_notes() if graphic_notes: index = { 384 : 0, 192 : 0, 96 : 1, 48 : 2, 24 : 3, 12 : 4, }[graphic_notes[0].note.base_duration()] else: index = max(0, self.duration_buttons.index(self.old_duration_button) - 1) self.on_note_duration(self.duration_buttons[index]) elif char == "/": graphic_notes = self.selected_notes() if graphic_notes: index = { 384 : 1, 192 : 2, 96 : 3, 48 : 4, 24 : 5, 12 : 5, }[graphic_notes[0].note.base_duration()] else: index = min(len(self.duration_buttons), self.duration_buttons.index(self.old_duration_button) + 1) self.on_note_duration(self.duration_buttons[index]) elif char == ".": self.on_note_doted() for partition in self.song.partitions: if partition.view.on_key_press(event): break if need_pop_cancel: self.cancel.pop() if event.keycode == 23: return "break" def on_button_press1(self, event): global selection self.canvas.focus_set() x, y = self.canvas.canvasx(event.x), self.canvas.canvasy(event.y) self.selection_x1 = x self.selection_y1 = y for partition in self.song.partitions: if partition.view.y1 < y < partition.view.y2: self.set_partition(partition) break # Check if the user is dragging an already selected note, or drawing a new selection for partition in self.song.partitions: graphic_note = partition.view.note_at(x, y) if graphic_note and graphic_note.selected: # There's a selected note at the clicked position => drag ! self.mode = DRAGGING_NOTES_MODE selection = [] for partition in self.song.partitions: selection.extend(partition.view.selected_notes()) return # Don't send the event to the partitions' views self.mode = SELECTION_MODE for partition in self.song.partitions: if partition.view.on_button_press1(event, x, y): break def on_button_press2(self, event): self.canvas.focus_set() x, y = self.canvas.canvasx(event.x), self.canvas.canvasy(event.y) if selection: # Paste self.mode = DRAGGING_NOTES_MODE self.drag_box = 1 for graphic_note in selection: graphic_note.drag(self.canvas, "drag") minx = miny = sys.maxint for graphic_note in selection: if graphic_note.x < minx: minx = graphic_note.x if graphic_note.y < miny: miny = graphic_note.y self.canvas.move("drag", x - minx, y - miny) self.selection_x1 = minx self.selection_y1 = miny self.selection_x2 = self.old_selection_x2 = x self.selection_y2 = self.old_selection_y2 = y def on_button_press3(self, event): self.canvas.focus_set() x, y = self.canvas.canvasx(event.x), self.canvas.canvasy(event.y) for partition in self.song.partitions: if partition.view.on_button_press3(event, x, y): break def on_button_release1(self, event): if self.mode == DRAGGING_NOTES_MODE and self.drag_box: self.drag_performed() elif self.mode == SELECTION_MODE and self.selection_box: self.selection_performed() self.mode = NO_MODE def on_button_release2(self, event): if self.mode == DRAGGING_NOTES_MODE and self.drag_box: self.drag_performed(delete_source = 0) self.mode = NO_MODE def on_button_release3(self, event): if self.mode == DRAGGING_NOTES_MODE: # Cancel drag self.canvas.delete("drag") self.drag_box = None self.mode = NO_MODE def on_motion(self, event): #if event.state in (272, 528): # Do not work on all computer if event.state: if not self.mode: return # The motion was not initiated in the canvas but in an inner widget !!! self.selection_x2, self.selection_y2 = x, y = self.canvas.canvasx(event.x), self.canvas.canvasy(event.y) self.ensure_visible_x(x) self.ensure_visible_y(y) if self.mode == DRAGGING_NOTES_MODE: if self.drag_box: self.canvas.move("drag", self.selection_x2 - self.old_selection_x2, self.selection_y2 - self.old_selection_y2) self.old_selection_x2 = self.selection_x2 self.old_selection_y2 = self.selection_y2 else: self.drag_box = 1 #self.canvas.root().add(gcanvas.CanvasGroup) for graphic_note in selection: graphic_note.drag(self.canvas, "drag") self.old_selection_x2 = self.selection_x1 self.old_selection_y2 = self.selection_y1 elif self.mode == SELECTION_MODE: if self.selection_box: self.canvas.coords(self.selection_box, min(self.selection_x1, self.selection_x2), min(self.selection_y1, self.selection_y2), max(self.selection_x1, self.selection_x2), max(self.selection_y1, self.selection_y2), ) else: self.selection_box = self.canvas.create_rectangle(self.selection_x1, self.selection_y1, self.selection_x1, self.selection_y1, fill = "#DDDDFF", outline = "#AAAADD", width = 2) self.canvas.tag_lower(self.selection_box) self.canvas.tag_raise(self.selection_box, self.partition_focus) def selection_performed(self): global selection, selection_cloned self.canvas.delete(self.selection_box) self.selection_box = None # Avoid dummy selections of a very small rect if you drag a little the mouse when clicking if abs(self.selection_x1 - self.selection_x2) + abs(self.selection_y1 - self.selection_y2) > 15: selection = [] selection_cloned = 0 for partition in self.song.partitions: partition.view.select_in_box( min(self.selection_x1, self.selection_x2), min(self.selection_y1, self.selection_y2), max(self.selection_x1, self.selection_x2), max(self.selection_y1, self.selection_y2), ) selection.extend(partition.view.selected_notes()) return 1 # Propagate the event def drag_performed(self, delete_source = 1): if self.drag_box: self.canvas.delete("drag") self.drag_box = None # dt and dy are the time and y deplacement. dt is rounded to the nearest current note duration (and that looks to require to work on its absolute part ?). dt_ = (self.selection_x2 - self.selection_x1) / self.zoom dy = self.selection_y2 - self.selection_y1 dt = int(0.4 + float(abs(dt_)) / self.default_note.duration) * self.default_note.duration if dt_ < 0: dt = -dt # deepcopies the notes (in one big list, and NOT note by note, because some notes may be linked to or from other ones !) clones = copy.deepcopy(map(lambda graphic_note: graphic_note.note, selection)) selection_and_clones = zip(selection, clones) self.cancel.push() if delete_source: sources = selection[:] def do_it(): for i in range(len(sources)): sources.pop().delete() self.cancel.add_cancel(cancel_it) def cancel_it(): for graphic_note, clone in selection_and_clones: graphic_note.get_view().partition.addnote(graphic_note.note) g = graphic_note.get_view().drawnote(graphic_note.note) g.get_view().add_selection(g) sources.append(g) self.cancel.add_redo(do_it) # Required, but should not be done here !!! But where and how ??? for partition in self.song.partitions: partition.view.big_change_done() do_it() partition_pasted_notes = {} # Map partitions to the list of note pasted to them # Add them in the right partition -- We must do 2 different "for" because ALL the time must be OK when we add the notes in the partition (for linked notes) for graphic_note, clone in selection_and_clones: y = graphic_note.y + dy if hasattr(clone, "time" ): clone.time = graphic_note.note.time + dt # Time-located element elif hasattr(clone, "mesure"): clone.mesure = self.song.mesure_at(clone.mesure.time + dt, 1) # Mesure-located element (note may be a Note but also a Lyric, ... !!!) for partition in self.song.partitions: if partition.view.y2 >= y: # The current note is over this partition. pasted_notes = partition_pasted_notes.get(partition) if not pasted_notes: pasted_notes = partition_pasted_notes[partition] = [] pasted_notes.append((graphic_note, y, clone)) break for partition, pasted_notes in partition_pasted_notes.items(): partition.view.paste(pasted_notes) self.cancel.pop() return 1 # Propagate the event def on_note_paste(self): selected_notes = self.selected_notes() if selected_notes: # Hack the selection coordinates self.selection_x1 = min(map(lambda graphic_note: graphic_note.x, selection)) self.selection_y1 = min(map(lambda graphic_note: graphic_note.y, selection)) self.selection_x2 = selected_notes[0].x self.selection_y2 = selected_notes[0].y # End up a "fake" drag self.drag_performed(delete_source = 0) def on_insert_times(self): import tkSimpleDialog nb_time = tkSimpleDialog.askinteger(_("Insert times..."), _("Insert how many times? (negative for removing)"), parent = self) if not nb_time: return at = self.selected_notes()[0].note.time delta = nb_time * 96 removed = [] def shift(delta): old_removed = removed[:] del removed[:] for partition in self.song.partitions: if isinstance(partition, song.Partition): i = 0 while i < len(partition.notes): note = partition.notes[i] if note.time >= at: if (delta < 0) and note.time < at - delta: del partition.notes[i] removed.append((partition, note)) continue else: note.time += delta i += 1 for partition, note in old_removed: partition.addnote(note) for partition in self.song.partitions: partition.view.destroy() self.draw() def do_it(): shift(delta) self.cancel.add_cancel(cancel_it) def cancel_it(): shift(-delta) self.cancel.add_redo(do_it) do_it() def on_insert_mesures(self): import tkSimpleDialog nb_mesure = tkSimpleDialog.askinteger(_("Insert bars..."), _("Insert how many bars? (negative for removing)"), parent = self) if not nb_mesure: return mesure = self.song.mesure_at(self.selected_notes()[0].note.time) mesure_pos = self.song.mesures.index(mesure) at = mesure.time removed = [] playlist_items_values = [] def shift(nb_mesure): # Add / remove mesures time = self.song.mesures[mesure_pos].time if nb_mesure > 0: for i in range(mesure_pos, mesure_pos + nb_mesure): self.song.mesures.insert(i, song.Mesure(time, mesure.tempo, mesure.rythm1, mesure.rythm2, mesure.syncope)) time += mesure.duration else: del self.song.mesures[mesure_pos : mesure_pos - nb_mesure] i = mesure_pos for mes in self.song.mesures[i:]: mes.time = time time += mes.duration # Shift playlist unobserve_tree(self.song.playlist, self.on_playlist_changed) if playlist_items_values: for item, from_mesure, to_mesure in playlist_items_values: item.from_mesure = from_mesure item.to_mesure = to_mesure del playlist_items_values[:] else: for item in self.song.playlist.playlist_items: playlist_items_values.append((item, item.from_mesure, item.to_mesure)) if item.from_mesure >= mesure_pos: if item.from_mesure < mesure_pos - nb_mesure: item.from_mesure = mesure_pos else: item.from_mesure += nb_mesure if item.to_mesure >= mesure_pos - 1: if item.to_mesure < mesure_pos-1-nb_mesure: item.to_mesure = mesure_pos - 1 else: item.to_mesure += nb_mesure # Shift notes old_removed = removed[:] del removed[:] delta = nb_mesure * mesure.duration for partition in self.song.partitions: if isinstance(partition, song.Partition): i = 0 while i < len(partition.notes): note = partition.notes[i] if note.time >= at: if (delta < 0) and note.time < at - delta: del partition.notes[i] removed.append((partition, note)) continue else: note.time += delta i += 1 for partition, note in old_removed: partition.addnote(note) for partition in self.song.partitions: partition.view.destroy() self.draw() observe_tree(self.song.playlist, self.on_playlist_changed) self.on_playlist_changed(None, None, None, None) def do_it(): shift(nb_mesure) self.cancel.add_cancel(cancel_it) def cancel_it(): shift(-nb_mesure) self.cancel.add_redo(do_it) do_it() def on_note_arrange(self): import tkSimpleDialog fret = tkSimpleDialog.askinteger(_("Arrange at fret..."), _("Arrange selected notes at fret?"), parent = self) self.cancel.push() for partition in self.song.partitions: partition.view.arrange_selection_at_fret(fret) self.cancel.pop() def on_note_duration(self, button): self.old_duration_button["relief"] = "flat" button["relief"] = "sunken" self.base_duration = button.duration self.compute_duration() self.old_duration_button = button def on_note_doted(self, event = None): if self.triplet_duration: return graphic_notes = self.selected_notes() if graphic_notes and graphic_notes[0].note.value > 0: self.doted_duration = not graphic_notes[0].note.dotted() else: self.doted_duration = self.doted_button["relief"] == "flat" if self.doted_duration: self.doted_button["relief"] = "sunken" else: self.doted_button["relief"] = "flat" self.compute_duration(graphic_notes) def on_note_triplet(self, event = None): if self.doted_duration: return graphic_notes = self.selected_notes() if graphic_notes and graphic_notes[0].note.value > 0: self.triplet_duration = not graphic_notes[0].note.is_triplet() else: self.triplet_duration = self.triplet_button["relief"] == "flat" if self.triplet_duration: self.triplet_button["relief"] = "sunken" else: self.triplet_button["relief"] = "flat" self.compute_duration(graphic_notes) def compute_duration(self, graphic_notes = None): if graphic_notes is None: graphic_notes = self.selected_notes() duration = self.base_duration if self.doted_duration : duration = int(duration * 1.5) if self.triplet_duration: duration = int(duration / 1.5) self.default_note.time = self.default_note.duration = duration def is_not_fake(graphic_note): if not isinstance(graphic_note.note, song.Note): return 0 if graphic_note.note.value < 0: graphic_note.note.duration = duration graphic_note.update() return 0 return 1 graphic_notes = filter(is_not_fake, graphic_notes) if not graphic_notes: return old_values = map(lambda graphic_note: graphic_note.note.duration, graphic_notes) def do_it(): for graphic_note in graphic_notes: g = graphic_note.get_self() g.note.duration = duration g.update() self.cancel.add_cancel(cancel_it) def cancel_it(): for graphic_note, old_value in zip(graphic_notes, old_values): g = graphic_note.get_self() g.note.duration = old_value g.update() self.cancel.add_redo(do_it) do_it() def on_note_stressed(self, event = None): graphic_notes = self.selected_notes() if graphic_notes: newvalue = graphic_notes[0].note.volume < 220 else: newvalue = self.stressed_button["relief"] == "flat" if newvalue: volume = self.default_note.volume = 0xFF self.stressed_button["relief"] = "sunken" else: volume = self.default_note.volume = 0xCC self.stressed_button["relief"] = "flat" def is_not_fake(graphic_note): if not isinstance(graphic_note.note, song.Note): return 0 if graphic_note.note.value < 0: graphic_note.note.volume = volume graphic_note.update() return 0 return 1 graphic_notes = filter(is_not_fake, graphic_notes) if not graphic_notes: return old_values = map(lambda graphic_note: graphic_note.note.volume, graphic_notes) def do_it(): for graphic_note in graphic_notes: g = graphic_note.get_self() g.note.volume = volume g.update() self.cancel.add_cancel(cancel_it) def cancel_it(): for graphic_note, old_value in zip(graphic_notes, old_values): g = graphic_note.get_self() g.note.volume = old_value g.update() self.cancel.add_redo(do_it) do_it() def draw(self): y = self.y for partition in self.song.partitions: partition.view.zoom = self.zoom partition.view.set_default_note(self.default_note) x, y = partition.view.draw(self.canvas, 20, y) y = y + 10 self.height = y self.set_scroll_region() self.ensure_drawn() def rythm_changed(self): self.song.rythm_changed() for partition in self.song.partitions: partition.view.rythm_changed() def selected_mesures(self): mesures = {} for graphic_note in self.selected_notes(): mesure = self.song.mesure_at(graphic_note.note.time) mesures[mesure] = 1 return mesures.keys() def selected_notes(self): notes = [] for partition in self.song.partitions: notes.extend(partition.view.selected_notes()) return notes def has_note_selected(self): for partition in self.song.partitions: if partition.view.selected_notes(): return 1 def x_to_time(self, x ): return int(x - 30) / self.zoom def time_to_x(self, time): return time * self.zoom + 30 def time_to_x_vec(self, time): return time * self.zoom def time_to_second(self, time): return float(time) / (self.song.mesures[0].tempo * 2) def on_dump(self): print self.song.__xml__().getvalue() #import lilypond #reload(lilypond) #lily = lilypond.lilypond(self.song) #print lily #print >> open("/home/jiba/src/test2.ly", "w"), lily def on_dump_clipboard(self): print `selection` def on_gc(self): import gc print gc.collect() for o in gc.garbage: print getattr(o, "title", repr(o)) print def on_console(self): from editobj.console import Console from Tkinter import tkroot import editobj, init_editobj, view, tablature, drum, staff, lyric2 t = Toplevel(tkroot) c = Console(t, { "app" : self, "SONG" : self.song, "song" : song, "view" : view, "tablature" : tablature, "drum" : drum, "staff" : staff, "lyric2" : lyric2, "os" : os, "sys" : sys, "editobj" : editobj, "edit" : init_editobj.edit, "observe" : editobj.observe, }) c.text.insert("end", """\nYou can access the song as "SONG", and the main app window as "app". Use "edit(obj)" to edit any object.\n""") c.text.insert("end", sys.ps1) c.pack()