# 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 import popen2, time, os, thread, Tkinter import song # Add a "view" property to each TemporalData (partition, lyrics, ...) instance, # by adding a new superclass (=Viewable) to TemporalData. # That's a dynamic object hack :-] _next_tag = 0 def new_tag(): global _next_tag _next_tag = _next_tag + 1 return "_" + str(_next_tag) class Viewable: "Abstract class for partition, lyric, battery, ..." def setviewtype(self, viewtype): if ((viewtype.__class__ is HiddenView) or (isinstance(viewtype, ViewType) and (viewtype.view is HiddenView))) and (not self.view.__class__ is HiddenView): # Hidden view => keep the previous view in memory, as a serialized form (a view can be used only once). self.oldview = self.view oldview = getattr(self, "view", None) if isinstance(viewtype, ViewType): self.view = viewtype.view(self.song, self, **viewtype.args) else: self.view = viewtype if oldview: oldview.destroy() def set_view(self, viewtype): canvas = self.view.canvas self.setviewtype(viewtype) canvas.draw() def set_capo(self, capo): if hasattr(self.view, "set_capo"): self.view.set_capo(capo) else: self.capo = capo def set_tonality(self, tonality): if hasattr(self.view, "set_tonality"): self.view.set_tonality(tonality) else: self.tonality = tonality def unhide(self): "Restore the view after it was hidden (by partition.setviewtype(view.HiddenView.viewtype) )." self.view.destroy() self.view = self.oldview del self.oldview song.TemporalData.__bases__ = song.TemporalData.__bases__ + (Viewable,) view_types = [] class ViewType: def __init__(self, group, name, view, args = {}, instrument = 24, register = 1): self.group = group self.name = name self.view = view self.args = args self.instrument = instrument if register: view_types.append(self) def __str__(self): if self.group: return _(self.group) + " -> " + self.name else: return self.name #if self.group: return (_(self.group) + " -> " + self.name).encode("latin") #else: return self.name.encode("latin") class GraphicNote: """A visual representation of a note. Has a note, x, y and selected properties, and some methods. This class is suclassed by an inner class in each View, in order to add view-specific data.""" def update (self): "Update the note. Called when the note has changed." def get_view (self): "Gets the view associated with this graphic note (e.g. the tablature, ...)." def delete (self): "Removes the note from the partition and destroy the graphic note in the view. No-op if called more than once." def destroy (self): "Destroys the graphic note in the view (but keeps the note in the partition; only the graphic representation is affected). No-op if called more than once." def drag (self, drag_box): "Draws the given note in the drag_box (a GnomeCanvasGroup), as it is represented by this view. Called when the note is dragged." def previous(self): "Returns the graphic note just before this one. This is view-dependant, e.g. for tablature, the previous note is understood to be on the same string." def next (self): "Returns the graphic note just after this one. This is view-dependant, e.g. for tablature, the next note is understood to be on the same string." def set_effect(self, effect): "GraphicNote.set_effect(effect) -- Set the given class of special effect (e.g. song.HammerNote) for the note of this graphic note." note = self.note note.remove_effect() # Remove previous effect if effect.linked: note.link_to(self.next().note) else: note.link_to(None) if not effect is song.Note: note.__class__ = effect note.init_effect() if effect is song.RollNote: # decal is k times the number of rolled notes at the same time and below this one ! (Hey ! All that takes a SINGLE line of Python) ! note.decal = 2 * len(filter(lambda n: n.value < note.value, self.get_view().partition.notes_at(self.note))) self.update() def _dot(drawer): # Create a doted drawer from a "normal" drawer return lambda view, x, y1, y2, time, tag: (view.canvas.create_line(x + 3, y2, x + 5, y2, width = 2, tag = tag),) + drawer(view, x, y1, y2, time, tag) class View: def __init__(self, song, partition, zoom): self.song = song self.partition = partition self.zoom = zoom def draw(self, canvas, x = 0, y = 0): "Draws the view in the given Gnome canvas, at the given x-y position. Can be called more than once; in this case the view is moved to the new position." def note_at (self, x, y, create = 0): """Gets the graphic note at the given x-y coordinates. If there is no such graphic note, None is returned if create is false, else a new empty "fake" note is created and returned.""" #def paste (self, graphic_note, x, y, note): "Pastes the given note at the given x-y location. If needed so, the note is already cloned and/or time-aligned. note is the note to add (already cloned), and graphic_note the graphic note that is copied." def paste (self, graphic_note_y_notes): "Pastes the given list of notes. graphic_note_y_notes is a list of (graphic_note, y, note) tuple, where x and y are the location, note is the note to add (already cloned and at the right time !), and graphic_note the graphic note that is copied (not a clone !). If needed so, note is already cloned and/or time-aligned." def select_in_box (self, x1, y1, x2, y2): "Selects all notes inside the given rect in this view." def add_selection (self, graphic_note): "Adds the given graphic note to the current selection." def remove_selection(self, graphic_note): "Removes the given graphic note from the current selection." def selected_notes (self): "Gets a sequence of all the selected graphic notes in this view." return () def deselect_all(self): "Deselect all selected notes in this view." def set_default_note(self, default_note): "Sets the default note. The default note is used as a template for newly created note in this view, and thus the new notes will have its duration, its volume, ...." def rythm_changed(self): "Redraws all the mesure bar. Must be called when the song's rythm is changed." def on_prop(self): "Displays a dialog box to edit this view's specific properties (If there are some). Called when the 'view properties' button is clicked in the partition properties dialog." import init_editobj init_editobj.edit(self.partition, cancel = self.canvas.app.cancel) def set_chord(self, chord): """Set the chord at the current position. chord is a sequence like ["", "3", "2", "0", "1", "0"].""" def get_chord(self): """Get the chord displayed at the current position. chord is a sequence like ["", "3", "2", "0", "1", "0"].""" return ["", "", "", "", "", ""] def destroy(self): "Destroy this view." def arrange_selection_at_fret(self, fret): pass def hide(self): canvas = self.canvas # self.destroy() delete the canvas attribute => we must stock it now self.partition.setviewtype(hidden_view_type) # Call self.destroy() canvas.draw() # Drawing funcs: def _nothing(self, x, y1, y2, time, tag): return () _round = _nothing def _white(self, x, y1, y2, time, tag): return ( self.canvas.create_line(x, y2, x, y1, fill = "gray80", width = 2, tag = tag), ) def _black(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 3 return ( self.canvas.create_line(x, y2, x, y1 + d, tag = tag), ) def _quarter(self, x, y1, y2, time, tag): dx = time % 96 if not dx: dx = -10 return ( self.canvas.create_line(x, y2, x , y1 , tag = tag), self.canvas.create_line(x, y1, x - dx * self.zoom, y1, width = 2, tag = tag), ) def _hquarter(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 48 if not dx: dx = -8 notations = ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 96) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d, x - dx * self.zoom, y1 + d, width = 2, tag = tag), ) return notations def _hhquarter(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 24 if not dx: dx = -6 notations = ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 96) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d , x - (time % 48) * self.zoom, y1 + d , width = 2, tag = tag), self.canvas.create_line(x, y1 + 2 * d, x - dx * self.zoom, y1 + 2 * d, width = 2, tag = tag), ) return notations def _quarter_triplet(self, x, y1, y2, time, tag): dx = time % 96 if not dx: dx = -10 if (time % 96) == 32: if cmp(y2, y1) > 0: anchor = "s" else: anchor = "n" triplet = ( self.canvas.create_text(x, y1, text = "3", anchor = anchor, tag = tag), ) else: triplet = () return triplet + ( self.canvas.create_line(x, y2, x , y1 , tag = tag), self.canvas.create_line(x, y1, x - dx * self.zoom, y1, width = 2, tag = tag), ) def _hquarter_triplet(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 48 if not dx: dx = -8 if (time % 48) == 16: if cmp(y2, y1) > 0: anchor = "s" else: anchor = "n" triplet = ( self.canvas.create_text(x, y1, text = "3", anchor = anchor, tag = tag), ) else: triplet = () return triplet + ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 96) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d, x - dx * self.zoom, y1 + d, width = 2, tag = tag), ) def _hhquarter_triplet(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 24 if not dx: dx = -6 if (time % 24) == 8: if cmp(y2, y1) > 0: anchor = "s" else: anchor = "n" triplet = ( self.canvas.create_text(x, y1, text = "3", anchor = anchor, tag = tag), ) else: triplet = () return triplet + ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 96) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d, x - (time % 48) * self.zoom, y1 + d, width = 2, tag = tag), self.canvas.create_line(x, y1 + 2 * d, x - dx * self.zoom, y1 + 2 * d, width = 2, tag = tag), ) def _quarter8(self, x, y1, y2, time, tag): dx = time % 144 if not dx: dx = -10 return ( self.canvas.create_line(x, y2, x , y1 , tag = tag), self.canvas.create_line(x, y1, x - dx * self.zoom, y1, width = 2, tag = tag), ) def _hquarter8(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 48 if not dx: dx = -8 notations = ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 144) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d, x - dx * self.zoom, y1 + d, width = 2, tag = tag), ) return notations def _hhquarter8(self, x, y1, y2, time, tag): d = cmp(y2, y1) * 4 dx = time % 24 if not dx: dx = -6 notations = ( self.canvas.create_line(x, y2 , x , y1 , tag = tag), self.canvas.create_line(x, y1 , x - (time % 144) * self.zoom, y1 , width = 2, tag = tag), self.canvas.create_line(x, y1 + d , x - (time % 48) * self.zoom, y1 + d , width = 2, tag = tag), self.canvas.create_line(x, y1 + 2 * d, x - dx * self.zoom, y1 + 2 * d, width = 2, tag = tag), ) return notations _drawers = { # Maps durations to the corresponding drawer function 576 : _dot(_round), 288 : _dot(_white), 144 : _dot(_black), 72 : _dot(_quarter), 36 : _dot(_hquarter), 18 : _dot(_hhquarter), 384 : _round, 192 : _white, 96 : _black, 48 : _quarter, 24 : _hquarter, 12 : _hhquarter, 32 : _quarter_triplet, 16 : _hquarter_triplet, 8 : _hhquarter_triplet, } _drawers8 = { # Maps durations to the corresponding drawer function for x/8 rythms 576 : _dot(_round), 288 : _dot(_white), 144 : _dot(_black), 72 : _dot(_quarter8), 36 : _dot(_hquarter8), 18 : _dot(_hhquarter8), 384 : _round, 192 : _white, 96 : _black, 48 : _quarter8, 24 : _hquarter8, 12 : _hhquarter8, # Does triplets make sense in 6/8 rythms ??? 32 : _quarter_triplet, 16 : _hquarter_triplet, 8 : _hhquarter_triplet, } def draw_stem_and_beam(self, x, y1, y2, time, duration, tag, mesure = None): if mesure and (mesure.rythm2 == 8): return (View._drawers8.get(duration) or View._nothing)(self, x, y1, y2, time, tag) else: return (View._drawers .get(duration) or View._nothing)(self, x, y1, y2, time, tag) def __xml__(self, xml, context): pass def big_change_done(self): pass class HiddenView(View): """A view that hide the partition instead of showing it. Can be used as a demo/sample basic view !""" def __init__(self, song, partition): View.__init__(self, song, partition, 1.0) def draw(self, canvas, x = 0, y = 0): text = unicode(self.partition) + u" (" + _("hidden") + u")" if hasattr(self, "group"): # Draw was already called before. Just move to the new position. self.canvas.move(self.group, 0, y - self.y1) self.canvas.itemconfigure(self.text, text = text) else: # First time draw id called. Create and draws all the stuff ! self.canvas = canvas self.group = new_tag() self.text = canvas.create_text(canvas.app.old_x1 + 20, y + 11, text = text, anchor = "w", tag = (self.group, "noscroll")) self.x = x self.y1 = y self.height = 20 self.y2 = y + self.height return x, self.y2 def destroy(self): if hasattr(self, "group"): # else, not initialized by "draw" self.canvas.delete(self.group) del self.group def on_key_press(self, event): pass def on_button_press1(self, event, x, y): pass def on_button_press2(self, event, x, y): pass def on_button_press3(self, event, x, y): if self.y1 <= y <= self.y2: self.unhide() def on_event(self, obj, event): if (event.type == gtk.gdk.BUTTON_PRESS) and (event.button == 3): x, y = self.canvas.get_pointer_abs() if self.y1 <= y <= self.y2: self.unhide() def unhide(self): self.partition.unhide() # partition instance keep the previous view when hidden. self.canvas.draw() def __getstate__(self): return None def __setstate__(self, dict): pass def __getinitargs__(self): return self.song, self.partition def __str__(self): return _("Hidden").encode("latin") def __xml__(self, xml, context): self.partition.oldview.__xml__(xml, context, 1) hidden_view_type = ViewType("", _("Hidden"), HiddenView) import song, player noteplayer = None def playnote(instrument, value): global noteplayer if not noteplayer: noteplayer = song.Song() noteplayer.partitions.append(song.Partition(noteplayer)) noteplayer.partitions[0].notes.append(song.Note(0, 48, 0)) noteplayer.partitions[0].instrument = instrument noteplayer.partitions[0].notes[0].value = value player.play_async(noteplayer.midi()[0]) import copy, ui class String: """A guitar string in a tablature. Nothing to see with char string !""" def __init__(self, basenote = 50, notationpos = 1): self.basenote = basenote self.notationpos = notationpos # The position of the notation of the note duration (0 at top, 1 at bottom) def draw(self, canvas, group, x, y, length = 32000): self.y = y self.lines = ( canvas.create_line(x, y, length, y, fill = "gray20", tag = group), ) def __getstate__(self): return None def __setstate__(self, dict): pass def __getinitargs__(self): return self.basenote, self.notationpos # Base class for drums and tablature class TabView(View): STRING_SEP = 20 REQUIRE_STRINGID = 0 def __init__(self, _song, partition, strings, zoom = 0.66667): View.__init__(self, _song, partition, zoom) self.graphic_notes = {} self.selection = [] self.mesures = [] self.mesuresmarks = [] self.default_note = None self.strings = strings self.selection_box = None self.update_selection_box_delayed = self.update_lyrics_delayed = 0 tablature = self class TabNote(GraphicNote): # Internal class def __init__(self, note): stringid = tablature.stringid(note) self.string = tablature.strings[stringid] self.x = tablature.time_to_x(note.time) self.y = self.string.y self.selected = 0 self.note = note self.tag = tablature.group + "_" + str(note.time) + " " + str(stringid) self.tag_all = (self.tag, tablature.group) self._drawnotation() self.text = tablature.canvas.create_text(self.x, self.y + 1, text = self._text(), anchor = "center", fill = self._color(), tag = self.tag_all) tablature.graphic_notes[note.time, stringid] = self def _text(self): return "?" def get_view(self): return tablature def _drawnotation(self): note = self.note x = self.x #10.0 + float(note.time) * tablature.zoom mesure = partition.song.mesure_at(note.time) or partition.song.mesures[-1] if self.string.notationpos == 0: # At the top of the tablature if not tablature.uppernotation.has_key(note.time): tablature.uppernotation[note.time] = note self.notations = tablature.draw_stem_and_beam(x, tablature.y1 + 4, tablature.y1 + 17, note.time - mesure.time, note.duration, self.tag_all, mesure) else: self.notations = None else: # At the bottom if not tablature.lowernotation.has_key(note.time): tablature.lowernotation[note.time] = note self.notations = tablature.draw_stem_and_beam(x, tablature.y2 - 4, tablature.y2 - 17, note.time - mesure.time, note.duration, self.tag_all, mesure) else: self.notations = None def _color(self): if self.note.volume > 220: return "red" return "gray%s" % int(100.0 - (self.note.volume / 2.55)) def update(self, note = None): if not self is tablature.get_at(self.note.time, tablature.stringid(self.note)): return if note is None: note = self.note if tablature.uppernotation.get(self.note.time) is self.note: del tablature.uppernotation[self.note.time] if tablature.lowernotation.get(self.note.time) is self.note: del tablature.lowernotation[self.note.time] if self.notations: tablature.canvas.delete(*self.notations) self.notations = [] self._drawnotation() self.set_value(note.value) tablature.canvas.itemconfigure(self.text, fill = self._color()) def get_self(self): """Get the graphic note at the position of a graphic note. It is usually the graphic note itself, except if it has been replaced by an other.""" if self.tag: return self return tablature.get_at(self.note.time, tablature.stringid(self.note)) or tablature.drawnote(self.note) #return tablature.get_at(self.note.time, tablature.stringid(self.note), 1) def delete(self): if self.destroy(): if self.note.value > 0: tablature.partition.delnote(self.note) tablature.delay_update_lyrics() return 1 def destroy(self): # return 1 if the note was not already destroyed stringid = tablature.stringid(self.note) if tablature.graphic_notes.get((self.note.time, stringid)) is self: # Else already destroyed, or another note has replaced this one !!! if self.selected: tablature.selection.remove(self) self.selected = 0 del tablature.graphic_notes[self.note.time, stringid] tablature.canvas.delete(self.tag) self.tag = None if tablature.uppernotation.get(self.note.time) is self.note: del tablature.uppernotation[self.note.time] if tablature.lowernotation.get(self.note.time) is self.note: del tablature.lowernotation[self.note.time] return 1 def is_at(self, x, y): "Returns true if this graphic note is at the given x-y position." return (self.note.value != -1) and abs(x - self.x) < 5 and abs(y - self.y) < 12 def get_bounds(self): x1, y1, x2, y2 = tablature.canvas.bbox(self.text) return x1, y1, max(x2, tablature.time_to_x(self.note.time + self.note.duration) - 12), y2 def set_selected(self, selected): if selected == self.selected: return self.selected = selected if not selected and (self.note.value < 0): self.delete() # A fake note is unselected => remove it ! def set_value(self, value): if self.note.value < 0: # A fake note that become real... partition.addnote(self.note) tablature.checktime(self.note.time) tablature.update_lyrics() self.note.value = value tablature.canvas.itemconfigure(self.text, text = self._text()) if value < 0: # A note that become a fake note ! partition.delnote(self.note) if not self.selected: self.delete() tablature.update_lyrics() if self.selected: tablature.delay_update_selection_box() def playnote(self): playnote(partition.instrument, self.note.value) def drag(self, canvas, tag): canvas.create_text(self.x, self.y, text = self._text(), anchor = "center", fill = self._color(), tag = tag) def previous(self): my_stringid = tablature.stringid(self.note) times = list(zip(*filter(lambda (time, stringid): stringid == my_stringid, tablature.graphic_notes.keys()))[0]) times.sort() i = times.index(self.note.time) if i: return tablature.graphic_notes[times[i - 1], my_stringid] def next(self): my_stringid = tablature.stringid(self.note) times = list(zip(*filter(lambda (time, stringid): stringid == my_stringid, tablature.graphic_notes.keys()))[0]) times.sort() i = times.index(self.note.time) if i + 1 < len(times): return tablature.graphic_notes[times[i + 1], my_stringid] def __repr__(self): return "" % self.note self.drawnote = TabNote def draw(self, canvas, x = 0, y = 0): if hasattr(self, "canvas"): self.canvas.itemconfigure(self.header, text = self.partition.header) x1, y1, x2, y2 = canvas.bbox(self.header) old_y1 = self.y1 self.y1 = y + y2 - y1 + 8 self.canvas.move(self.group, 0, self.y1 - old_y1) self.canvas.coords(self.header, canvas.app.old_x1 + 20, y + 4) self.bar.coords(x2 + 20, y + 10) self.x = x self.height = len(self.strings) * self.STRING_SEP + 40 self.y2 = self.y1 + self.height # Update the strings's y coordinate for string in self.strings: string.y = string.y + self.y1 - old_y1 # Update the graphic note's y coordinates for graphic_note in self.graphic_notes.values(): graphic_note.y = graphic_note.string.y else: self.canvas = canvas self.uppernotation = {} self.lowernotation = {} self.x = x self.group = new_tag() self.header = canvas.create_text(canvas.app.old_x1 + 20, y + 4, text = self.partition.header, anchor = "nw", tag = (self.group, "noscroll")) x1, y1, x2, y2 = canvas.bbox(self.header) self.y1 = y + y2 - y1 + 8 self.bar = ui.LinksBar(canvas, x2 + 20, y + 10, ((_("Move up") , lambda event: self.canvas.app.move_partition(self.partition, -1)), (_("Move down") , lambda event: self.canvas.app.move_partition(self.partition, 1)), (_("Delete") , lambda event: self.canvas.app.on_partition_delete(self.partition)), (_("Properties"), lambda event: self.on_prop()), ), tag = (self.group, "noscroll"), ) self.draw_strings() self.checktime() #map(self.drawnote , self.partition.notes) return x, self.y2 def ensure_drawn(self, time1, time2): notes = self.partition.notes_range(time1, time2) for note in notes: if not self.graphic_notes.has_key((note.time, self.stringid(note))): self.drawnote(note) def draw_strings(self): stringy = 30 + self.y1 for string in self.strings: string.draw(self.canvas, self.group, self.x, stringy) stringy += self.STRING_SEP self.y2 = stringy + 10 self.height = self.y2 - self.y1 def rythm_changed(self): self.canvas.delete(*self.mesuresmarks) self.mesures = [] self.checktime() def checktime(self, time = 0): if len(self.mesures) < len(self.song.mesures): map(self.add_mesure, self.song.mesures[len(self.mesures):]) self.canvas.app.set_scroll_region() def add_mesure(self, mesure): width = 1 x = mesure.endtime() * self.zoom + 2 + self.x self.mesures.append(mesure) if len(self.song.mesures) > len(self.mesures): next = self.song.mesures[len(self.mesures)] else: next = None symbols = self.song.playlist.symbols.get(next) if symbols: for symbol in symbols: h = self.STRING_SEP * (len(self.strings) - 1) if (symbol == "} % end repeat") or (symbol == "} % end alternative"): self.mesuresmarks.append(self.canvas.create_oval(x - 8, self.y1 + 28 + h * 0.35, x - 3, self.y1 + 33 + h * 0.35, fill = "black", tag = self.group)) self.mesuresmarks.append(self.canvas.create_oval(x - 8, self.y1 + 27 + h * 0.65, x - 3, self.y1 + 32 + h * 0.65, fill = "black", tag = self.group)) width = 2 elif symbol.startswith(r"\repeat"): self.mesuresmarks.append(self.canvas.create_oval(x + 8, self.y1 + 28 + h * 0.35, x + 3, self.y1 + 33 + h * 0.35, fill = "black", tag = self.group)) self.mesuresmarks.append(self.canvas.create_oval(x + 8, self.y1 + 27 + h * 0.65, x + 3, self.y1 + 32 + h * 0.65, fill = "black", tag = self.group)) width = 2 elif symbol.startswith(r"{ % start alternative"): alt = symbol[22:] self.mesuresmarks.append(self.canvas.create_line(x, self.y1, x + 60, self.y1, tag = self.group)) self.mesuresmarks.append(self.canvas.create_text(x + 15, self.y1 + 7, text = alt, tag = self.group)) if mesure.syncope: from main import icons self.mesuresmarks.append(self.canvas.create_image(self.x + mesure.time * self.zoom, self.y1 + 13, image = icons["syncope"], tag = self.group)) self.mesuresmarks.append(self.canvas.create_line(x, self.y1 + 20, x, self.y2, fill = 'gray50', width = width, tag = self.group)) else: self.mesuresmarks.append(self.canvas.create_line(x, self.y1, x, self.y2, fill = "black", width = width, tag = self.group)) def add_selection(self, graphic_note): if graphic_note in self.selection: return b1 = graphic_note.get_bounds() if self.selection: b2 = self.canvas.bbox(self.selection_box) self.canvas.coords(self.selection_box, min(b1[0] - 2, b2[0] + 1), # +1 / -1 because of the border ??? min(b1[1] - 1, b2[1] + 1), max(b1[2] + 3, b2[2] - 1), max(b1[3] + 2, b2[3] - 1), ) else: self.selection_box = self.canvas.create_rectangle( b1[0] - 2, b1[1] - 1, b1[2] + 3, b1[3] + 2, outline = "#AAAADD", fill = "#DDDDFF", width = 2, tag = self.group) self.canvas.tag_lower(self.selection_box, self.group) self.selection.append(graphic_note) graphic_note.set_selected(1) self.previoustype = 0 def remove_selection(self, graphic_note): self.selection.remove(graphic_note) graphic_note.set_selected(0) self.update_selection_box() def delay_update_selection_box(self): if not self.update_selection_box_delayed: self.update_selection_box_delayed = 1 self.canvas.after(50, self.update_selection_box) def update_selection_box(self): self.update_selection_box_delayed = 0 if self.selection: xys = zip(*map(lambda graphic_note: graphic_note.get_bounds(), self.selection)) if self.selection_box: self.canvas.coords(self.selection_box, min(xys[0]) - 2, min(xys[1]) - 1, max(xys[2]) + 3, max(xys[3]) + 2, ) else: self.selection_box = self.canvas.create_rectangle(min(xys[0]) - 2, min(xys[1]) - 1, max(xys[2]) + 3, max(xys[3]) + 2, outline = "#AAAADD", fill = "#DDDDFF", width = 2, tag = self.group) self.canvas.tag_lower(self.selection_box, self.group) else: self.canvas.delete(self.selection_box) self.selection_box = None def deselect_all(self): for graphic_note in self.selection: graphic_note.set_selected(0) self.selection = [] self.canvas.delete(self.selection_box) self.selection_box = None def set_default_note(self, default_note): self.default_note = default_note def on_key_press(self, event): if not self.selection: return key = event.keycode if (key == 107) or (key == 22): # Del or backspace if self.selection: self.previoustype = 0 oldnotes = map(lambda graphic_note: graphic_note.note, self.selection) def do_it(): for note in oldnotes: self.get_at(note.time, self.stringid(note)).delete() self.select_at(oldnotes[0].time, self.stringid(oldnotes[0])) # Select something self.big_change_done() self.canvas.app.cancel.add_cancel(cancel_it) def cancel_it(): self.deselect_all() # Unselect and delete any "fake" note that may have been added under the note we are resurected. for note in oldnotes: self.partition.addnote(note) self.drawnote(note) self.update_lyrics() self.select_at(oldnotes[0].time, self.stringid(oldnotes[0])) # Select something self.big_change_done() self.canvas.app.cancel.add_redo(do_it) do_it() elif (key == 102) and self.selection: # Right sel = self.selection[0] stringid = self.stringid(sel.note) #time = self.round(((sel.note.time / self.default_note.time) + 1) * self.default_note.time) time = sel.note.time + sel.note.duration next = sel.next() if next: time = min(time, next.note.time) self.select_at(time, stringid) elif (key == 100) and self.selection: # Left sel = self.selection[0] stringid = self.stringid(sel.note) #time = self.round(((sel.note.time / self.default_note.time) - 1) * self.default_note.time) time = sel.note.time - self.default_note.time previous = sel.previous() if previous: time = max(time, previous.note.time) self.select_at(time, stringid) elif (key == 98) and self.selection: # Up sel = self.selection[0] stringid = self.stringid(sel.note) if stringid > 0: self.select_at(sel.note.time, stringid - 1) else: # Select a note in the upper view. index = self.song.partitions.index(self.partition) if index > 0: self.deselect_all() view = self.song.partitions[index - 1].view view.add_selection(view.note_at(self.time_to_x(sel.note.time), view.y2, 1)) elif (key == 104) and self.selection: # Down sel = self.selection[0] stringid = self.stringid(sel.note) if stringid < len(self.strings) - 1: self.select_at(sel.note.time, stringid + 1) else: # Select a note in the lower view. index = self.song.partitions.index(self.partition) if index < len(self.song.partitions) - 1: self.deselect_all() view = self.song.partitions[index + 1].view view.add_selection(view.note_at(self.time_to_x(sel.note.time), view.y1, 1)) return 1 # Do not send the keydown event to the next view !!! elif key == 97: # origin sel = self.selection[0] stringid = self.stringid(sel.note) self.select_at(0, stringid) elif key == 103: # End sel = self.selection[0] stringid = self.stringid(sel.note) self.select_at(self.mesures[-1].endtime, stringid) elif key == 99: # page up sel = self.selection[0] stringid = self.stringid(sel.note) self.select_at(self.song.mesurebefore(sel.note.time).time, stringid) elif key == 105: # page down sel = self.selection[0] stringid = self.stringid(sel.note) self.select_at(self.song.mesure_at(sel.note.time).endtime(), stringid) elif (key == 23) and event.state: # Shift-tab : move to previous note on this string sel = self.selection[0] if sel: sel = sel.previous() if sel: self.deselect_all() self.add_selection(sel) elif key == 23: # Tab : move to next note on this string sel = self.selection[0] if sel: sel = sel.next() if sel: self.deselect_all() self.add_selection(sel) def on_button_press1(self, event, x, y): if self.y1 < y < self.y2: graphic_note = self.note_at(x, y) if graphic_note: self.deselect_all() self.add_selection(graphic_note) else: time = self.x_to_round_time(x) self.select_at(time, self.y_to_stringid(y)) else: self.deselect_all() def on_button_press2(self, event, x, y): pass def on_button_press3(self, event, x, y): # A right click on the header hide the tablature x1, y1, x2, y2 = self.canvas.bbox(self.header) if y1 <= y <= y2: self.hide() def select_at(self, time, stringid = 0): self.deselect_all() if time < 0: time = 0 elif time >= self.song.mesures[-1].time + 2 * self.song.mesures[-1].duration: time = self.song.mesures[-1].time + 2 * self.song.mesures[-1].duration - self.default_note.time # Check if we need to scroll in order to make the new section visible. self.canvas.app.ensure_visible_x(time * self.zoom + 30) graphic_note = self.get_at(time, stringid, 1) self.add_selection(graphic_note) return graphic_note def get_at(self, time, stringid, create = 0): try: graphic_note = self.graphic_notes[time, stringid] except (KeyError, NameError): if not create: return None # Creates a new "fake" note with no value (-1 as value means "fake notes", represented by a "_"). graphic_note = self.drawnote(self.fake_note(time, stringid)) return graphic_note def fake_note(self, time, stringid): pass def select_in_box(self, x1, y1, x2, y2): self.deselect_all() self.previoustype = 0 for graphic_note in self.graphic_notes.values(): if (x1 < graphic_note.x < x2) and y1 < graphic_note.y < y2: self.selection.append(graphic_note) graphic_note.set_selected(1) #self.add_selection(graphic_note) self.update_selection_box() def note_at(self, x, y, create = 0): for graphic_note in self.graphic_notes.values(): if graphic_note.is_at(x, y): return graphic_note if create: # Creates a new "fake" note with no value (-1 as value means "fake notes", represented by a "_"). note = song.Note(self.x_to_time(x), self.default_note.duration, -1, self.default_note.volume) if self.REQUIRE_STRINGID: note.stringid = self.y_to_stringid(y) graphic_note = self.drawnote(self.fake_note(self.x_to_time(x), self.y_to_stringid(y))) return graphic_note def paste(self, graphic_note_y_notes): oldnotes = [] def do_it(): self.deselect_all() for i in range(len(oldnotes)): del oldnotes[0] # Empty the list # Remove any note already at the same position as a new one. for graphic_note, y, note in graphic_note_y_notes: if isinstance(note, song.Note): stringid = self.y_to_stringid(y) oldnote = self.graphic_notes.get((note.time, stringid)) if oldnote: oldnote.delete() oldnotes.append(oldnote.note) for graphic_note, y, note in graphic_note_y_notes: if isinstance(note, song.Note): stringid = self.y_to_stringid_(y) if stringid is None: # Out of the tab continue # Old tablature-specific code # #if isinstance(graphic_note.get_view(), Tablature): # note.value = note.value - graphic_note.get_view().strings[note.stringid].basenote + self.strings[stringid].basenote if self.REQUIRE_STRINGID: note.stringid = stringid self.partition.addnote(note) self.add_selection(self.drawnote(note)) self.big_change_done() self.checktime() # Add mesure bar if needed self.canvas.app.cancel.add_cancel(cancel_it) def cancel_it(): self.deselect_all() # Copy the notes before to remove them, since removing them may unlink some hammers... notes = map(lambda graphic_note_y_note: graphic_note_y_note[2], graphic_note_y_notes) notes = copy.deepcopy(notes) for i in range(len(graphic_note_y_notes)): graphic_note_y_notes[i] = graphic_note_y_notes[i][0], graphic_note_y_notes[i][1], notes[i] for graphic_note, y, note in graphic_note_y_notes: if isinstance(note, song.Note): graphic_note = self.get_at(note.time, self.y_to_stringid(y)) if graphic_note: graphic_note.delete() # Else, it was pasted out of the tab ! for note in copy.deepcopy(oldnotes): # Clone them, in order to keep "oldnotes" clean. self.partition.addnote(note) self.drawnote(note) self.big_change_done() self.canvas.app.cancel.add_redo(do_it) do_it() #def paste(self, graphic_note_y_notes): pass def big_change_done(self): """Called when important change has been done -- addition or deletion of a bunch of notes.""" self.update_lyrics() def stringid(self, note): pass def x_to_time (self, x ): return int((x - self.x - 10) / self.zoom) def x_to_round_time(self, x ): return int(round(int(((x - self.x - 10.0) / self.zoom / self.default_note.time) + 0.4) * self.default_note.time)) def time_to_x (self, time): return time * self.zoom + self.x + 10 def y_to_stringid (self, y ): return max(0, min(int((y - self.y1 - 20.0) / self.STRING_SEP), len(self.strings) - 1)) def round (self, time): return int(round(int((time / self.default_note.time) + 0.4) * self.default_note.time)) def y_to_stringid_ (self, y ): # Similar to y_to_stringid, but return None if y is out of the tab. stringid = int(round(((y - self.y1 - self.STRING_SEP - 10.0) / self.STRING_SEP))) if (stringid < 0) or (stringid >= len(self.strings)): return None return stringid def destroy(self): if hasattr(self, "canvas"): # else, not initialized by "draw" self.bar.destroy() self.canvas.delete(self.group) for graphic_note in self.graphic_notes.itervalues(): graphic_note.tag = None # Mark them as deleted del self.canvas self.graphic_notes = {} # Restore the view so it can be re-used ! self.selection = [] self.mesures = [] self.mesuresmarks = [] def selected_notes(self): return self.selection def delay_update_lyrics(self): if not self.update_lyrics_delayed: self.update_lyrics_delayed = 1 self.canvas.after(50, self.update_lyrics) def update_lyrics(self): partitions = self.song.partitions i = partitions.index(self.partition) + 1 while (i < len(partitions)) and isinstance(partitions[i], song.Lyrics2): partitions[i].view.update() i = i + 1 def __getstate__(self): return None def __setstate__(self, dict): pass def __getinitargs__(self): return self.song, self.partition, self.strings, self.zoom