<<<<<<< iabc_autodoc.xml This is a static class (utility class) that keeps track of the state of some things in the parser that are global. Like how many '(' we've matched so far and what the note duration is. Usually this state lasts throught out the course of a single file. There are 3 ways to represent a duration. One is as a fraction, e.g. "1/4" for a 1/4 note. This is the whole duration specifier in abc. It also contains the default duration, which all duration rules use in case the duration is not specified. Note that the default duration for a note is handled internally in this abc parser. When a duration is read the value is computed in terms of the current default, which is handled in the parser. X: \d+ describes an index field. This maps titles to tunes. C: By Aaron Newman (c) 2003 H: This class was written last Tuesday while Aaron was supposed to be doing the dishes. T: the title rule. Describes a title. Add to the current title if we are still in the same tune (which you can tell by looking at the last index) The M: header rule The meter specifier in ABC. This also acts as the source of the current meter in ABC. ALso, I frequently call 'meter' 'time signature'. This is the voice change that can be at the start of a line of music. The letter note rule is part of the pitch. An octave as defined by '' or ,,. We'll need to add the octave header somewhere too. A part is a section of music called out by a letter or number above the music. The entire key header rule in one take. We need to know the key before we know the pitch since we will adjust the accidental accordingly. Get the key the user wants, and return the number of characters that should be skipped to get to the next thing. Get the key=value pairs that can trail a key declaration. We occasionally delete the key regular expressions since the take lots of memory. Construct them before use. The accidental that can preceed a note. A pitch is a letter note, possibly combined with an octave and an accidental. The end of line, which could be a repeat, bar line, etc. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. Return true if there is a match of a header inline a piece of music. A note_info is a pitch and a duration. If no duration is given the default one is used. Sometimes the pitch was not changed but we received an inline header instead. Return false in this case. many notes, glommed together. Used to put together chords and also single notes. Both the header rule and the note info rule can be enclosed in []. Figure out which here. A chord in abc is a single note or multiple notes within a pair of square brackets. The hornpipe rule is a funny little abc'ism. The fraction produced by this rule is interpreted as follows: multiply the default duration by 1/2^#, where # is the number of < or > s. For < ( > ) Add that to the LHS(RHS) and subtract it from the RHS(LHS). This usually (always?) results in a dotted rhythm For some reason abc allows a space between the closing note in a beam group and a closing paren. Have a rule that does that. For some reason abc allows a space between the closing note in a beam group and an opening paren. Have a rule that does that. The dynamics that ABC knows about that can be displayed on the screen or via midi. some things are defined within the '!' fenceposts We glom these together under the bang rule. We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. abc allows space after quotes and before the chords they accompany. Handle it. We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. This is the stuff that can occur between the notes in a chord or at the end of a chord. This rule will match almost everything in legal abc that is expressed as multiple chords run together, except xlets. Note: here is where we start counting paren's for slurs/ties The V: command, which does many things like we said before Matches a voice header. Depending on whether or not we're allowing text-based voice rules, proxy to the correct object. In abc a beam group is defined as any set of chords without a space. These are the words that actually go below the music. These are the words that are written free-hand below the music. Classes to handle arrays of arbitrary types. The array class uses the smart pointer pattern. The memory allocated for the array is handled here. Clients of the array classes should use array < > and not array_data. A parameterized array class that allows effecient assignement and shallow copying. Create the array. Args are optional. No argmunts creates an empty array. int the_initial_size, the number of (un-initialized) elements in the array at creation time. the_grow_size is the number of elements that we add when we expand the array. dereference the underlying data, when all references have been removed the data will be deleted. Create un-initialized elements until the array is the_index+1 elements. create num_elems additional un-initialzied elements in the array. return the number of elements (get_number_elements would have been a better name) return the element at the_index'th position. dereference my data and reference the data of the_other. remove all the elements and set the size of the array to 0 Remove the last element of the array, effectively shrinking the array size by one. copy all elements of the array from the_intput to the_output. Assumption is that the underlying arrays are not the same. Invoke the_predicate(the_list[i]) for each element in the array. Beamer draws beams and flags on notes. A note tells the beamer its coordinates as it is drawn, and the beamer computes the coordinates and shape of the beam and stem. Call the base class figure constructor with the screen dimensions. Since we beam according to note heads, we can't just map our points to another space; we need to actually clone the note heads first. virtual figure* clone(const rect & r1,const rect & r2,const size & ppi); When a note figure knows its coordinates, it calls this method to tell the beamer to add this note head to the beam group. If there is no beam group then this note receives a stem but no beam. Unlike other figures, beamers know where they're really supposed to go. Return that absolute point, and everything else is relative to that. This makes it easier to move around Get the points where the little xlet descriptions are supposed to go. Get some geometry information about the figure so that we might draw it correctly. For some notes, like with SATB parts, we like to force the beam to go a certain way. Return true if the value is either less than the level of the beam, or is a dotted level of the beam. The figure virtual method. The window wants to draw the beam so its time to render the shape. Draw the little number and the bracket associated with triplets and other xlets. return true if this value is a dotted version of the_base. These have different flags than triplety things. The figure virtual method. Most figures use a bogotwip coordinate system based on PostScript. But this shape is drawn to absolute screen coordinates, so set the linear xform for this polygon to 1:1. Get the highest connection point in our beam group. Get the lowest connection point in our beam group. A helper function to create_beam, that actually draws the beam and makes create_beam a little less complicated. The draw_half variable indicates whether we draw the segment all the way to p2, or only 1/2 way. the_left says we are drawing from left to right. -------- --------- |-- | | ----| | | | | | | | | 0 0 0 0 half = true, left = true half = false, left = false If we need to put a tail on a single unbeamed 8th note, do that Offset the connection points depending on whether the stem goes up or down. figure out where the high and low points are. Create the stem going either to the beam or just up. The depth in pixels of the beaming figure between note heads. Beams always go up. If the beam is actually down we need to start it below the note. Where the note goes on the staff, sometimes used to determine the 'upness' of the note head. Some interesting things about the geometry of the figure. This is the place where the note heads go. This is the place where the beams go. This is for clone array < point > my_original_beam_points; The xlet values that will be beamed under/over the beam groups Keep track of where the descriptions of the xlets are supposed to go. We can't draw them because we don't know about fonts and windows and stuff. Indicate whether the beams go up or down. 1 or -1 if we are forced to beam up or down, otherwise it stays at 0 Keep track of the durations of notes so we can beam them The note head that goes on the note. True if this is a grace note. The command we are trying to send to the window will be embedded in a wd command class. A derived version of this class will actually be called in the correct thread. The dispatcher requires a window to send the command to. Implement reference counting so the window gets destroyed when everybody's done with it and not before. We assume that there's always 1 'main' window that is always available to dispatch your commands for you, if you need to dispatch something but don;e know about a particular window class (which is often the case with dialog boxes). A dispatcher takes a set of wd_command objects and queues them up and sends them to the correct thread. If we are already in the correct thread and blocking is on then we execute it right then and there. Derivation draws the thing here. Derivation draws the thing here. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Derivation draws the thing here. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Derivation draws the thing here. Classes to handle events safely and efficiently The interface to an event handler, that an event source knows about. This breaks up the circular dependency between source and handler using the obserer pattern. Event Handlers and event sources need to keep reference counts to each other very carefully. A source object call this instance of a handler that it knows about. A class that represents an event that could occur. It is capable of notifying event handlers that the event has occured. An event handler wants to be informed if this event fires; Add it to the list of events we notify in the event of an event. The event handler no longer cares about this event. Remove it from the list. The event has occured! Notify all event handlers that the event has occured. Before and after the event handler adds the event, there may be special things that we need to do, like set a timer in the case of a timer for example. Protected method that actually adds the handler to the linked list. We need threadsafe access to our internal list, but we can't block while we're notifying events. So we just deep copy our internal list and we don't have to worry about the list changing underneath us. An event handler can block on events until they occur. Many event handlers can be or'd together so that we can wait on the first of many things at once. Add the_other to the list of events in this event chain. Set the event source for all the events in the chain, and then pend on the semaphore that indicates that the event has occured. This is the part that must be derived. Each instance of an event handler should know how to get an instance of the source that it can wait on. This is called when the event source fires. The event chain will then be torn down and the thread that was waiting on the event will be allowed to continue. Allow an event to be reused. This is the actual source that I am waiting on. The generic logic that calls GetEventSource. An excpetion is thrown here if the event source already exists. the_next is an event handler in the chain. This is used\ when setting up the 'or' chain. Only one event in a chain is the 'first', which is the one that ends on blocking. Make sure we always release the block from that point to assure deterministic behavior. The pending has ended. The event has fired. Tear down the event chain. When handling events in chains, the actual values can be zeroed out underneath us when the chain is released. Prevent the events and sources from being released prematurely. The semaphore that we are pending on. The other events in the chain. Log all kinds of events and changes in program state. Not to be confused with events, which are a specific concurrent type. Most events have this data in common so we have a class for it to save some typeing. A container for event log data. Methods used for printing, logging. The data that is actually in the log is implementation-specific Initialize the common data. the_size is the number of events and the_num_params is the number of parameters in each event. When printing out the events, we use get_first_event_index to get the index of the oldest event in the circular queue When printing out the events, we use get_last_event_index to get the index of the most recent event in the circular queue Return the number of events in this particular log. Print the log entry into a character buffer in human-readable format. Dump the entire log file to the stream f. return the timestamp for an event log. the number of events in this log the current index into the circular buffer. true if the event log has wrapped. The number of parameters in a single event. Most event logs are exactly the same except for the strings used to describe the numerical parameters and the number of parameters per event. This template handles all of those types of events. The title is printed out before the entire log is dumped. Store an event in the event log array. The enumeration is one of the types of events defined for EventType Implementation of the interface described above. Implementation of the interface described above. Some event logs have variable-sized events. Each event generates some text that is variable size and some numerical events that are of fixed size. Log the event. The first parameter is the variable-sized part, which is represented as a character string. Implementation of the interface described above. Implementation of the interface described above. the log of event data. the array for the variable-sized character data. A single windows event. The interface allows the template class event_log_template to manage these events. The strings that describe the events and their parameters. A single dispatch event. The strings that describe the events and their parameters. The lifetime of a document and things that happen to it. The strings that describe the events and their parameters. A figure (e.g. a picture of a note) has changed. The strings that describe the events and their parameters. Data to log a single event. The strings that describe the events and their parameters. A single parser event. This is some data that is common to all events The strings that describe the events and their parameters. A single parser event. This is some data that is common to all events The strings that describe the events and their parameters. The strings that describe the events and their parameters. The strings that describe the events and their parameters. Define a template for a function that returns an instance of a class where the actual create function is defined at link time. Define a static instance that is guaranteed to be created at the right time if it is referenced before 'main'. Good for class factories. Define a renderable thing. The abstract method render_poly must be overridden to define the point in the polygon. Additional virtual method control scaling, composite objects and other goodies. This will come in handy to describe a figure and the point where it is to be rendered. Since rendering in abcmacs is done in bogotwips (100*twips), we need to make sure that we know how many pixels to an inch. The figures work out best if we transform to screen coordinates when rendering the figure rather than rendering in twips and fixing it later. Create a new figure based on this figure Reset the scale. Since we render on a scale-specific canvas, that means re-rendering the polygon. Note that, since many figures are shared between many clients, re-scaling a figure could have strange results if everything else isn't rescaled, also. Handle reference counting Get the extreme points (leftmost, etc) points in a figure. Returns size in pixels and ul in terms of offset from starting point Return the bounding box of the rectangle if it were drawn at the given point. return the middle point of the bounding box that surrounds the figure. You can get this from the size one, but its useful by itself Draw the figure in the window thread at the point the_origin on the window w. Returns the topmost, leftmost, etc. actual point. Good for connecting figures together. Remove references to contained figures. method called by dispatcher template class. This method will always be called in the windows thread. Derivation draws the thing here. Render the polygon, either so it can be drawn or for sizing. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. The pixels per inch that we use to reference our points. The scaling constant we use when deciding how big things are. The polygon that defines the figure. True if we have rendered, so we only have to do it once. reference count, delete this when 0. set the pen width for drawing this figure before rendering. Sometimes, especially for outlined objects, its good to get the pend width based on the scale and ppi of this object. Do that here. Indicates the pen width is scaled. I added this when I realized that cloned_figure broke my scaled_figure inheritance, but left the scaled_figure class out of laziness. A figure that uses a pen width based on the current scale. A cloned figure uses the polygons from a figure class but maps the points to a different rectangle. We have to re-render the polygon in order to handle the different scaling without aliasing. ctor Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Create and manage figures that are fixed. that is, they have the same set of points regardless of where the center of the figure is. Geometry Management. Stand-alone functions that compute coordinates of things in relation to a staff, but didn't belong any place else. Basically these functions will compute the correct spot to place a note given some basic information about the note and the staff. Compute the coordinate to place the figure, if you want it to represent the_note place on the_staff. Find the height of the note, if the staff height is the_staff_heigh and the center of the staff is center_line. Value is offset from the center of the staff. Get the vertical placement of the given pitch, if the given staff is the_staff_height. This class reads in an abc file, and converts it to the universal internal format. Then it sends this internal music to the media for the music to be realized. Store the file that we will open later and try to parse. parse the input file and tell the media what we've found so the music can be realized somehow. The buffer has been modified. Set up the last modified time as the current time. Return the line that the tune we just partsed started on. We have parsed a file. Now display all the music. We have changed parts so we weren't reading the music in in order. Get the points we saved the last time, and save the current point of measure and chord for when we change back to this part/voice. Get the current tune selection from the GUI, and also save that in the registry for next time we open the file. Indicates whether or not we have parsed a file already so we can display different parts of a file without reloading the file, which can take a long time if the file is big. The number of tunes in the parser, used to see if we need to re-parse the file. This is it. There is where the parser is created and the window that the parser draws on is created. It must know about all things including wxWindows stuff because it creates things explicitly Display a list of tunes that the media read in. We need to use the tune box to do this. Allow a user to open and parse and iabc file, then display it on a window somewhere. Also handles printing and midi. someone has clicked on the area of the window that contains this document. Do many things. Handle the entry point of the thread. The parsing and construction of the music is done in this thread. Handle where the user has chosen a different rendering scale. send it to the printer in wxWindows Someone has created a document and is now attaching it to a window. Let the window know that we exist and keep track of it so that we can draw on something. The document is closing or has closed. Its no good anymore so remove all references to it. Start the thread and parse the same file again. Indicates that the parse is still on-going so we can't respond to the drawing commands yet. Document method that returns what part of the window a page in a document occupies. Used in printing. Open the following abc file and parse it. Create a midi file based on the current tune. Close the file we were just looking at and free all resources. Usually for printing, return this information Choose a tune from the file we have already opened. The user wants to refresh a tune that he is editing. PARAMS: the_last_cursor - the last cursor position. We'd like to restore this after the system has finished rendering the image so the user doesn't have to scroll back on every redraw. We check and update some things every so often on a tick from the GUI. Get the screen position in pixels from the location of the cursor in the text buffer transpose the selected text the given number of 1/2 steps (or letters if it is diatonic) PARAMETERS: the_steps - the number of steps (1/2 or diatonic) to transpose the_diatonic - true if we transpose letter values only. the_start - the start place of the selection in the buffer the_stop - the stop place of the selection in the buffer Return the list of voice names for the GUI. Get the on/off voice status of the voices in the tune. Set the voice map when the user has edited it from the menu. This is something we owe document. We assume that the printing is already set up, and we just need to tell the page to print itself. Set up the page settings and stuff. We are printing. Don't read in the music again but render the music again. Make sure the scale is 1/1 This is the wxWindow instance where the music drawing occurs. keep track of the 'voice on map' when we are refreshing the tune. This will tell the tune which voices to turn on in the new tune. This is the iabc-defined window, which contains a view-canvas window and interacts with classes like figure and text_figure. This is the actual wx object that the tune list gets drawn into. This is the gadget that we pass to the iabc_media that accepts all the tunes that it creates. Set this to indicate that we are still parsing this file, os we should not try and open a new file. True if we are opening a new tune in a collection, so we need to set the buffer position to the start point of the new tune. Otherwise we preserve the existing buffer position. This is where the music information gets displayed. This is where the print information gets displayed. The thing that parses the abc file and makes the music data structures. We set this to true when we have finished displaying the music and the parsing thread exits, so that we cna restart. This lets us tall the iabc source which file to open. the last positition within the text buffer that we were. Used to reposition the cursor after refreshes. Unless we're changing tunes, then we don't want to replace the cursor since the program will change the cursor position. This is used to center the screen on a redraw around the part of the tune that we were last editing. We set this every time we redraw something so we don't have to redraw when nothing's changed. The midi output place. The buffer where the ABC text lives. This is the last place we drew the handy text pointer. Note that this is a pointer to the GUI music that indiates where the text is, not a pointer to the text window itself. Drive the parser rules that define the abc language, at least as iabc understands them. Keep track of a line or so of an abc file and the musical information that came out of it from the parser. This can keep us from having to re-parse an unchanged line of abc. Parse this line of text, update the parser state and store all of the musical information. return true if this string matches the string that I was created with, or if the timestamp is earlier than the last time I was created. If this returns true, the_info and the_start_voice will contain the voice and parser_info that were present at the end of this line when it was first parsed. Indicate that check_match() has returned false. This is called by the constructor and actually performs the work of parsing the line of code we were fed when we were created. Parse the w: header. Put the chords into an array (they are stored in list format) so that we may put the words to them. Also used when putting words with the chord infos. RETURNS: true if the array still has stuff left in it. The line that I was created with Keep track of the first measure of the last line, which is where we start putting the words. The array of all the matches. The match type will indicate whether the current match type is a header, measure, or whatever The header rules that we created from parsing our string the match rules that we created from parsing our string. The parser state info could change during any Each rule is matched in the context of a parser state. Keep track of the parser state at the start of this line, if the line is same and the parser state is the same then the line is unchanged so all the misical information is also unchanged. Indicates that we have a match. This is the line number of the text file that was matched. We keep track of this so that we can track the music with the text in the GUI. Don't even bother looking at the line if the buffer hasn't changed since my_modified_time. This class invokes the pre-processor to get a line of text and then adds the music to the supplied media_source object. Keep the index in to the file for quickly finding a tune. Store the file name that we will open later and try to parse. retunr the starting line of the tune that we just parsed. parse the input file and tell the media what we've found so the music can be realized somehow. Get the tune from the file, based in the tune at the given index. Do a parse of just the T: and the X: headers get the next measure and deal with it from the abc file. Some measures are split across several lines so send the file in too, and keep track of the measure number. ARGS: int the_measure - the last measure we read in bool read_in_music - true if we've read in some music and we need a line break preprocess & the_file - the file we're reading in. Get the next line of text. This can actually be more than one line of text, if there are words that are associated with this line of abc stuff. Also get the line number of the file so that we can associate it with this spot in the music. return true if there is text left to read in the current tune. Because of the way we associate words with chord_info structures, we have to parse the word header (w:) outside if the state machine rules as well as in the word rule itself. Read through all the lines of the file, and feed each line to a new parseable unit for parsing. But, if we already have a parseable unit in the list that has parsed this line then don't bother reparsing. We want to make the lowest measure in a line be the key for that line for playing and indicating the place in the music. We've found a measure's worth of music. Handle it and update the current measure and beat. We have received a header at the given score point. Record it and make any required changes. Also reset the_measure_index to 1 if we are on a new tune. Return the last measure we read from the_voice. If this is the first one, we return 0. We have just changed voices, so update the new measure since it may be different than the last voice was. Keep track of the last line that we read in from the scanner, if there are words in this line then we combine it with earlier lines into one parseable unit. Keep track of the last line number that we read in from the user. Keep track of the line in the text buffer that a song starts on so that we can scroll to there if we like. When we switch voices in the parse, we need to keep track of what measure index we were on last time. Keep that information here. map of words that go below the staff, to the point in the music where they go. Tunes that we get in a quick parse of an abc file. Keep track of the first measure of the last line, which is where we start putting the words. text buffer for input Reset all the internal state things that I keep track of for a fresh parse of a file. Keep track of which line corresponds to which line of text for GUI magic later on. Handle all the logic and resources associated with drawing a key signature on a staff. Just populate variables. draw yourself on the page, on the staff supplied. Draw the ending bar if this is an inline key change. gets the number of sharps or flats If this is an inline key change, indicate how many naturals to put down if we are going to a more-natural key. A line_of_music is a container for all the stuff that gets drawn on one line of music. It also takes care of drawing fixtures of the staff (like the key signature) and the staff itself. Aside from that, the line_of_music does the horizontal justification that keeps the notes evenly spaced. Free all the graphical resources we use to draw ourselves. Add another measure to this staff. Future notes will be added to that measure. Add an 1st, 2nd etc. ending bracket over the music between the given measures. add a slur from the previous point in the music. The point in the music where we're slurring to will be added later. Finish the slur that was last added with add_slur_from get the measure that we start with get the measure that we end with just subtract the from and the to. This draws everything. Return true if the rectangle overlaps any of the regions of the staff. Used by the page manager (window_media) to draw page fixtures without ruiing the music. Add a creschendo/dimenuendo to the staff from/to the given point. This adds a dynamic change (pp, p, etc) to the list for later rendering Get the highest y coordinate, which is the lowest point on the screen tha this staff takes up. We decided this staff needs an offset different that the y coordinate. Change the y coordinate of the origin. return the lowest musical point on this staff, good for making hashtables. We need to add the ornaments after we draw all the notes cause then we know which way the beams go. This should be called after the notes are rendered or nothing will happen. A lot of fixtures need some basic information about a staff before rendering themselves. This is information about this staff for figures to use when drawing themselves. It also reflects my current position horizontally as I'm drawing from left to right. get the width of the words below the notes. If they are wider than the note head, use this for the width. render the notes into figures. render the words for the first time. render the 'part' string, which is the letter marking used at different places in the music. render the dynamics. draw the time signature on the point at the given location. Update the point based on my width. return the time signature for the given measure. If there is a repeat sign at the beginning of the measure, draw that. Draws the end-of-measure figures We try to spread out the notes on a staff as much as possible. If we do this in a uniform way, this guarantees that we will always line up parts from the same points of a score, if we can. RETURNS: The number of points that this note figure should take up. This will always be at least the width of the figure. ASSUMPTIONS: We assume that the get_leftover_pixels() has already been run, as this will use my_rhs_overlap and my_spare_pixels Go through all the figures in this staff, and figure out how many pixels they would take up. Fill in some class information about how many pixels in all so we can justify the notes. Get the number of pixels a note of this duration shoudl take up, given the number of pixles and number of beats in this staff. Count the numer of pixels taken by measure end things. We use this to justify the music Determine if we need ledger lines and draw them. Draws the little measure numbers on the left hand side Get the width of the barline figure for the end of measure x. Get the width of bar in pixels, once its been drawn. Assumes that the bar points have been populated already. Get the width of bar in pixels, once its been drawn. Create the text figure that goes above/(and somdeday below) the note and compute its x coordinate. The y location is computed when we have rendered the chord and we know where its supposed to go. We figure out the chord symbols, but we can't actually render the chords until we have drawn the figures and beamed them all. Go through the my_chord_symbols and print them all out. Add the description of the voice information to the staff. Get the top and bottom note on the staff to deterine if the ledger lines are needed Get the appropriate figure for the give figure ending. We need to put something near the first beat of a measure, make sure it doesn't run into a note. Render the figures into a list first so we can move them down to a different page if we want to. We create lots of intermediate things when creating the figures. We don't need any of it now so release all the resources. Indicate that all of the fixtures have been added to the staff, no more should be added. the offset where this staff is to be drawn. the measure number I start on. my last measure keep track of whether or not we should try and justify where it all happens... true if we need to show the name on top of the staff, i.e. we're in score mode Map each point in the score with a figure to draw on the staff. We keep 2 around, so we can re-render things fast if we already know where stuff goes. We also store the x location of the words since we compute that at the same time as the note locations Keep track of the places where the barlines go so we don't have to keep recomputing those. Keep track of the time signature. A key signature can draw itself on my. We keep track of the UL part of ourselves, and then we increment the x part as we render the staf from left to right. This is the original origin. We compute the x location of the chord symbols and the y location at different times, to avoid chords and beams colliding. Save the figures in an array and then render them all after the notes have been rendered. Keep track of which is the center pitch for this cleff. That is used to determmine things like beam directions, etc. Keep track of how many pixels are left for notes, after drawing the key sig and stuff. This helps us justify correctly. Keep track of how many pixels over the right edge we'll be going, so we can 'borrow' from wider notes on a later pass. Keep track of how many 'spare' pixels we have for each note so we can 'borrow' if there is overlap. Keep track of the last beamer so that we can add notes to the current beam group as they come in from the parser. We beam grace notes seperately, so keep track of those too. There is one slur object per staff that contains all slurs on that staff. This should allow us to do complex things with slurs like slur around notes. For now we just try to draw it as best we can. a constant scaling the drawing routines so we can fit more/less stuff on the screen. When we add figures to the staff, we want to keep them from bumping into the important things like notes. So make an array of all the rectangles of the figures that we have drawn. Page width in inches If a measure begins with a repeat, and its the first in a line, this is what we draw. This is all the stuff that is required to draw an nth ending. We populate the number ending and begin/end type when we add the measure to the staff, and the other stuff gets populated after we have rendered all the measures. Make the figures that constitue nth endings. Keep track of dynamics that we need to spell out, and crescendos. Return true, this will let a client know that no more music should go on this page. If the first measure is the first measure in a new part, we need to be told that so that we can draw it. General stuff about the current key, staff, etc. Mapped per measure. Keep track of the high and low point so we can adjust our size for vertical justification. keep track of a running total of the accidentals Keep track of which accidentals are being used in which measure This is a bidirectional list with the default node serving as the head of the list. The 'data' part of the default node is not valid and is never refereneced. The default node always exists (even in an empty list) and is used in comparisons to end-of-list List node is the data plus the pointers of a linked list. list_data does all the work of the container interface for lists. This iterates through a list, and also is used to add or remove elements (which in STL is a list function). This is always referenced as a nested iterator within list (e.g. list < T > ::iterator = my_list.first) Acts like a pointer dereference. Throws excepction if the list is empty. Returns a reference. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a copy. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe shallow, reference counted copy. list is an extra layer of indirection so that we can pass const lists and still access the methods needed to perform const-type operations (like copying a list) It also allows us to assign the lists by value and lets the reference counting for list_data work transparently. these are a bunch of predicates to find special elements of a list using find_predicate function. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe get the item that maps to lowest ordinal in the map. Get the item that maps to the greatest ordinal in the map. A key-value pair template class. The key is some type of ordinal type, and the value is something associated with the key. It's used as an element of a map. list_data does all the work of the container interface for lists. Create a predicate for map searches. Allow a user to iterate through a map from some start point to some end point, using the get_item method of map. get the item that maps to the_key, or return a NULL iterator. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a reference. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a copy. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe If there's a place you need to go, it'll get you there I know. Map a set of keys to a set of values. There's a couple of things that make this class special. First off, the map follows a 'worst possible' matching algorithm, which means for example, that the lt (less-than) match type will always return the greatest ordinal for which the lt constraint holds. Second, the map contains an iterator, which always points to the last thing selected. This means that copying one map to another will be an O(n) operation. Frequently the map iterator will be used instead of creating a seperate iterator class. Allow the client to iterate through the list. I'm not sure that I like this since it allows the user to delete an item and not my_last_cursor. But it allows the user to easily dereference all the pointers from a map. The assumption is that this is only used before the list is destroyed. list < kv_pair < ordinal,T > > ::iterator get_iterator(){return (my_list.first());} Add a new pair to the map, with the_key mapping to the_item get the item that maps to the_key, or return a NULL iterator. get the item that maps to lowest ordinal in the map. Get the item that maps to the greatest ordinal in the map. Safely remove an item. Clear out all the element in the map. Get the size of the list of keys/values It is possible for this class to be populated entirely by a copy of this map class, in which case my iterator's my_current pointer will be null. This is never a valid case since even an empty list has the seed element. So perform this initializtion one time if required. Return map < key,value > give map < value,key > . Note that not all maps will have an inverse. Classes that define how iabc handles media. A media is a thing that the music is presented on. Probably the most common media is a window on the screen, but it will include other types. The media is populated with information about the music from a media source, which could be something like an abc parser. A score point is an ordinal type that represents a particular beat in a particular measure in a particular voice. Sometimes we need to sort by voice last instead of first, like when we're playing all the voices back at once. To do this we use the score_time class as an ordinal. Contains all the information that can make a tune, including all the music, voices, key changes, etc. A single abc file could contain many small tunes, or one big one. Sometimes its nice to have all the streams of music information into one map for easy iteration. This function combines the maps in a tune into on supermap. This function sorts by score_point. Extract the music from the tune for the given voice only. same as the other extract, except sorts by score_time The media needs to get a list of voices that we want to display. There may be more voices in the source. Create an abstract class for this. Media represents a place where the music is presented to the user. The media source populates the media with information about the music. The media presents it to the user. Get any resources and parameters neccessary to display the music on the media Notify the media that that's all the music there is. This only applies to visual renderings of the music. Typically abc programs use this parameter to display information about dynamics and stuff. A part info is a bunch of static information that applies to the music, but could change at anytime. One example is the key signature. Get the current set of information for this point in the music. Keep track of the voices in the tune, and allow people to change whether or not they are on/off Return true if this voice has not been turned off. The base class overrides this method to actually present the music to the user The base class overrides this method to actually present the end of the measure to the user information about a particular repeat, including which measure its located in, and nth endings around the repeat. A map of measures to repeat infos. Go through the tune and figure out which repeats go where in the song. Count the number of voices in the tune. Encapsulate a list of tunes, and provide an interface for allowing a user to choose one from a user interface of some kind... Add a tune to the list of tunes. Clear the music out of the tunes, but leave the title and index of each tune. Abstract method that gets the current tune choice from the user. Abstract method that clears the list for new parsing. Allow the client to treat the list like an array to get or modify elements. This indicates whether or not we need to repopulate the box, if data has changed. A media source is a thing that defines the music that a media object presents to the user. The most common example would be an abc parser. Add a music feature (e.g. a note) to the current tune on the given beat. Add a measure feature (e.g. a bar line) to the current tune on the given beat. Look up the measure feature for the last beat before this measure and make it a line break. add a word to the chord at the given time, in the current tune and voice. These are the words that show up after the music. The state of the music that is being played/displayed has changed in some way, for example the key signature. Get the voice info for as close to the given point in the score as we can. We have read in some tunes. Get the tune at index the_index, and return an empty string when there are no more. Clear the music out of each tune. This is done to prepare for a new parsing. Leave the title and index number in each tune so we don't have to redo the quick parse. Remove all tunes from the tune list. This is done to prepare a modified file for new parsing. Start looking at the_measure, the_beat in the current tune, and iterate through the music until a non-rest is recovered. Output to a midi file, and hopefully someday play midi file as well. Get any resources and parameters neccessary to display the music on the media Notify the media that that's all the music there is. Store all the track data for the given voice in the array. Fix the chords so that tied notes actually sound like one note. The base class overrides this method to actually present the music to the user The base class overrides this method to actually present the end of the measure to the user The music for grace notes is stored somewhat deceptively: we give grace notes some time, even though they're sort of 'out of time' to make them display properly. But we need to compensate for grace notes, put them before the next beat and subtract the delta time. If the voice info has changed (tempo, meter, etc.) send an midi meta-event to handle that. Count the beats from the_start to the_end. Make sure we write the midi header if we haven't already. Store the time signature in the music array as a midi meta-event. Store the tempo in the music array as a midi meta-event. Store the track end magic cookie in the array. Store the program change for the given voice in the given stream. Write the given value in midi variable-sized format Keep track of where the next note off point goes, if the point we're currently talking about is beyond that. Go through the array of note off events pending and see if we owe the world any note off events. Spit them out to the file, and return the point where we ended up before any deltas. Convert the internal pitch format to the midi format convert the internal duration format to a the number of midi ticks. Use the current tempo as a guide. Some files don't declare a tempo; here we guess what the tempo is based on the time signature that is used through most of the piece. E.g. cut time tunes go twice as fast. Store the midi data in an array so that we can size if and incorporate that stuff into the MTrk part Keep track of all the music in one map so we don't have to keep switching maps. The music part of the tune. We need to change this for midi reasons, but we should restore the original after we have constructed the midi part. This contains information about the music that's not particular to any single medium and isn't about the notes (note stuff is in note info) information to describe a particular measure, including the number and the endpoint 1st, 2nd ending etc. usually 0. A part point represents a particular beat in a particular measure. Each chord in each voice belongs to a particular part_point Information about a particular part, which in ABC would be called a voice. This is the voice number or part number. This is a union of all things that can be in a tune that are related to the music at any given point. The idea is that you can construct a big supermap of this to make it easy to iterate through the music for midi and display output. The abstract interface to the platform-specific object. The generic mutex proxies to this object, that allows us to create mutex objects automatically. IMPORTANT NOTE: See IMPORTANT NOTE below... A proxy to the real mutex object. The is called the proxy pattern. IMPORTANT NOTE: This mutex may behave differently than some other mutex objects you may have heard tell of. So here is how it works: If you seize the mutex and you don't own it, you block. If you release the mutex and you own it, then you don't own it anymore. If you seize a mutex and own it, NOTHING happens, no count is increased. If you release a mutex and you don't own it, nothing happens. If this behavior is surprising to you, then you probably want semaphore or lock (see below) Allow stackable locking and unlocking of a mutex. This allows you to implement re-entrant methods. Usage: void my_safe_function(){ lock tmp_lock(my_mutex); ... access shared stuff } Implement a threadsafe decrement-and-read operation. This avoids nasty race conditions when implementing reference counters across multiple threads. Draws the actual note part. Also updates beam group. Return the width of the rendered figure so that the staff can do justification. Return the offset of the head, which isn't always in the left hand side. none. Dereference all my stuff. Actually draw self in correct thread. Honor the_should_block, which should be set the first time so drawing occurs properly. Also activate beams and slurs and stuff. Allow the beamer to get set, so I can beam self when drawing self. Accessor functions. We need to keep track of the absolute bounding box once we've rendered these so that we can draw other figures right next to them. We are now on a different scale so all of our beamers and figures are no good. So get new ones. Handle any ornamentation on the note, like tenuto or slurs. Figure out what type of note head to draw and get that from the factory. Keep track of the high and low point of this note and beam group. Figure out what type of accidental to draw, and get that from the factory. Figure out which rest figure we need and get it from the factory. Reverse-engineer the number of dots on the note from its duration. Update the slurer for this channel with the location of the note. A whole bunch of figures for rendering beams, etc. We use this to determine what the scaling factor of all those figures is. The page on which we draw ourselves. This tells us whether or not we need to draw accidentals. This is the chord that we are representing. Where we park. We keep track of this so we can tell how big the whole figure is. This is used when justifying. Keep track of whether or not we have drawn the beam and stuff. The array of accidentaly, maybe one for each note This file contains classes that represent the notes and chords in the music. A note info consists of a pitch and a duration. We also keep an extra flag to indicate whether or not this note is a rest. You can slur to and from a chord to another chord. Allow getting and setting of this attribute In ABC you can use a chord almost anywhere you can use a note, so a chord is the main abstraction that represents music. A chord info is an array of note_infos, plus some additional information about how the music is to be played and notated. Return a copy of this note, including a deep-copy of the array. A shallow copy of the array happens during copy ctor or = operator. Return true if this note is short enough to beam In order to figure out what beat we're on, we need to give each chord a concept of a duration. We say that the shortest duration note in a chord is the true duration, since that should determine where the next beat in a measure will fall. Change the length of each note in the chord by multiplying by product and adding sum. Get the highest note in the chord When we connect 2 chords in a beam we create a 2-directional list, so we can get the next and last in the beam group. (so if foo.get_next_in_beam() == foo there's no subsequent notes.) the number of notes in the chord. Return a string representation of the chord, for debugging Treat a chord info like an array of chords. We want a chord to be treated like a simple type with regard to assignment and concatenation A chord can have an embellishment like an accent. Allow setting and getting of that. A chord can have a description, for example [CEG] can be C. Allow the chord to save its description. You can slur to and from a chord to another chord. Allow getting and setting of this attribute by looking at the contained notes of the chord Return true if this is a grace note stacatto, etc. A textual description of the chord, e.g. 'Am7'. words that go along with this particular beat. The notes that make me a chord true if this chord is the first in a beam group true if this is the last note in a beam group. Indicates that it's supposed to be grouped with a number, like a triplet is. pretty self-explanatory The base class overrides this method to actually present the end of the measure to the user The base class overrides this method to actually present the music to the user This is useful for debugging, since the match method of most of the classes will be overridden, this will allow you to debug other classes by overriding this method. A null rule always matches. It is handy when optimizing the sequence of rules in an 'or' and making optional params. A loser rule is like a null rule, except that it always fails. A terminal is a regular expression, like a variable name A non-terminal rule is made up of other terminal or non-terminal rules. We want to overload the & and | operators to use them in the usual way so we don't make non_terminal be of type 'rule'. Instead we make non_terminal its own class that can be constructed with a rule or another non_terminal. Some rules are made up of other rules. When constructing these rules its more efficient if you just set up your parse tree one time during the lifetime of the rule, and then just keep resetting it everytime you use it. Construct the compound rule if we have to, and then run it. Call convert() if there's a match and return true. return true if I matched last time I tried We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. A '1 or more' compound rule. Calls repeat_match until the match fails, and return true if there was at least 1 match and no syntax_error was raised. Try repeat_match 1 more more times, then call convert if there is a match. Keep going until the match fails. We are iterating through the_iteration and we need to make sure that the arrays have been created up to this level, if we have never been at this level before. We also need to make sure we've reset the rules at this level before we try the match. We have matched on the_iteration. Extract any information we need from the rules before going on to the next step. This is where we call the actual match. These are the non-terminal rules that make up this rule. They are an array such that the n'th iteration refers to the n-1th rule. The array is populated by calls to create_complete_rule. This matches a string delemited by matching characters. Probably the most famous of these is a quoted string. A word, in other words not spaces key = something, chop off the '=' part name-value right hand side, either a word or a quoted string. name-value pair, for example: NAME = VALUE Representation of a pitch. Consists of a letter note, accidental, and octave. Returns a string representation of the pitch, but not an ABC string use abc_string for that. Returns the pre-parsed value of the string. Used for transposing ..toABC things These can be used by clients keeping track of accidentals to decide what needs to be displayed/played based on what has been played thus far in the measure and the common rules of music notation Change the accidental to compensate for the key or the forced accidental. The assumption is that the changed accidental is already added to the map. return true if the accidental for my_letter in the map is different than my_accidental, or if the accidental doesn't appear in the map at all. Return true if there is an accidental for my_letter in the map. Represents an arbitrary shape that can later be rendered on some type of device. Most of the operations that can be performed on this objects are derived from the postscript language (loosely). A polygon can be transformed the same way a window can. When we transform a polygon we only apply the transform to future drawing operations. If you want to change the transform of the whole polygon you need to apply the transform and then redraw all the points Allow the user to set up the zoom and offset in x and y directions This class is used to represent a point in the drawing of the polygon where the drawing actually occurs. This lets us represent more complex shapes in one polygon. returns the extreme points of the polygon. Allow the polygon to be treated like an array of points. Many figures are actually multiple sub-figures. The sub-figures are either filled or outlined at a certain index into the array. This sets the next fill point at the current index (the index that was added last). This sets the next outline point at the current index (the index that was added last). Follow the same set of commands that was used to build 'o', when creating a new polygon. This can be used to render polys on a different scale (like on a printer). this is used by clone() handle expandable array. We figure that this object will be rendered seldom but referenced many times, so an expandable array will be best. return true if we must add the current point in a lineto or curveto operation. We need to do this is the last thing was a moveto or moveto relative. Implement Bezier curve by replacing a n point array with n + 1 midpoints. Return false if we can't bisect the midpoints because they're too close together. Keep track of the size and some special points of the polygon Keep track of whether or not we need to recalculate things. This speeds things up when referencing the size of a polygon many times. Abstract the behavior of a file so that it could work on any text buffer, such as a text editing window. free up the resource so that it can be used by others. Make sure the contents of the text_file object match the contents of the underlying buffer. set cursor position to l Open the text buffer for reading. Return the current position of the pointer into the text buffer. get the next character in the buffer. Return text_buf::eof when the last position is reached. set the position of the next read to the_pos; Refresh the text buffer with the persistent representation. returns the last time the buffer was changed, so you'll know if you need to reparse it. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. A stdio file implementation of text_buf. Used for unit testing and development. free up the resource so that it can be used by others. Return the current position of the pointer into the text buffer. get the next character in the buffer. Return text_buf::eof when the last position is reached. set the position of the next read to the_pos; Preprocess an abc file. Scan through the comments and return completed lines, including lines seperated with '\'. Move to the position of the given line number. Get the offset (for getpos, etc.) that we corresponds to the beginning of the given line. return true if the file has changed since this was opened. Count the lines, and create the line to position map for the buffer. Keep track of which index is which line, so we can get there fast. Classes that implement a simple platform-independent persistent registry for a program, that manage a list of name-value pairs from a .ini file. This can be used to store preferences, program state, etc. The form of the registry is: [category] key1=value1 key2=value2 key3.subkey = value3 A registry key is a set of strings that can be associated with a value. The strings are arranged in a heirarchy so that we can sort them and peruse them. Parse the string to split on the '.', which allows entries like: LASTFILE.1=foo.abc registry_entry is a registry_key + a string value. An entry can be put into the registry and looked up later, based on the key. construct a registry entry based on the strings. construct a registry entry based on the key an a value. construct an empty registry entry. change the value of the existing key. Indicate whether or not this registry entry should be written to disk when a flush() is performed on the registry. Allow the user toe store key/value pairs persistently between releases. It is similary to a windows .ini file, hence the name, but it works cross- platforms. Create a new registry instance, and initialize it with values from the_filename. Future flushes of this buffer will also be written to this filename. look up the registry and return the value associated with the given key, or an empty string if no such value is found. look up the registry and add or replace the given entry. write all values marked as persistent to the file All the class needed to implement a semi-functional, extremely slow regular expression scanner In order to get all of the state machine creators created we need to explicitly reference them somewhere. Do it here, for the linker's benefit. We will construct a state machine to implement our regular expression scanner. Each state in the machine will implement the following interface. We construct a scan state with 2 variables: the previous state, which could be used for things like wildcard matches, and the group number, which can be used to remember previous matches This is the main public module for a scan state. Match the_string starting at the_index. If this state matches the string at the_index, increment the_index by the size of the string we matched and return true. Otherwise the match failed, return false and leave the_index unchanged. Parts of a regular expression can be grouped. The groups are assigend indices and can be referenced if they are all matched. States are assigned group numbers when they are created. Return the group number we were assigned. return the minimum that this state can match and be satisifed. If the remainin string is less than that, we know we're done. Return the matched string, or an emptry string if no match was found. This actually implements the match in the derived class Some states have internal state that must be reset before another expression can be matched. This does that. return the length of the string that this state has matched. The state machine is constructed based on an input string. So we have to scan the input string before we have a state machine. This class will construct a scan state based on the input string. For example, the '\d' input string will construct a digit-matching scan state. Static method. Regexp can call this to create the next state in the input string. This will return a state if the next input token on the input string matches the string the scan_state that I know how to create. Note when implementing this method in a derived class, make sure that you increment the_index if you create a state, or you will loop forever. match A-z or 0-9 or an _ Make \w match a word character. Define some simple types that are useful, like point and line and stuff. A 2 dimensional point, and some usefule operations In order to create an ordinal type out of 'point', assign the y value arbitrary importance. same as point Define a fraction as 2 int's, and some useful operations a floating point version of size A line is just 2 points. A rectangle is 2 points also, but it's treated differently These functions are used to map a point from one rectangle to one of a different size. Handles all the slur points for a single staff. This will allow it (in theory) to keep the slurs from running into each other. We discover slurs by matching open/closed parens in a LIFO way. Each time we get a new to point, we match it with the last 'from' point and add it to the map. Then we draw the map from left to right. We try to normalize around 0,0. That way we can draw the slurer on the page where it starts instead of having it always offset from absolute 0,0. Makes the page logic simpler since 0,0 is always on page 1. remove the last character Clear out the string Allow a string to be drawn on the given window in the correct thread. Handle the dispatching to the GUI thread and the correct placement This gets the current rectangle from the current string. Do the same things with words. Calculate all the size info about this string in this font. This is true if we need to call calculate text info Template files for handling notification of concurrent things. This is various interpretations of the observer pattern. Encapsulate a multi-type container. This class acts as a proxy to another derived wd_data, which contains an instance of some type, possible a built in type, which is passed as a parameter to a dispatcher function. A derived wd_data, with the parameterized type which detemrines what the real type is. It can be used in the place of a < type1 > parameter to a dispatcher call. Abstract class that allows a client to get reports of GUI things to him using the observer pattern. This is a template class that allows the client to be a selection handler (e.g. receive selection events) without having to inherit from selection_handler himself. But he needs to implement the handle_selection method. create the class with the object that is getting notified as the parent. This is the method the widget calls to get the events to the user. This is what calls the handle_selection method. The client class that we notify. This is the type that the client creates. Usage: my_tree_ctrl- > add_selection_handler(selection_handler_dx < my_type > (*this)); Create the data that is reference counted and initiaze it with this parent. If the parameter is another instance, add ref to my data object. Remove the reference count and delete the object if need be. Call the select method of the data object. Iterate through the music and populate the graphical interface. We use a template because the iteration actually uses different clients depending on whether we're in score mode or not, but everything else is the same. There will be other media types, such as: midi device output, printer output, midi file output, but for now the only one is window output. As other media types are added they will be moved into their own files. This accepts musical features from a media source and renders them on some type of window device. This is supposed to be where the media gets set up to receive the music, but it doesn't really apply to a window getting music. This didn't really work.... This is called when all the music has been added to the media. It's a sign for the media to start drawing itself. Here we just render the music one page at a time. If we are in part mode, consolitdate all the rests into blocks where possible. Sort the staffs in order from lowest to highest on the screen Move all the staffs so that they don't overlap one another. Add the header and footer to the given page. Make the musical feature come alive on the window. Usually this creates a note figure and puts it on the correct line_of_music. render a feature that revolves around a measure, such as a bar line or repeat sign. Transpose the note up or down the given number of half-steps Transpose the note up or down the given number of half-steps We've read in the music, and stored it, so now its time to render the music. RETURNS: the number of the next page; 0 if this is the last page. Handle the big 'W'. Just draw the words centered in the window at the end of the song part. We've put together a bunch of staffs and added the music to them, now go and do the drawing of them all at once. Set the dynamics in the staff, if they've changed. Add the staffs to the pages, compensating for the offset and adding new pages when necessary. If we are in score mode, return the number of voices. Otherwise, return 1. Create a note figure from a note info and add it to the staff. We have rendered all the notes in the measure, now complete the measure by adding the figure that goes at the end, and the figure that starts the next measure (e.g. a begin repeat) to the appropriate staff. We keep a map of places in the music to the staff objects that go with it. Look up the staff in the map that is less than or = to this point in the score. If this is the first such request there are no staffs for this voice, create the initial staff and return it. To keep the staffs from running into one another, compare the points to the previous staff. Figure out which nth endings go on the staff. We have changed parts so we weren't reading the music in in order. Get the points we saved the last time, and save the current point of measure and chord for when we change back to this part/voice. x and y scale and page size an array names that contain the voice header name information (e.g. trumpet2). There may be one of these for each page. We have a line_of_music. We want to see what the offset is info this window so that we can put it in the right place. Handle the work of creating a new staff instance given a point of music. We assume that the client wants to actually create the line_of_music if they call this function; no check is made to see if it already exists. Return true if we are in score mode. This is where we do our thing... Used to determine whether or not a thing is in the window range A map of staffs to parts/measures Keep track of the staffs as we draw them so we can space them properly Keep track of the staffs and then render them all at once. Keep track of the staffs that we have started so far. These keep track of the pages. The last point I rendered, used to update the system a little at a time. Keep track of all the music in one map so we don't have to keep switching maps. This is the map we use if we are displaying in score mode. Keep track of which screen lines the staff is on so we can do GUI magic later. Generic window classes. We want this to be as portable as possible so we make the base classes do as much of the work as possible A generic resource associated with a windowing system. This could be a font, a pen or a window itself. Keep a reference count so it gets deleted at the correct time. Decrement the reference count and delete if its zero A template class that will cast a window resource to its derived type, or return null A canvas is really a window, but we use it to get around the circular dependency between a window and the resources that can draw stuff in it. We make the assumption that it doesn't really make any sense to have a pen, color, whatever unless there's a window to go with it. A pen that can draw on a window. We create pens and fonts based on a particular window. Avoid memory leaks by derefing all pens still owned by this canvas. Hopefully by now any clients that keep pens around have been removed. A font class that can write text to a window font_data allows you to specify a font in a generic way, and then get the font for a specific system. get the font from the list of fonts that this window knows about, or return NULL if this font has not been created yet. This can be called from outside the windows thread and will not switch threads. Return the bounding rectangle that you get if you draw the_string using this font. This is like the windows view/document architecture. A document gives the window something to nofity when its state changes, so that the document can render itself in the window properly redraw the rectangle the_rect in the window, as this part has changed someone has clicked on the area of the window that contains this document. attach a canvas, which is really a window, to a document Detach a document from a window, so that we can destroy the window or the document. Print the given page Finally we have enough information to define a window. Mostly a window object represents a real system window, and the methods transform from the logical space of the application to the 'real' space. The interface also allows almost all drawing to occur in a generic window without any real system specific stuff. A linear transform on a thing that consists of multiplying by a scalar and adding a scalar offset A display context is the current linear transform that operates on stuff that gets drawn in the window, and the current point (the turtle) that we're drawing on. Each window has a name, you can get a particular window by knowning its name and calling this static function. create or get the font that has this typeface as a family name (e.g. Times). Get the pen that draws in this color and has this width and drawn on this window. pixels_per_inch return the pixels per inch that can be drawn on the current window. This is used by things that render shapes on the screen. This can be used to refresh a region; also it is called by the OS when the screen is refreshed. Otherwise known as redraw. Refreshes the whole screen. Sets my document to the_document. Also notify the document that its got a windoow, things are gonna be different from now on... Used when the document is being destroyed. Remove my reference to it, and set my_document to 0 so we ignore any pending events. Scale the point size such that it is proportional to the size of the window. We need to do this since the mapping mode we used is pixel-based. make the given point the central point visible on the screen. Make it virtual but not pure virtual so printing doesn't have to fake it out. Remove all text figures at the given point Classes to help manage the dimensions of the pages, without any windows-specific stuff in it. This is the interface that describes how the pages hold the figures. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure with the given string, and sort on the given point. Allow other classes to act like a page class. This allows us to implement the same interface as a page without having to inherit from anything. A structure to keep track of the settings of one page. By settings I mean page size, things like that. This is all the figures in a page, along with information about the page itself. Add the title to this page. Add the copyright information to the page. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure with the given string, and sort on the given point. Redraw all figures who's bounding rectangle intersects the_rect. Remove all figures at the given point. Remove all text figures at the given point Re-render all the figures on the given window, by stretching/ compacting the figures based on the source and target rectangles. Disallow erasing the image before draw, as on a print. Add the offset to the figures before they're drawn, as on a redraw. True if we should erase before redrawing. False on printing since there's nothing to erase on a blank page. This is the interface to page_contents, which includes copy operators and reference counting. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure, and sort on the given point. Redraw all figures who's bounding rectangle intersects the_rect. Based on an absolute pixel offset, figure out which page we're on, or vise versa. Return the important parts of a page like the title rectangle Add the page to the array, if it doesn't exist. Given a page number, Create all new page objects using the target window and scale to get the dimensions to draw on. We can also take a point and figure out which page we're on. Iterate through all the pages, and refresh any pages that intersect with the_rect Render the page, but fix the UL to be 0,0 This is the main application window. All the events that can happen in iabc come through this class. The main window is divided up into 3 panes, for the music, the tune list and the abc text. This mostly created those and also creates the main sub objects and timers that define the application. Make debuggin a little easier by putting the init stuff into a different function. Prints the version. We provide a menu option to allow the user to dump the event log to a file. This helps me debug problems that occur. This will attempt to start a web browser that points to the included documentation. But the online docs are probably better. The user wants a clean document. Handle save issues and create a generic tune. Open a new file. gets the file name from the user and sends the parameter to the iabc_media_manager to handle. The user has requested to display the music in 'score' mode. Display the 'view preferences' dialog that allows the user to set a variety of display parameters. Allow the user to set up some parameters regarding the ABC language and how the parser works. Display a dialog for changing the editor font. Save the current document. iabc dispatch model uses the wxWindows event pump. This is the system entry points for events that are dispatched to the windows thread or other threads. The user has pressed the ctrl-L combination. This will call the function in iabc_media_manager that re-parses the file and refreshes the tune. Also save the current cursor position so that the user is in the same place after the refresh. Play zha midi, ja. Handle the logic to set the midi player, for the OnPlay command. Allow the user to export the document to midi. Print the current tune using OS-specific methods. Handle the Ctrl-x character sequence. This gets sent to the text buffer window. Handle the Ctrl-c character sequence. This gets sent to the text buffer window. handle the Ctrl-v character sequence. This gets sent to the text buffer window. Handle the 'undo' command - poorly. This needs some work. The big 'X' has been clicked, or exit from the menu. This is called one time during creation, we just use the generic windows code. Recalculate the sizes of the window parts. Someday I'd like to allow the user to undock different parts of the window. We try to keep the music and the text in sync as the user is typing. Every tick we check for changed text to move the cursor and do some other periodic things. The user has selected some text and chosen to transpose it. Call the code that handles this. Setup voice options. The dialog box doesn't do anything yet but this will let the user show/hide voices. Show or hide the window pane with the tune list in it. Confirm save before exit. Some key events that get received in the key area don't get handled by the text buffer object, but have a global effect and must be handled here. Returns the point in the text buffer where the cursor is. Documents can be opened a couple of different ways, this performs the actual open. remove the object and close the window. This constructs the command line string that we use to launch the midi player. Utility function to generate a random file name. create the main window's menu bar. true if we are initialized enough to handle window events. This is where all the music-rendering and parsing action goes on. handle the 500ms tick. These files all have to do with GUI artifacts used to get information from the user to an application. Don't do this because we will delete these explicitly since its a widows resource. A nested list of things, a widget that really everyone else calls a tree (and maybe someday I will too) helper functions to convert values from dialog boxes into globals of various types Stuff to handle property pages. A property page is just a way to get preferences from the user. set the position of the next read to the_pos; Update the text contents with the contents of the underlying wxTextCtrl buffer get the next character in the buffer. Return text_buf::eof when the last position is reached. free up the resource so that it can be used by others. We need a way to pass some key events to the menu frame so we can bind 'hotkeys' to menu items. This abstract class allows us to do that. This is our derivation of the text control class. Right now we just update the cursor position when the user presses a character control. Someday maybe we will do some brief-style formatting. Update the cursor position in the status bar. Some key events we handle and don't pass to the default handler. Return true if that's the case. Call the default handler and return true if this is an event that has changed the buffer. Keep track of the last time the buffer was modified so we know when to require a redraw. Lets us update the status text based on cursor position change. give the main window first dibs on keyboard events. A buffer class that implements text_buf, which has pretty much the same interface as FILE* stdio. This is so our preprocess class can treat this like a file text buffer. Return the current position of the pointer into the text buffer. set the position of the next read to the_pos; get the next character in the buffer. Return text_buf::eof when the last position is reached. free up the resource so that it can be used by others. Load the contents of the file and refresh the internal string. return the file name that I was opened with. Get the last time this control was modified by the user. We return the lesser of the modify/redraw time, since what the user really wants to know is: have the contents changes since last I redrew everything? Update the status bar with the new position. There to satisfy dispatcher Return the point of the 'carat' in the text field. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. Set the modify time of the underlying file to match the underlying file's modify time (so we don't keep reloading the file) Returns true if the file underlying the control has been changed since my_last_modify_time. Return true if the contents have changed. Load the file if it has modified since we last read it in, or if we never read it in yet. GUI thread method to interact with windows. GUI thread method to insert the carat in the file. The underlying windows object. The scanning thread sets this to true if the underlying file has changed beneath the buffer. used to control the exit of the scanning thread. This stuff is kept track of so we can access it outside the windows thread. The modify time of the underlying file. Use this to keep track of when we need to load the file into the buffer. The last time we've redrawn the graphical music. Under MS windows, the control has an extra character for each return character, so handle that here. A place holder to break the dependency between resources like wxFonts and the windows who love them. Create a font in the correct windows thread. wxWindows implementation of the font concept. Return the rectangle that would contain the given string. This method can be called from any thread, since the geometry data associated with a font is not stored when the font is created. A pen to draw on a window. We need to derive from the wxWindow object to handle the events like scrolling and screen updates, event though we have our own window object that does all the real window stuff. Proxy for the wxWindows device context, which needs to be established whenever we draw something on the screen or print something. This is the actual window that we draw on. It also acts as the event source for events and dispatches. Constructor. Give wx_window its drawing area. show/hide the window. Gets the window dimensions. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. The reference count has expired us and we are gone. Sets up the DC to draw with the selected pens. The contents of the document have changed such that the size of the virtual window needs to be updated. Draw a rectangle on the screen with the given pen. Draw a line. Draw a string in the current location. METHOD: Draw the polygon in the current location. Redraw the window in the given rectangle. return the absolute visible rectangle. not used. Determine whether or not we are printing and get either the visible or printable area. Store the ppi so we don't have to re-render it all the time This is a class that is used for drawing on the screen, in that it can handle scrolling. It needs a specailly derived instance of wxWindow for scrolling and handling scroll events. Move the scroll thing so tha the given position is where the top of the scroll point is. The document calls this when the contents of the document have changed such that the scroll bars need to be re-sized. Redraw the window in the given rectangle. virtual void raw_refresh(const rect & tmp_rect); not used. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. Like the scrolling window, but does not accept callbacks since it doesn't get redrawn. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. This is set when we are prepared to print. set the print object to be the_printout and defer rendering for awhile until the pages have all been prepared. Set the printout object to NULL and do all future rendering on the screen DC. Get the rectangle that describes the supplied page, and redraw that page. return the absolute visible rectangle. The printout object that we will be printing on if we will be printing on something. If my_printing rect has some area to it, accept drawing commands over that area. Derive from the wxPrintout and do the stuff we need to. Defines the entry point for the application. Every application needs to create a derivation of hte wxApp class as an entry point. Define a new application Create the main appplication window frame, and initialize all of the pre-ordained dialog box objects. This is called when the main window is created. We make the window visible here. Do some garbage collection and other cleanup, if you are debugging for memory leaks this may be useful. Boilerplate stuff for the windows message pump. the frame is the main application window. Define most of the dialog boxes and similar gadgets that are defined in this program. A text widget in a dialog box. Acts just like a wxTextCtrl combined with a sizer. Create the widget and bind it to the parent window release the resources Act just like a sizer to the client Set the value of the widget The label for the control the control itself the parent sizer Act just like a sizer, allow the user to make boolean choices. Implemented as a checkbox probably Allows the user to choose a number with arrows up/down that increment /decrement the values. Just displays progress for a long operation The dialog box that contains all of the display choices like page size, etc. The dialog box that contains all of the display choices like page size, etc. A dialog box that allows the user t ochoose some options that affect the parser. Allows the user to choose midi player, etc. Each major window in wxWindows consists of a frame and a canvas. Define the frame. The canvas is described in wx_winres.cpp. Abstract method that gets the current tune choice from the user. Abstract method that clears the list for new parsing. ======= This is a static class (utility class) that keeps track of the state of some things in the parser that are global. Like how many '(' we've matched so far and what the note duration is. Usually this state lasts throught out the course of a single file. There are 3 ways to represent a duration. One is as a fraction, e.g. "1/4" for a 1/4 note. This is the whole duration specifier in abc. It also contains the default duration, which all duration rules use in case the duration is not specified. Note that the default duration for a note is handled internally in this abc parser. When a duration is read the value is computed in terms of the current default, which is handled in the parser. X: \d+ describes an index field. This maps titles to tunes. C: By Aaron Newman (c) 2003 H: This class was written last Tuesday while Aaron was supposed to be doing the dishes. T: the title rule. Describes a title. Add to the current title if we are still in the same tune (which you can tell by looking at the last index) The M: header rule The meter specifier in ABC. This also acts as the source of the current meter in ABC. ALso, I frequently call 'meter' 'time signature'. This is the voice change that can be at the start of a line of music. The letter note rule is part of the pitch. An octave as defined by '' or ,,. We'll need to add the octave header somewhere too. A part is a section of music called out by a letter or number above the music. The entire key header rule in one take. We need to know the key before we know the pitch since we will adjust the accidental accordingly. Get the key the user wants, and return the number of characters that should be skipped to get to the next thing. Get the key=value pairs that can trail a key declaration. We occasionally delete the key regular expressions since the take lots of memory. Construct them before use. The accidental that can preceed a note. A pitch is a letter note, possibly combined with an octave and an accidental. The end of line, which could be a repeat, bar line, etc. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. Return true if there is a match of a header inline a piece of music. A note_info is a pitch and a duration. If no duration is given the default one is used. Sometimes the pitch was not changed but we received an inline header instead. Return false in this case. many notes, glommed together. Used to put together chords and also single notes. Both the header rule and the note info rule can be enclosed in []. Figure out which here. A chord in abc is a single note or multiple notes within a pair of square brackets. The hornpipe rule is a funny little abc'ism. The fraction produced by this rule is interpreted as follows: multiply the default duration by 1/2^#, where # is the number of < or > s. For < ( > ) Add that to the LHS(RHS) and subtract it from the RHS(LHS). This usually (always?) results in a dotted rhythm For some reason abc allows a space between the closing note in a beam group and a closing paren. Have a rule that does that. For some reason abc allows a space between the closing note in a beam group and an opening paren. Have a rule that does that. The dynamics that ABC knows about that can be displayed on the screen or via midi. some things are defined within the '!' fenceposts We glom these together under the bang rule. We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. abc allows space after quotes and before the chords they accompany. Handle it. We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. This is the stuff that can occur between the notes in a chord or at the end of a chord. This rule will match almost everything in legal abc that is expressed as multiple chords run together, except xlets. Note: here is where we start counting paren's for slurs/ties The V: command, which does many things like we said before Matches a voice header. Depending on whether or not we're allowing text-based voice rules, proxy to the correct object. In abc a beam group is defined as any set of chords without a space. These are the words that actually go below the music. These are the words that are written free-hand below the music. Classes to handle arrays of arbitrary types. The array class uses the smart pointer pattern. The memory allocated for the array is handled here. Clients of the array classes should use array < > and not array_data. A parameterized array class that allows effecient assignement and shallow copying. Create the array. Args are optional. No argmunts creates an empty array. int the_initial_size, the number of (un-initialized) elements in the array at creation time. the_grow_size is the number of elements that we add when we expand the array. dereference the underlying data, when all references have been removed the data will be deleted. Create un-initialized elements until the array is the_index+1 elements. create num_elems additional un-initialzied elements in the array. return the number of elements (get_number_elements would have been a better name) return the element at the_index'th position. dereference my data and reference the data of the_other. remove all the elements and set the size of the array to 0 Remove the last element of the array, effectively shrinking the array size by one. copy all elements of the array from the_intput to the_output. Assumption is that the underlying arrays are not the same. Invoke the_predicate(the_list[i]) for each element in the array. Beamer draws beams and flags on notes. A note tells the beamer its coordinates as it is drawn, and the beamer computes the coordinates and shape of the beam and stem. Call the base class figure constructor with the screen dimensions. Since we beam according to note heads, we can't just map our points to another space; we need to actually clone the note heads first. virtual figure* clone(const rect & r1,const rect & r2,const size & ppi); When a note figure knows its coordinates, it calls this method to tell the beamer to add this note head to the beam group. If there is no beam group then this note receives a stem but no beam. Unlike other figures, beamers know where they're really supposed to go. Return that absolute point, and everything else is relative to that. This makes it easier to move around Get the points where the little xlet descriptions are supposed to go. Get some geometry information about the figure so that we might draw it correctly. For some notes, like with SATB parts, we like to force the beam to go a certain way. Return true if the value is either less than the level of the beam, or is a dotted level of the beam. The figure virtual method. The window wants to draw the beam so its time to render the shape. Draw the little number and the bracket associated with triplets and other xlets. return true if this value is a dotted version of the_base. These have different flags than triplety things. The figure virtual method. Most figures use a bogotwip coordinate system based on PostScript. But this shape is drawn to absolute screen coordinates, so set the linear xform for this polygon to 1:1. Get the highest connection point in our beam group. Get the lowest connection point in our beam group. A helper function to create_beam, that actually draws the beam and makes create_beam a little less complicated. The draw_half variable indicates whether we draw the segment all the way to p2, or only 1/2 way. the_left says we are drawing from left to right. -------- --------- |-- | | ----| | | | | | | | | 0 0 0 0 half = true, left = true half = false, left = false If we need to put a tail on a single unbeamed 8th note, do that Offset the connection points depending on whether the stem goes up or down. figure out where the high and low points are. Create the stem going either to the beam or just up. The depth in pixels of the beaming figure between note heads. Beams always go up. If the beam is actually down we need to start it below the note. Where the note goes on the staff, sometimes used to determine the 'upness' of the note head. Some interesting things about the geometry of the figure. This is the place where the note heads go. This is the place where the beams go. This is for clone array < point > my_original_beam_points; The xlet values that will be beamed under/over the beam groups Keep track of where the descriptions of the xlets are supposed to go. We can't draw them because we don't know about fonts and windows and stuff. Indicate whether the beams go up or down. 1 or -1 if we are forced to beam up or down, otherwise it stays at 0 Keep track of the durations of notes so we can beam them The note head that goes on the note. True if this is a grace note. The command we are trying to send to the window will be embedded in a wd command class. A derived version of this class will actually be called in the correct thread. The dispatcher requires a window to send the command to. Implement reference counting so the window gets destroyed when everybody's done with it and not before. We assume that there's always 1 'main' window that is always available to dispatch your commands for you, if you need to dispatch something but don;e know about a particular window class (which is often the case with dialog boxes). A dispatcher takes a set of wd_command objects and queues them up and sends them to the correct thread. If we are already in the correct thread and blocking is on then we execute it right then and there. Derivation draws the thing here. Derivation draws the thing here. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Derivation draws the thing here. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Derivation draws the thing here. Classes to handle events safely and efficiently The interface to an event handler, that an event source knows about. This breaks up the circular dependency between source and handler using the obserer pattern. Event Handlers and event sources need to keep reference counts to each other very carefully. A source object call this instance of a handler that it knows about. A class that represents an event that could occur. It is capable of notifying event handlers that the event has occured. An event handler wants to be informed if this event fires; Add it to the list of events we notify in the event of an event. The event handler no longer cares about this event. Remove it from the list. The event has occured! Notify all event handlers that the event has occured. Before and after the event handler adds the event, there may be special things that we need to do, like set a timer in the case of a timer for example. Protected method that actually adds the handler to the linked list. We need threadsafe access to our internal list, but we can't block while we're notifying events. So we just deep copy our internal list and we don't have to worry about the list changing underneath us. An event handler can block on events until they occur. Many event handlers can be or'd together so that we can wait on the first of many things at once. Add the_other to the list of events in this event chain. Set the event source for all the events in the chain, and then pend on the semaphore that indicates that the event has occured. This is the part that must be derived. Each instance of an event handler should know how to get an instance of the source that it can wait on. This is called when the event source fires. The event chain will then be torn down and the thread that was waiting on the event will be allowed to continue. Allow an event to be reused. This is the actual source that I am waiting on. The generic logic that calls GetEventSource. An excpetion is thrown here if the event source already exists. the_next is an event handler in the chain. This is used\ when setting up the 'or' chain. Only one event in a chain is the 'first', which is the one that ends on blocking. Make sure we always release the block from that point to assure deterministic behavior. The pending has ended. The event has fired. Tear down the event chain. When handling events in chains, the actual values can be zeroed out underneath us when the chain is released. Prevent the events and sources from being released prematurely. The semaphore that we are pending on. The other events in the chain. Log all kinds of events and changes in program state. Not to be confused with events, which are a specific concurrent type. Most events have this data in common so we have a class for it to save some typeing. A container for event log data. Methods used for printing, logging. The data that is actually in the log is implementation-specific Initialize the common data. the_size is the number of events and the_num_params is the number of parameters in each event. When printing out the events, we use get_first_event_index to get the index of the oldest event in the circular queue When printing out the events, we use get_last_event_index to get the index of the most recent event in the circular queue Return the number of events in this particular log. Print the log entry into a character buffer in human-readable format. Dump the entire log file to the stream f. return the timestamp for an event log. the number of events in this log the current index into the circular buffer. true if the event log has wrapped. The number of parameters in a single event. Most event logs are exactly the same except for the strings used to describe the numerical parameters and the number of parameters per event. This template handles all of those types of events. The title is printed out before the entire log is dumped. Store an event in the event log array. The enumeration is one of the types of events defined for EventType Implementation of the interface described above. Implementation of the interface described above. Some event logs have variable-sized events. Each event generates some text that is variable size and some numerical events that are of fixed size. Log the event. The first parameter is the variable-sized part, which is represented as a character string. Implementation of the interface described above. Implementation of the interface described above. the log of event data. the array for the variable-sized character data. A single windows event. The interface allows the template class event_log_template to manage these events. The strings that describe the events and their parameters. A single dispatch event. The strings that describe the events and their parameters. The lifetime of a document and things that happen to it. The strings that describe the events and their parameters. A figure (e.g. a picture of a note) has changed. The strings that describe the events and their parameters. Data to log a single event. The strings that describe the events and their parameters. A single parser event. This is some data that is common to all events The strings that describe the events and their parameters. A single parser event. This is some data that is common to all events The strings that describe the events and their parameters. The strings that describe the events and their parameters. The strings that describe the events and their parameters. Define a template for a function that returns an instance of a class where the actual create function is defined at link time. Define a static instance that is guaranteed to be created at the right time if it is referenced before 'main'. Good for class factories. Define a renderable thing. The abstract method render_poly must be overridden to define the point in the polygon. Additional virtual method control scaling, composite objects and other goodies. This will come in handy to describe a figure and the point where it is to be rendered. Since rendering in abcmacs is done in bogotwips (100*twips), we need to make sure that we know how many pixels to an inch. The figures work out best if we transform to screen coordinates when rendering the figure rather than rendering in twips and fixing it later. Create a new figure based on this figure Reset the scale. Since we render on a scale-specific canvas, that means re-rendering the polygon. Note that, since many figures are shared between many clients, re-scaling a figure could have strange results if everything else isn't rescaled, also. Handle reference counting Get the extreme points (leftmost, etc) points in a figure. Returns size in pixels and ul in terms of offset from starting point Return the bounding box of the rectangle if it were drawn at the given point. return the middle point of the bounding box that surrounds the figure. You can get this from the size one, but its useful by itself Draw the figure in the window thread at the point the_origin on the window w. Returns the topmost, leftmost, etc. actual point. Good for connecting figures together. Remove references to contained figures. method called by dispatcher template class. This method will always be called in the windows thread. Derivation draws the thing here. Render the polygon, either so it can be drawn or for sizing. Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. The pixels per inch that we use to reference our points. The scaling constant we use when deciding how big things are. The polygon that defines the figure. True if we have rendered, so we only have to do it once. reference count, delete this when 0. set the pen width for drawing this figure before rendering. Sometimes, especially for outlined objects, its good to get the pend width based on the scale and ppi of this object. Do that here. Indicates the pen width is scaled. I added this when I realized that cloned_figure broke my scaled_figure inheritance, but left the scaled_figure class out of laziness. A figure that uses a pen width based on the current scale. A cloned figure uses the polygons from a figure class but maps the points to a different rectangle. We have to re-render the polygon in order to handle the different scaling without aliasing. ctor Set the scale of the drawing surface. Many of the drawing routines we have use twips in a postscript-like coordinate system, but some are in absolute pixels. The default behavior is the postscript like scaling. Create and manage figures that are fixed. that is, they have the same set of points regardless of where the center of the figure is. Geometry Management. Stand-alone functions that compute coordinates of things in relation to a staff, but didn't belong any place else. Basically these functions will compute the correct spot to place a note given some basic information about the note and the staff. Compute the coordinate to place the figure, if you want it to represent the_note place on the_staff. Find the height of the note, if the staff height is the_staff_heigh and the center of the staff is center_line. Value is offset from the center of the staff. Get the vertical placement of the given pitch, if the given staff is the_staff_height. This class reads in an abc file, and converts it to the universal internal format. Then it sends this internal music to the media for the music to be realized. Store the file that we will open later and try to parse. parse the input file and tell the media what we've found so the music can be realized somehow. The buffer has been modified. Set up the last modified time as the current time. Return the line that the tune we just partsed started on. We have parsed a file. Now display all the music. We have changed parts so we weren't reading the music in in order. Get the points we saved the last time, and save the current point of measure and chord for when we change back to this part/voice. Get the current tune selection from the GUI, and also save that in the registry for next time we open the file. Indicates whether or not we have parsed a file already so we can display different parts of a file without reloading the file, which can take a long time if the file is big. The number of tunes in the parser, used to see if we need to re-parse the file. This is it. There is where the parser is created and the window that the parser draws on is created. It must know about all things including wxWindows stuff because it creates things explicitly Display a list of tunes that the media read in. We need to use the tune box to do this. Allow a user to open and parse and iabc file, then display it on a window somewhere. Also handles printing and midi. someone has clicked on the area of the window that contains this document. Do many things. Handle the entry point of the thread. The parsing and construction of the music is done in this thread. Handle where the user has chosen a different rendering scale. send it to the printer in wxWindows Someone has created a document and is now attaching it to a window. Let the window know that we exist and keep track of it so that we can draw on something. The document is closing or has closed. Its no good anymore so remove all references to it. Start the thread and parse the same file again. Indicates that the parse is still on-going so we can't respond to the drawing commands yet. Document method that returns what part of the window a page in a document occupies. Used in printing. Open the following abc file and parse it. Create a midi file based on the current tune. Close the file we were just looking at and free all resources. Usually for printing, return this information Choose a tune from the file we have already opened. The user wants to refresh a tune that he is editing. PARAMS: the_last_cursor - the last cursor position. We'd like to restore this after the system has finished rendering the image so the user doesn't have to scroll back on every redraw. We check and update some things every so often on a tick from the GUI. Get the screen position in pixels from the location of the cursor in the text buffer transpose the selected text the given number of 1/2 steps (or letters if it is diatonic) PARAMETERS: the_steps - the number of steps (1/2 or diatonic) to transpose the_diatonic - true if we transpose letter values only. the_start - the start place of the selection in the buffer the_stop - the stop place of the selection in the buffer Return the list of voice names for the GUI. Get the on/off voice status of the voices in the tune. Set the voice map when the user has edited it from the menu. This is something we owe document. We assume that the printing is already set up, and we just need to tell the page to print itself. Set up the page settings and stuff. We are printing. Don't read in the music again but render the music again. Make sure the scale is 1/1 This is the wxWindow instance where the music drawing occurs. keep track of the 'voice on map' when we are refreshing the tune. This will tell the tune which voices to turn on in the new tune. This is the iabc-defined window, which contains a view-canvas window and interacts with classes like figure and text_figure. This is the actual wx object that the tune list gets drawn into. This is the gadget that we pass to the iabc_media that accepts all the tunes that it creates. Set this to indicate that we are still parsing this file, os we should not try and open a new file. True if we are opening a new tune in a collection, so we need to set the buffer position to the start point of the new tune. Otherwise we preserve the existing buffer position. This is where the music information gets displayed. This is where the print information gets displayed. The thing that parses the abc file and makes the music data structures. We set this to true when we have finished displaying the music and the parsing thread exits, so that we cna restart. This lets us tall the iabc source which file to open. the last positition within the text buffer that we were. Used to reposition the cursor after refreshes. Unless we're changing tunes, then we don't want to replace the cursor since the program will change the cursor position. This is used to center the screen on a redraw around the part of the tune that we were last editing. We set this every time we redraw something so we don't have to redraw when nothing's changed. The midi output place. The buffer where the ABC text lives. This is the last place we drew the handy text pointer. Note that this is a pointer to the GUI music that indiates where the text is, not a pointer to the text window itself. Drive the parser rules that define the abc language, at least as iabc understands them. Keep track of a line or so of an abc file and the musical information that came out of it from the parser. This can keep us from having to re-parse an unchanged line of abc. Parse this line of text, update the parser state and store all of the musical information. return true if this string matches the string that I was created with, or if the timestamp is earlier than the last time I was created. If this returns true, the_info and the_start_voice will contain the voice and parser_info that were present at the end of this line when it was first parsed. Indicate that check_match() has returned false. This is called by the constructor and actually performs the work of parsing the line of code we were fed when we were created. Parse the w: header. Put the chords into an array (they are stored in list format) so that we may put the words to them. Also used when putting words with the chord infos. RETURNS: true if the array still has stuff left in it. The line that I was created with Keep track of the first measure of the last line, which is where we start putting the words. The array of all the matches. The match type will indicate whether the current match type is a header, measure, or whatever The header rules that we created from parsing our string the match rules that we created from parsing our string. The parser state info could change during any Each rule is matched in the context of a parser state. Keep track of the parser state at the start of this line, if the line is same and the parser state is the same then the line is unchanged so all the misical information is also unchanged. Indicates that we have a match. This is the line number of the text file that was matched. We keep track of this so that we can track the music with the text in the GUI. Don't even bother looking at the line if the buffer hasn't changed since my_modified_time. This class invokes the pre-processor to get a line of text and then adds the music to the supplied media_source object. Keep the index in to the file for quickly finding a tune. Store the file name that we will open later and try to parse. retunr the starting line of the tune that we just parsed. parse the input file and tell the media what we've found so the music can be realized somehow. Get the tune from the file, based in the tune at the given index. Do a parse of just the T: and the X: headers get the next measure and deal with it from the abc file. Some measures are split across several lines so send the file in too, and keep track of the measure number. ARGS: int the_measure - the last measure we read in bool read_in_music - true if we've read in some music and we need a line break preprocess & the_file - the file we're reading in. Get the next line of text. This can actually be more than one line of text, if there are words that are associated with this line of abc stuff. Also get the line number of the file so that we can associate it with this spot in the music. return true if there is text left to read in the current tune. Because of the way we associate words with chord_info structures, we have to parse the word header (w:) outside if the state machine rules as well as in the word rule itself. Read through all the lines of the file, and feed each line to a new parseable unit for parsing. But, if we already have a parseable unit in the list that has parsed this line then don't bother reparsing. We want to make the lowest measure in a line be the key for that line for playing and indicating the place in the music. We've found a measure's worth of music. Handle it and update the current measure and beat. We have received a header at the given score point. Record it and make any required changes. Also reset the_measure_index to 1 if we are on a new tune. Return the last measure we read from the_voice. If this is the first one, we return 0. We have just changed voices, so update the new measure since it may be different than the last voice was. Keep track of the last line that we read in from the scanner, if there are words in this line then we combine it with earlier lines into one parseable unit. Keep track of the last line number that we read in from the user. Keep track of the line in the text buffer that a song starts on so that we can scroll to there if we like. When we switch voices in the parse, we need to keep track of what measure index we were on last time. Keep that information here. map of words that go below the staff, to the point in the music where they go. Tunes that we get in a quick parse of an abc file. Keep track of the first measure of the last line, which is where we start putting the words. text buffer for input Reset all the internal state things that I keep track of for a fresh parse of a file. Keep track of which line corresponds to which line of text for GUI magic later on. Handle all the logic and resources associated with drawing a key signature on a staff. Just populate variables. draw yourself on the page, on the staff supplied. Draw the ending bar if this is an inline key change. gets the number of sharps or flats If this is an inline key change, indicate how many naturals to put down if we are going to a more-natural key. A line_of_music is a container for all the stuff that gets drawn on one line of music. It also takes care of drawing fixtures of the staff (like the key signature) and the staff itself. Aside from that, the line_of_music does the horizontal justification that keeps the notes evenly spaced. Free all the graphical resources we use to draw ourselves. Add another measure to this staff. Future notes will be added to that measure. Add an 1st, 2nd etc. ending bracket over the music between the given measures. add a slur from the previous point in the music. The point in the music where we're slurring to will be added later. Finish the slur that was last added with add_slur_from get the measure that we start with get the measure that we end with just subtract the from and the to. This draws everything. Return true if the rectangle overlaps any of the regions of the staff. Used by the page manager (window_media) to draw page fixtures without ruiing the music. Add a creschendo/dimenuendo to the staff from/to the given point. This adds a dynamic change (pp, p, etc) to the list for later rendering Get the highest y coordinate, which is the lowest point on the screen tha this staff takes up. We decided this staff needs an offset different that the y coordinate. Change the y coordinate of the origin. return the lowest musical point on this staff, good for making hashtables. We need to add the ornaments after we draw all the notes cause then we know which way the beams go. This should be called after the notes are rendered or nothing will happen. A lot of fixtures need some basic information about a staff before rendering themselves. This is information about this staff for figures to use when drawing themselves. It also reflects my current position horizontally as I'm drawing from left to right. get the width of the words below the notes. If they are wider than the note head, use this for the width. render the notes into figures. render the words for the first time. render the 'part' string, which is the letter marking used at different places in the music. render the dynamics. draw the time signature on the point at the given location. Update the point based on my width. return the time signature for the given measure. If there is a repeat sign at the beginning of the measure, draw that. Draws the end-of-measure figures We try to spread out the notes on a staff as much as possible. If we do this in a uniform way, this guarantees that we will always line up parts from the same points of a score, if we can. RETURNS: The number of points that this note figure should take up. This will always be at least the width of the figure. ASSUMPTIONS: We assume that the get_leftover_pixels() has already been run, as this will use my_rhs_overlap and my_spare_pixels Go through all the figures in this staff, and figure out how many pixels they would take up. Fill in some class information about how many pixels in all so we can justify the notes. Get the number of pixels a note of this duration shoudl take up, given the number of pixles and number of beats in this staff. Count the numer of pixels taken by measure end things. We use this to justify the music Determine if we need ledger lines and draw them. Draws the little measure numbers on the left hand side Get the width of the barline figure for the end of measure x. Get the width of bar in pixels, once its been drawn. Assumes that the bar points have been populated already. Get the width of bar in pixels, once its been drawn. Create the text figure that goes above/(and somdeday below) the note and compute its x coordinate. The y location is computed when we have rendered the chord and we know where its supposed to go. We figure out the chord symbols, but we can't actually render the chords until we have drawn the figures and beamed them all. Go through the my_chord_symbols and print them all out. Add the description of the voice information to the staff. Get the top and bottom note on the staff to deterine if the ledger lines are needed Get the appropriate figure for the give figure ending. We need to put something near the first beat of a measure, make sure it doesn't run into a note. Render the figures into a list first so we can move them down to a different page if we want to. We create lots of intermediate things when creating the figures. We don't need any of it now so release all the resources. Indicate that all of the fixtures have been added to the staff, no more should be added. the offset where this staff is to be drawn. the measure number I start on. my last measure keep track of whether or not we should try and justify where it all happens... true if we need to show the name on top of the staff, i.e. we're in score mode Map each point in the score with a figure to draw on the staff. We keep 2 around, so we can re-render things fast if we already know where stuff goes. We also store the x location of the words since we compute that at the same time as the note locations Keep track of the places where the barlines go so we don't have to keep recomputing those. Keep track of the time signature. A key signature can draw itself on my. We keep track of the UL part of ourselves, and then we increment the x part as we render the staf from left to right. This is the original origin. We compute the x location of the chord symbols and the y location at different times, to avoid chords and beams colliding. Save the figures in an array and then render them all after the notes have been rendered. Keep track of which is the center pitch for this cleff. That is used to determmine things like beam directions, etc. Keep track of how many pixels are left for notes, after drawing the key sig and stuff. This helps us justify correctly. Keep track of how many pixels over the right edge we'll be going, so we can 'borrow' from wider notes on a later pass. Keep track of how many 'spare' pixels we have for each note so we can 'borrow' if there is overlap. Keep track of the last beamer so that we can add notes to the current beam group as they come in from the parser. We beam grace notes seperately, so keep track of those too. There is one slur object per staff that contains all slurs on that staff. This should allow us to do complex things with slurs like slur around notes. For now we just try to draw it as best we can. a constant scaling the drawing routines so we can fit more/less stuff on the screen. When we add figures to the staff, we want to keep them from bumping into the important things like notes. So make an array of all the rectangles of the figures that we have drawn. Page width in inches If a measure begins with a repeat, and its the first in a line, this is what we draw. This is all the stuff that is required to draw an nth ending. We populate the number ending and begin/end type when we add the measure to the staff, and the other stuff gets populated after we have rendered all the measures. Make the figures that constitue nth endings. Keep track of dynamics that we need to spell out, and crescendos. Return true, this will let a client know that no more music should go on this page. If the first measure is the first measure in a new part, we need to be told that so that we can draw it. General stuff about the current key, staff, etc. Mapped per measure. Keep track of the high and low point so we can adjust our size for vertical justification. keep track of a running total of the accidentals Keep track of which accidentals are being used in which measure This is a bidirectional list with the default node serving as the head of the list. The 'data' part of the default node is not valid and is never refereneced. The default node always exists (even in an empty list) and is used in comparisons to end-of-list List node is the data plus the pointers of a linked list. list_data does all the work of the container interface for lists. This iterates through a list, and also is used to add or remove elements (which in STL is a list function). This is always referenced as a nested iterator within list (e.g. list < T > ::iterator = my_list.first) Acts like a pointer dereference. Throws excepction if the list is empty. Returns a reference. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a copy. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe shallow, reference counted copy. list is an extra layer of indirection so that we can pass const lists and still access the methods needed to perform const-type operations (like copying a list) It also allows us to assign the lists by value and lets the reference counting for list_data work transparently. these are a bunch of predicates to find special elements of a list using find_predicate function. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe get the item that maps to lowest ordinal in the map. Get the item that maps to the greatest ordinal in the map. A key-value pair template class. The key is some type of ordinal type, and the value is something associated with the key. It's used as an element of a map. list_data does all the work of the container interface for lists. Create a predicate for map searches. Allow a user to iterate through a map from some start point to some end point, using the get_item method of map. get the item that maps to the_key, or return a NULL iterator. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a reference. Acts like a pointer dereference. Throws excepction if the list is empty. Returns a copy. Allow the list to be checked for validity in the pointer way, e.g.: if (my_iterator) { // check for end of list. tmp_data = *my_iterator; // now this is safe If there's a place you need to go, it'll get you there I know. Map a set of keys to a set of values. There's a couple of things that make this class special. First off, the map follows a 'worst possible' matching algorithm, which means for example, that the lt (less-than) match type will always return the greatest ordinal for which the lt constraint holds. Second, the map contains an iterator, which always points to the last thing selected. This means that copying one map to another will be an O(n) operation. Frequently the map iterator will be used instead of creating a seperate iterator class. Allow the client to iterate through the list. I'm not sure that I like this since it allows the user to delete an item and not my_last_cursor. But it allows the user to easily dereference all the pointers from a map. The assumption is that this is only used before the list is destroyed. list < kv_pair < ordinal,T > > ::iterator get_iterator(){return (my_list.first());} Add a new pair to the map, with the_key mapping to the_item get the item that maps to the_key, or return a NULL iterator. get the item that maps to lowest ordinal in the map. Get the item that maps to the greatest ordinal in the map. Safely remove an item. Clear out all the element in the map. Get the size of the list of keys/values It is possible for this class to be populated entirely by a copy of this map class, in which case my iterator's my_current pointer will be null. This is never a valid case since even an empty list has the seed element. So perform this initializtion one time if required. Return map < key,value > give map < value,key > . Note that not all maps will have an inverse. Classes that define how iabc handles media. A media is a thing that the music is presented on. Probably the most common media is a window on the screen, but it will include other types. The media is populated with information about the music from a media source, which could be something like an abc parser. A score point is an ordinal type that represents a particular beat in a particular measure in a particular voice. Sometimes we need to sort by voice last instead of first, like when we're playing all the voices back at once. To do this we use the score_time class as an ordinal. Contains all the information that can make a tune, including all the music, voices, key changes, etc. A single abc file could contain many small tunes, or one big one. Sometimes its nice to have all the streams of music information into one map for easy iteration. This function combines the maps in a tune into on supermap. This function sorts by score_point. Extract the music from the tune for the given voice only. same as the other extract, except sorts by score_time The media needs to get a list of voices that we want to display. There may be more voices in the source. Create an abstract class for this. Media represents a place where the music is presented to the user. The media source populates the media with information about the music. The media presents it to the user. Get any resources and parameters neccessary to display the music on the media Notify the media that that's all the music there is. This only applies to visual renderings of the music. Typically abc programs use this parameter to display information about dynamics and stuff. A part info is a bunch of static information that applies to the music, but could change at anytime. One example is the key signature. Get the current set of information for this point in the music. Keep track of the voices in the tune, and allow people to change whether or not they are on/off Return true if this voice has not been turned off. The base class overrides this method to actually present the music to the user The base class overrides this method to actually present the end of the measure to the user information about a particular repeat, including which measure its located in, and nth endings around the repeat. A map of measures to repeat infos. Go through the tune and figure out which repeats go where in the song. Count the number of voices in the tune. Encapsulate a list of tunes, and provide an interface for allowing a user to choose one from a user interface of some kind... Add a tune to the list of tunes. Clear the music out of the tunes, but leave the title and index of each tune. Abstract method that gets the current tune choice from the user. Abstract method that clears the list for new parsing. Allow the client to treat the list like an array to get or modify elements. This indicates whether or not we need to repopulate the box, if data has changed. A media source is a thing that defines the music that a media object presents to the user. The most common example would be an abc parser. Add a music feature (e.g. a note) to the current tune on the given beat. Add a measure feature (e.g. a bar line) to the current tune on the given beat. Look up the measure feature for the last beat before this measure and make it a line break. add a word to the chord at the given time, in the current tune and voice. These are the words that show up after the music. The state of the music that is being played/displayed has changed in some way, for example the key signature. Get the voice info for as close to the given point in the score as we can. We have read in some tunes. Get the tune at index the_index, and return an empty string when there are no more. Clear the music out of each tune. This is done to prepare for a new parsing. Leave the title and index number in each tune so we don't have to redo the quick parse. Remove all tunes from the tune list. This is done to prepare a modified file for new parsing. Start looking at the_measure, the_beat in the current tune, and iterate through the music until a non-rest is recovered. Output to a midi file, and hopefully someday play midi file as well. Get any resources and parameters neccessary to display the music on the media Notify the media that that's all the music there is. Store all the track data for the given voice in the array. Fix the chords so that tied notes actually sound like one note. The base class overrides this method to actually present the music to the user The base class overrides this method to actually present the end of the measure to the user The music for grace notes is stored somewhat deceptively: we give grace notes some time, even though they're sort of 'out of time' to make them display properly. But we need to compensate for grace notes, put them before the next beat and subtract the delta time. If the voice info has changed (tempo, meter, etc.) send an midi meta-event to handle that. Count the beats from the_start to the_end. Make sure we write the midi header if we haven't already. Store the time signature in the music array as a midi meta-event. Store the tempo in the music array as a midi meta-event. Store the track end magic cookie in the array. Store the program change for the given voice in the given stream. Write the given value in midi variable-sized format Keep track of where the next note off point goes, if the point we're currently talking about is beyond that. Go through the array of note off events pending and see if we owe the world any note off events. Spit them out to the file, and return the point where we ended up before any deltas. Convert the internal pitch format to the midi format convert the internal duration format to a the number of midi ticks. Use the current tempo as a guide. Some files don't declare a tempo; here we guess what the tempo is based on the time signature that is used through most of the piece. E.g. cut time tunes go twice as fast. Store the midi data in an array so that we can size if and incorporate that stuff into the MTrk part Keep track of all the music in one map so we don't have to keep switching maps. The music part of the tune. We need to change this for midi reasons, but we should restore the original after we have constructed the midi part. This contains information about the music that's not particular to any single medium and isn't about the notes (note stuff is in note info) information to describe a particular measure, including the number and the endpoint 1st, 2nd ending etc. usually 0. A part point represents a particular beat in a particular measure. Each chord in each voice belongs to a particular part_point Information about a particular part, which in ABC would be called a voice. This is the voice number or part number. This is a union of all things that can be in a tune that are related to the music at any given point. The idea is that you can construct a big supermap of this to make it easy to iterate through the music for midi and display output. The abstract interface to the platform-specific object. The generic mutex proxies to this object, that allows us to create mutex objects automatically. IMPORTANT NOTE: See IMPORTANT NOTE below... A proxy to the real mutex object. The is called the proxy pattern. IMPORTANT NOTE: This mutex may behave differently than some other mutex objects you may have heard tell of. So here is how it works: If you seize the mutex and you don't own it, you block. If you release the mutex and you own it, then you don't own it anymore. If you seize a mutex and own it, NOTHING happens, no count is increased. If you release a mutex and you don't own it, nothing happens. If this behavior is surprising to you, then you probably want semaphore or lock (see below) Allow stackable locking and unlocking of a mutex. This allows you to implement re-entrant methods. Usage: void my_safe_function(){ lock tmp_lock(my_mutex); ... access shared stuff } Implement a threadsafe decrement-and-read operation. This avoids nasty race conditions when implementing reference counters across multiple threads. Draws the actual note part. Also updates beam group. Return the width of the rendered figure so that the staff can do justification. Return the offset of the head, which isn't always in the left hand side. none. Dereference all my stuff. Actually draw self in correct thread. Honor the_should_block, which should be set the first time so drawing occurs properly. Also activate beams and slurs and stuff. Allow the beamer to get set, so I can beam self when drawing self. Accessor functions. We need to keep track of the absolute bounding box once we've rendered these so that we can draw other figures right next to them. We are now on a different scale so all of our beamers and figures are no good. So get new ones. Handle any ornamentation on the note, like tenuto or slurs. Figure out what type of note head to draw and get that from the factory. Keep track of the high and low point of this note and beam group. Figure out what type of accidental to draw, and get that from the factory. Figure out which rest figure we need and get it from the factory. Reverse-engineer the number of dots on the note from its duration. Update the slurer for this channel with the location of the note. A whole bunch of figures for rendering beams, etc. We use this to determine what the scaling factor of all those figures is. The page on which we draw ourselves. This tells us whether or not we need to draw accidentals. This is the chord that we are representing. Where we park. We keep track of this so we can tell how big the whole figure is. This is used when justifying. Keep track of whether or not we have drawn the beam and stuff. The array of accidentaly, maybe one for each note This file contains classes that represent the notes and chords in the music. A note info consists of a pitch and a duration. We also keep an extra flag to indicate whether or not this note is a rest. You can slur to and from a chord to another chord. Allow getting and setting of this attribute In ABC you can use a chord almost anywhere you can use a note, so a chord is the main abstraction that represents music. A chord info is an array of note_infos, plus some additional information about how the music is to be played and notated. Return a copy of this note, including a deep-copy of the array. A shallow copy of the array happens during copy ctor or = operator. Return true if this note is short enough to beam In order to figure out what beat we're on, we need to give each chord a concept of a duration. We say that the shortest duration note in a chord is the true duration, since that should determine where the next beat in a measure will fall. Change the length of each note in the chord by multiplying by product and adding sum. Get the highest note in the chord When we connect 2 chords in a beam we create a 2-directional list, so we can get the next and last in the beam group. (so if foo.get_next_in_beam() == foo there's no subsequent notes.) the number of notes in the chord. Return a string representation of the chord, for debugging Treat a chord info like an array of chords. We want a chord to be treated like a simple type with regard to assignment and concatenation A chord can have an embellishment like an accent. Allow setting and getting of that. A chord can have a description, for example [CEG] can be C. Allow the chord to save its description. You can slur to and from a chord to another chord. Allow getting and setting of this attribute by looking at the contained notes of the chord Return true if this is a grace note stacatto, etc. A textual description of the chord, e.g. 'Am7'. words that go along with this particular beat. The notes that make me a chord true if this chord is the first in a beam group true if this is the last note in a beam group. Indicates that it's supposed to be grouped with a number, like a triplet is. pretty self-explanatory The base class overrides this method to actually present the end of the measure to the user The base class overrides this method to actually present the music to the user This is useful for debugging, since the match method of most of the classes will be overridden, this will allow you to debug other classes by overriding this method. A null rule always matches. It is handy when optimizing the sequence of rules in an 'or' and making optional params. A loser rule is like a null rule, except that it always fails. A terminal is a regular expression, like a variable name A non-terminal rule is made up of other terminal or non-terminal rules. We want to overload the & and | operators to use them in the usual way so we don't make non_terminal be of type 'rule'. Instead we make non_terminal its own class that can be constructed with a rule or another non_terminal. Some rules are made up of other rules. When constructing these rules its more efficient if you just set up your parse tree one time during the lifetime of the rule, and then just keep resetting it everytime you use it. Construct the compound rule if we have to, and then run it. Call convert() if there's a match and return true. return true if I matched last time I tried We have found a match for the rule, which means we have matched a expression in the language. Do whatever that expression tells us to. We create the compound rule using or and 'and' only once during the lifetime of the object to speed up the parse - its wasteful to keep creating and deleting instances. A '1 or more' compound rule. Calls repeat_match until the match fails, and return true if there was at least 1 match and no syntax_error was raised. Try repeat_match 1 more more times, then call convert if there is a match. Keep going until the match fails. We are iterating through the_iteration and we need to make sure that the arrays have been created up to this level, if we have never been at this level before. We also need to make sure we've reset the rules at this level before we try the match. We have matched on the_iteration. Extract any information we need from the rules before going on to the next step. This is where we call the actual match. These are the non-terminal rules that make up this rule. They are an array such that the n'th iteration refers to the n-1th rule. The array is populated by calls to create_complete_rule. This matches a string delemited by matching characters. Probably the most famous of these is a quoted string. A word, in other words not spaces key = something, chop off the '=' part name-value right hand side, either a word or a quoted string. name-value pair, for example: NAME = VALUE Representation of a pitch. Consists of a letter note, accidental, and octave. Returns a string representation of the pitch, but not an ABC string use abc_string for that. Returns the pre-parsed value of the string. Used for transposing ..toABC things These can be used by clients keeping track of accidentals to decide what needs to be displayed/played based on what has been played thus far in the measure and the common rules of music notation Change the accidental to compensate for the key or the forced accidental. The assumption is that the changed accidental is already added to the map. return true if the accidental for my_letter in the map is different than my_accidental, or if the accidental doesn't appear in the map at all. Return true if there is an accidental for my_letter in the map. Represents an arbitrary shape that can later be rendered on some type of device. Most of the operations that can be performed on this objects are derived from the postscript language (loosely). A polygon can be transformed the same way a window can. When we transform a polygon we only apply the transform to future drawing operations. If you want to change the transform of the whole polygon you need to apply the transform and then redraw all the points Allow the user to set up the zoom and offset in x and y directions This class is used to represent a point in the drawing of the polygon where the drawing actually occurs. This lets us represent more complex shapes in one polygon. returns the extreme points of the polygon. Allow the polygon to be treated like an array of points. Many figures are actually multiple sub-figures. The sub-figures are either filled or outlined at a certain index into the array. This sets the next fill point at the current index (the index that was added last). This sets the next outline point at the current index (the index that was added last). Follow the same set of commands that was used to build 'o', when creating a new polygon. This can be used to render polys on a different scale (like on a printer). this is used by clone() handle expandable array. We figure that this object will be rendered seldom but referenced many times, so an expandable array will be best. return true if we must add the current point in a lineto or curveto operation. We need to do this is the last thing was a moveto or moveto relative. Implement Bezier curve by replacing a n point array with n + 1 midpoints. Return false if we can't bisect the midpoints because they're too close together. Keep track of the size and some special points of the polygon Keep track of whether or not we need to recalculate things. This speeds things up when referencing the size of a polygon many times. Abstract the behavior of a file so that it could work on any text buffer, such as a text editing window. free up the resource so that it can be used by others. Make sure the contents of the text_file object match the contents of the underlying buffer. set cursor position to l Open the text buffer for reading. Return the current position of the pointer into the text buffer. get the next character in the buffer. Return text_buf::eof when the last position is reached. set the position of the next read to the_pos; Refresh the text buffer with the persistent representation. returns the last time the buffer was changed, so you'll know if you need to reparse it. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. A stdio file implementation of text_buf. Used for unit testing and development. free up the resource so that it can be used by others. Return the current position of the pointer into the text buffer. get the next character in the buffer. Return text_buf::eof when the last position is reached. set the position of the next read to the_pos; Preprocess an abc file. Scan through the comments and return completed lines, including lines seperated with '\'. Move to the position of the given line number. Get the offset (for getpos, etc.) that we corresponds to the beginning of the given line. return true if the file has changed since this was opened. Count the lines, and create the line to position map for the buffer. Keep track of which index is which line, so we can get there fast. Classes that implement a simple platform-independent persistent registry for a program, that manage a list of name-value pairs from a .ini file. This can be used to store preferences, program state, etc. The form of the registry is: [category] key1=value1 key2=value2 key3.subkey = value3 A registry key is a set of strings that can be associated with a value. The strings are arranged in a heirarchy so that we can sort them and peruse them. Parse the string to split on the '.', which allows entries like: LASTFILE.1=foo.abc registry_entry is a registry_key + a string value. An entry can be put into the registry and looked up later, based on the key. construct a registry entry based on the strings. construct a registry entry based on the key an a value. construct an empty registry entry. change the value of the existing key. Indicate whether or not this registry entry should be written to disk when a flush() is performed on the registry. Allow the user toe store key/value pairs persistently between releases. It is similary to a windows .ini file, hence the name, but it works cross- platforms. Create a new registry instance, and initialize it with values from the_filename. Future flushes of this buffer will also be written to this filename. look up the registry and return the value associated with the given key, or an empty string if no such value is found. look up the registry and add or replace the given entry. write all values marked as persistent to the file All the class needed to implement a semi-functional, extremely slow regular expression scanner In order to get all of the state machine creators created we need to explicitly reference them somewhere. Do it here, for the linker's benefit. We will construct a state machine to implement our regular expression scanner. Each state in the machine will implement the following interface. We construct a scan state with 2 variables: the previous state, which could be used for things like wildcard matches, and the group number, which can be used to remember previous matches This is the main public module for a scan state. Match the_string starting at the_index. If this state matches the string at the_index, increment the_index by the size of the string we matched and return true. Otherwise the match failed, return false and leave the_index unchanged. Parts of a regular expression can be grouped. The groups are assigend indices and can be referenced if they are all matched. States are assigned group numbers when they are created. Return the group number we were assigned. return the minimum that this state can match and be satisifed. If the remainin string is less than that, we know we're done. Return the matched string, or an emptry string if no match was found. This actually implements the match in the derived class Some states have internal state that must be reset before another expression can be matched. This does that. return the length of the string that this state has matched. The state machine is constructed based on an input string. So we have to scan the input string before we have a state machine. This class will construct a scan state based on the input string. For example, the '\d' input string will construct a digit-matching scan state. Static method. Regexp can call this to create the next state in the input string. This will return a state if the next input token on the input string matches the string the scan_state that I know how to create. Note when implementing this method in a derived class, make sure that you increment the_index if you create a state, or you will loop forever. match A-z or 0-9 or an _ Make \w match a word character. Define some simple types that are useful, like point and line and stuff. A 2 dimensional point, and some usefule operations In order to create an ordinal type out of 'point', assign the y value arbitrary importance. same as point Define a fraction as 2 int's, and some useful operations a floating point version of size A line is just 2 points. A rectangle is 2 points also, but it's treated differently These functions are used to map a point from one rectangle to one of a different size. Handles all the slur points for a single staff. This will allow it (in theory) to keep the slurs from running into each other. We discover slurs by matching open/closed parens in a LIFO way. Each time we get a new to point, we match it with the last 'from' point and add it to the map. Then we draw the map from left to right. We try to normalize around 0,0. That way we can draw the slurer on the page where it starts instead of having it always offset from absolute 0,0. Makes the page logic simpler since 0,0 is always on page 1. remove the last character Clear out the string Allow a string to be drawn on the given window in the correct thread. Handle the dispatching to the GUI thread and the correct placement This gets the current rectangle from the current string. Do the same things with words. Calculate all the size info about this string in this font. This is true if we need to call calculate text info Template files for handling notification of concurrent things. This is various interpretations of the observer pattern. Encapsulate a multi-type container. This class acts as a proxy to another derived wd_data, which contains an instance of some type, possible a built in type, which is passed as a parameter to a dispatcher function. A derived wd_data, with the parameterized type which detemrines what the real type is. It can be used in the place of a < type1 > parameter to a dispatcher call. Abstract class that allows a client to get reports of GUI things to him using the observer pattern. This is a template class that allows the client to be a selection handler (e.g. receive selection events) without having to inherit from selection_handler himself. But he needs to implement the handle_selection method. create the class with the object that is getting notified as the parent. This is the method the widget calls to get the events to the user. This is what calls the handle_selection method. The client class that we notify. This is the type that the client creates. Usage: my_tree_ctrl- > add_selection_handler(selection_handler_dx < my_type > (*this)); Create the data that is reference counted and initiaze it with this parent. If the parameter is another instance, add ref to my data object. Remove the reference count and delete the object if need be. Call the select method of the data object. Iterate through the music and populate the graphical interface. We use a template because the iteration actually uses different clients depending on whether we're in score mode or not, but everything else is the same. There will be other media types, such as: midi device output, printer output, midi file output, but for now the only one is window output. As other media types are added they will be moved into their own files. This accepts musical features from a media source and renders them on some type of window device. This is supposed to be where the media gets set up to receive the music, but it doesn't really apply to a window getting music. This didn't really work.... This is called when all the music has been added to the media. It's a sign for the media to start drawing itself. Here we just render the music one page at a time. If we are in part mode, consolitdate all the rests into blocks where possible. Sort the staffs in order from lowest to highest on the screen Move all the staffs so that they don't overlap one another. Add the header and footer to the given page. Make the musical feature come alive on the window. Usually this creates a note figure and puts it on the correct line_of_music. render a feature that revolves around a measure, such as a bar line or repeat sign. Transpose the note up or down the given number of half-steps Transpose the note up or down the given number of half-steps We've read in the music, and stored it, so now its time to render the music. RETURNS: the number of the next page; 0 if this is the last page. Handle the big 'W'. Just draw the words centered in the window at the end of the song part. We've put together a bunch of staffs and added the music to them, now go and do the drawing of them all at once. Set the dynamics in the staff, if they've changed. Add the staffs to the pages, compensating for the offset and adding new pages when necessary. If we are in score mode, return the number of voices. Otherwise, return 1. Create a note figure from a note info and add it to the staff. We have rendered all the notes in the measure, now complete the measure by adding the figure that goes at the end, and the figure that starts the next measure (e.g. a begin repeat) to the appropriate staff. We keep a map of places in the music to the staff objects that go with it. Look up the staff in the map that is less than or = to this point in the score. If this is the first such request there are no staffs for this voice, create the initial staff and return it. To keep the staffs from running into one another, compare the points to the previous staff. Figure out which nth endings go on the staff. We have changed parts so we weren't reading the music in in order. Get the points we saved the last time, and save the current point of measure and chord for when we change back to this part/voice. x and y scale and page size an array names that contain the voice header name information (e.g. trumpet2). There may be one of these for each page. We have a line_of_music. We want to see what the offset is info this window so that we can put it in the right place. Handle the work of creating a new staff instance given a point of music. We assume that the client wants to actually create the line_of_music if they call this function; no check is made to see if it already exists. Return true if we are in score mode. This is where we do our thing... Used to determine whether or not a thing is in the window range A map of staffs to parts/measures Keep track of the staffs as we draw them so we can space them properly Keep track of the staffs and then render them all at once. Keep track of the staffs that we have started so far. These keep track of the pages. The last point I rendered, used to update the system a little at a time. Keep track of all the music in one map so we don't have to keep switching maps. This is the map we use if we are displaying in score mode. Keep track of which screen lines the staff is on so we can do GUI magic later. Generic window classes. We want this to be as portable as possible so we make the base classes do as much of the work as possible A generic resource associated with a windowing system. This could be a font, a pen or a window itself. Keep a reference count so it gets deleted at the correct time. Decrement the reference count and delete if its zero A template class that will cast a window resource to its derived type, or return null A canvas is really a window, but we use it to get around the circular dependency between a window and the resources that can draw stuff in it. We make the assumption that it doesn't really make any sense to have a pen, color, whatever unless there's a window to go with it. A pen that can draw on a window. We create pens and fonts based on a particular window. Avoid memory leaks by derefing all pens still owned by this canvas. Hopefully by now any clients that keep pens around have been removed. A font class that can write text to a window font_data allows you to specify a font in a generic way, and then get the font for a specific system. get the font from the list of fonts that this window knows about, or return NULL if this font has not been created yet. This can be called from outside the windows thread and will not switch threads. Return the bounding rectangle that you get if you draw the_string using this font. This is like the windows view/document architecture. A document gives the window something to nofity when its state changes, so that the document can render itself in the window properly redraw the rectangle the_rect in the window, as this part has changed someone has clicked on the area of the window that contains this document. attach a canvas, which is really a window, to a document Detach a document from a window, so that we can destroy the window or the document. Print the given page Finally we have enough information to define a window. Mostly a window object represents a real system window, and the methods transform from the logical space of the application to the 'real' space. The interface also allows almost all drawing to occur in a generic window without any real system specific stuff. A linear transform on a thing that consists of multiplying by a scalar and adding a scalar offset A display context is the current linear transform that operates on stuff that gets drawn in the window, and the current point (the turtle) that we're drawing on. Each window has a name, you can get a particular window by knowning its name and calling this static function. create or get the font that has this typeface as a family name (e.g. Times). Get the pen that draws in this color and has this width and drawn on this window. pixels_per_inch return the pixels per inch that can be drawn on the current window. This is used by things that render shapes on the screen. This can be used to refresh a region; also it is called by the OS when the screen is refreshed. Otherwise known as redraw. Refreshes the whole screen. Sets my document to the_document. Also notify the document that its got a windoow, things are gonna be different from now on... Used when the document is being destroyed. Remove my reference to it, and set my_document to 0 so we ignore any pending events. Scale the point size such that it is proportional to the size of the window. We need to do this since the mapping mode we used is pixel-based. make the given point the central point visible on the screen. Make it virtual but not pure virtual so printing doesn't have to fake it out. Remove all text figures at the given point Classes to help manage the dimensions of the pages, without any windows-specific stuff in it. This is the interface that describes how the pages hold the figures. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure with the given string, and sort on the given point. Allow other classes to act like a page class. This allows us to implement the same interface as a page without having to inherit from anything. A structure to keep track of the settings of one page. By settings I mean page size, things like that. This is all the figures in a page, along with information about the page itself. Add the title to this page. Add the copyright information to the page. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure with the given string, and sort on the given point. Redraw all figures who's bounding rectangle intersects the_rect. Remove all figures at the given point. Remove all text figures at the given point Re-render all the figures on the given window, by stretching/ compacting the figures based on the source and target rectangles. Disallow erasing the image before draw, as on a print. Add the offset to the figures before they're drawn, as on a redraw. True if we should erase before redrawing. False on printing since there's nothing to erase on a blank page. This is the interface to page_contents, which includes copy operators and reference counting. Add the figure, and sort on the given point. Note that the point may not be the same as the UL location where the figure is located on the window, since some figures have the absolute coordinates and some have relative. The point where the figure is to be drawn is in the point part of the point-figure pair. Add the figure, and sort on the given point. Add the figure, and sort on the given point. Redraw all figures who's bounding rectangle intersects the_rect. Based on an absolute pixel offset, figure out which page we're on, or vise versa. Return the important parts of a page like the title rectangle Add the page to the array, if it doesn't exist. Given a page number, Create all new page objects using the target window and scale to get the dimensions to draw on. We can also take a point and figure out which page we're on. Iterate through all the pages, and refresh any pages that intersect with the_rect Render the page, but fix the UL to be 0,0 This is the main application window. All the events that can happen in iabc come through this class. The main window is divided up into 3 panes, for the music, the tune list and the abc text. This mostly created those and also creates the main sub objects and timers that define the application. Make debuggin a little easier by putting the init stuff into a different function. Prints the version. We provide a menu option to allow the user to dump the event log to a file. This helps me debug problems that occur. This will attempt to start a web browser that points to the included documentation. But the online docs are probably better. The user wants a clean document. Handle save issues and create a generic tune. Open a new file. gets the file name from the user and sends the parameter to the iabc_media_manager to handle. The user has requested to display the music in 'score' mode. Display the 'view preferences' dialog that allows the user to set a variety of display parameters. Allow the user to set up some parameters regarding the ABC language and how the parser works. Display a dialog for changing the editor font. Save the current document. iabc dispatch model uses the wxWindows event pump. This is the system entry points for events that are dispatched to the windows thread or other threads. The user has pressed the ctrl-L combination. This will call the function in iabc_media_manager that re-parses the file and refreshes the tune. Also save the current cursor position so that the user is in the same place after the refresh. Play zha midi, ja. Handle the logic to set the midi player, for the OnPlay command. Allow the user to export the document to midi. Print the current tune using OS-specific methods. Handle the Ctrl-x character sequence. This gets sent to the text buffer window. Handle the Ctrl-c character sequence. This gets sent to the text buffer window. handle the Ctrl-v character sequence. This gets sent to the text buffer window. Handle the 'undo' command - poorly. This needs some work. The big 'X' has been clicked, or exit from the menu. This is called one time during creation, we just use the generic windows code. Recalculate the sizes of the window parts. Someday I'd like to allow the user to undock different parts of the window. We try to keep the music and the text in sync as the user is typing. Every tick we check for changed text to move the cursor and do some other periodic things. The user has selected some text and chosen to transpose it. Call the code that handles this. Setup voice options. The dialog box doesn't do anything yet but this will let the user show/hide voices. Show or hide the window pane with the tune list in it. Confirm save before exit. Some key events that get received in the key area don't get handled by the text buffer object, but have a global effect and must be handled here. Returns the point in the text buffer where the cursor is. Documents can be opened a couple of different ways, this performs the actual open. remove the object and close the window. This constructs the command line string that we use to launch the midi player. Utility function to generate a random file name. create the main window's menu bar. true if we are initialized enough to handle window events. This is where all the music-rendering and parsing action goes on. handle the 500ms tick. These files all have to do with GUI artifacts used to get information from the user to an application. Don't do this because we will delete these explicitly since its a widows resource. A nested list of things, a widget that really everyone else calls a tree (and maybe someday I will too) helper functions to convert values from dialog boxes into globals of various types Stuff to handle property pages. A property page is just a way to get preferences from the user. set the position of the next read to the_pos; Update the text contents with the contents of the underlying wxTextCtrl buffer get the next character in the buffer. Return text_buf::eof when the last position is reached. free up the resource so that it can be used by others. We need a way to pass some key events to the menu frame so we can bind 'hotkeys' to menu items. This abstract class allows us to do that. This is our derivation of the text control class. Right now we just update the cursor position when the user presses a character control. Someday maybe we will do some brief-style formatting. Update the cursor position in the status bar. Some key events we handle and don't pass to the default handler. Return true if that's the case. Call the default handler and return true if this is an event that has changed the buffer. Keep track of the last time the buffer was modified so we know when to require a redraw. Lets us update the status text based on cursor position change. give the main window first dibs on keyboard events. A buffer class that implements text_buf, which has pretty much the same interface as FILE* stdio. This is so our preprocess class can treat this like a file text buffer. Return the current position of the pointer into the text buffer. set the position of the next read to the_pos; get the next character in the buffer. Return text_buf::eof when the last position is reached. free up the resource so that it can be used by others. Load the contents of the file and refresh the internal string. return the file name that I was opened with. Get the last time this control was modified by the user. We return the lesser of the modify/redraw time, since what the user really wants to know is: have the contents changes since last I redrew everything? Update the status bar with the new position. There to satisfy dispatcher Return the point of the 'carat' in the text field. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. For the real GUI application, we need to get and set the selection of the text buffer so that the selection stays the same after redraw. Set the modify time of the underlying file to match the underlying file's modify time (so we don't keep reloading the file) Returns true if the file underlying the control has been changed since my_last_modify_time. Return true if the contents have changed. Load the file if it has modified since we last read it in, or if we never read it in yet. GUI thread method to interact with windows. GUI thread method to insert the carat in the file. The underlying windows object. The scanning thread sets this to true if the underlying file has changed beneath the buffer. used to control the exit of the scanning thread. This stuff is kept track of so we can access it outside the windows thread. The modify time of the underlying file. Use this to keep track of when we need to load the file into the buffer. The last time we've redrawn the graphical music. Under MS windows, the control has an extra character for each return character, so handle that here. A place holder to break the dependency between resources like wxFonts and the windows who love them. Create a font in the correct windows thread. wxWindows implementation of the font concept. Return the rectangle that would contain the given string. This method can be called from any thread, since the geometry data associated with a font is not stored when the font is created. A pen to draw on a window. We need to derive from the wxWindow object to handle the events like scrolling and screen updates, event though we have our own window object that does all the real window stuff. Proxy for the wxWindows device context, which needs to be established whenever we draw something on the screen or print something. This is the actual window that we draw on. It also acts as the event source for events and dispatches. Constructor. Give wx_window its drawing area. show/hide the window. Gets the window dimensions. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. The reference count has expired us and we are gone. Sets up the DC to draw with the selected pens. The contents of the document have changed such that the size of the virtual window needs to be updated. Draw a rectangle on the screen with the given pen. Draw a line. Draw a string in the current location. METHOD: Draw the polygon in the current location. Redraw the window in the given rectangle. return the absolute visible rectangle. not used. Determine whether or not we are printing and get either the visible or printable area. Store the ppi so we don't have to re-render it all the time This is a class that is used for drawing on the screen, in that it can handle scrolling. It needs a specailly derived instance of wxWindow for scrolling and handling scroll events. Move the scroll thing so tha the given position is where the top of the scroll point is. The document calls this when the contents of the document have changed such that the scroll bars need to be re-sized. Redraw the window in the given rectangle. virtual void raw_refresh(const rect & tmp_rect); not used. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. Like the scrolling window, but does not accept callbacks since it doesn't get redrawn. Get the DC that we need to draw on. This allows us to handle the DC where we are printing and the one where we're not. This needs to be public as fonts and pens need to use the DC as well. This is set when we are prepared to print. set the print object to be the_printout and defer rendering for awhile until the pages have all been prepared. Set the printout object to NULL and do all future rendering on the screen DC. Get the rectangle that describes the supplied page, and redraw that page. return the absolute visible rectangle. The printout object that we will be printing on if we will be printing on something. If my_printing rect has some area to it, accept drawing commands over that area. Derive from the wxPrintout and do the stuff we need to. Defines the entry point for the application. Every application needs to create a derivation of hte wxApp class as an entry point. Define a new application Create the main appplication window frame, and initialize all of the pre-ordained dialog box objects. This is called when the main window is created. We make the window visible here. Do some garbage collection and other cleanup, if you are debugging for memory leaks this may be useful. Boilerplate stuff for the windows message pump. the frame is the main application window. Define most of the dialog boxes and similar gadgets that are defined in this program. A text widget in a dialog box. Acts just like a wxTextCtrl combined with a sizer. Create the widget and bind it to the parent window release the resources Act just like a sizer to the client Set the value of the widget The label for the control the control itself the parent sizer Act just like a sizer, allow the user to make boolean choices. Implemented as a checkbox probably Allows the user to choose a number with arrows up/down that increment /decrement the values. Just displays progress for a long operation The dialog box that contains all of the display choices like page size, etc. The dialog box that contains all of the display choices like page size, etc. A dialog box that allows the user t ochoose some options that affect the parser. Allows the user to choose midi player, etc. Each major window in wxWindows consists of a frame and a canvas. Define the frame. The canvas is described in wx_winres.cpp. Abstract method that gets the current tune choice from the user. Abstract method that clears the list for new parsing. >>>>>>> 1.3