log

------- ------- ------- ------- ------- ------- ------- ------- ------- -------
2022-08-15
  - small redesign: when created, the eightStepSequencer will have all step
    velocities set to '0.5' instead of '0.0'

    
2022-06-10
  - fixed up audio workers. For some reason, its now not possible to transfer
    wasm modules to a worker, so now I'm transferring the wasm code and having
    the worker compile it.
      There also seems to be some issue around holding onto the references of
    array buffers, meaning that they need to be re-generated on every process
    loop. From what I've heard this doesn't have a performace cost, but I
    haven't tested this.


2021-06-24
  - began work on audio_buffer_type_2, which has multiple playheads


2021-06-22
  - finished off and moved audio_buffer_type_1 from workshop into production


2021-06-02
  - moved integrated_synthesizer_type_1 from workshop into production


2021-04-01
  - updates to the explainPage to add links to the help and github pages
  - updated the FAQ page to include a section about the site not working on
    some browsers (I should really test Edge and Opera)


2021-03-22
  - modified the /help/getting_started site so that videos are only loaded when
    their frame comes into view. Instead of the page loading all of them at the
    same time in a random order
  - added more items the faq, and changed the graphics a little of the whole
    site to work better on different screens.. not perfect but certainly better


2021-03-20
  - made the last of the documents
  - re-rendered the covers into smaller png files, so that the library site
    loads faster. The site now also recognises pixel densities, so there are
    three covers available; full original resolution, 250px horizontal and
    double 250px horizontal (so 500px)


2021-03-18
  - more work on documents (added the momentary_amplitude_meter and
    stable_amplitude_generator)


2021-03-14
  - updated help/library layout code again. It's much better now, though really
    the page could use a small redesign


2021-03-12
  - more work on documents


2021-03-10
  - updated help/library layout code.. which is only a little better and needs
    more work


2021-03-08
  - more work on documents
  - added check to frequencyAmplitudeResponseAnalyser worklet, which checks to
    see if there's any input before attempting to add that output to the
    internal step data. This used to cause the F/AR Workstation to become
    inoperable if you pressed the start button when nothing was plugged in


2021-03-04
  - more work on documents


2021-03-02
  - modified frequency_generator and data_controlled_frequency_generator unit
    backing images to make the 'detune' dial markings match what the math is
    actually doing
  - more work on documents


2021-02-26
  - more work on documents


2021-02-24
  - more work on documents


2021-02-22
  - added more documents (all Harbinger's documents are now in)
  - fixed issue in the Harbinger RDP, where cut/copy/pasting didn't work
    properly. Seems in some of the code, it would clear the clipboard. This 
    would happen immediately after cut and paste operations, and was a quirk of
    the refreshLEDs function, which would reset the Unify button, which in doing
    so would clear the clipboard.
      Clearing the clipboard is important however, as otherwise while in unified
    mode the pasting function will expect a multi-dimensional array in the
    clipboard. If the clipboard wasn't cleared during the switch to Unified mode,
    then the old single-dimension data structure will be present, causing an
    error. The solution was to add an if statement to the unify button's code 
    that detects if the incoming value is different to the current one. If so,
    the clipboard is cleared... it's admittedly a little messy.
  - added the 'next' site, to hold the new software (well, test programs)


2021-02-10
  - cleaned up what images the Harbinger units were using, plus replaced the
    DSDS images with new ones
  - fixed some issues with the Harbinger DSDS, where the preset buttons weren't
    using the preset saver function correctly. There was a little confusion
    over what numbers to use, so I made things easier by making them the same
    as the preset selection function
  - work on Harbinger's documents (dsds added, mrd underway)


2021-02-08
  - some of harbinger's common images were misnamed 


2021-02-04
  - swapped the names on CurveTech's Multiplexer and Demultiplexer, as it turns
    out I had them the wrong way around
  - finished the Curve Tech devices document, and wrote the company paragraph


2021-02-02
  - added a document for Curve Tech into the library, for the interface units,
    and made a start on the devices


2021-01-31
  - added a document for Curve Tech into the library, for the logic gates


2021-01-29
  - added the audio combiner unit to the Alpha collection, and modified the 
    audio duplicator slightly to make it match in size
  - changed the print name of curveTech to CurveTech
  - changed the look documents in the library web page have when they are
    hovered
  

2021-01-27
  - changed the Reverb Unit to display that it's counting from 1 instead of 0.
    Also changed it so that the dials both start at 0.5 instead of 0, which now
    matches how the internal circuit starts
  - renamed the miscellaneous section of the Alpha collection to Routing
  - more work on the Alpha document
  - updated Alpha's Amplifier and Audio Duplicator backing image
  - began work on the Audio Combiner


2021-01-25
  - repaired the needleOverlay control part. When it was to remove a needle, it
    just removed it and assumed that the group of elements would still be
    around. Unfortunately, this is not the case, as removing a group from a 
    group causes all the children to be destroyed..which in retrospect is not a
    fantastic method. The problems arose when the needleOverlay part tried to
    readd one of these needles, and only the group itself was there, thus it
    was invisible to the user. I fixed it by making it make a new needle every
    time. There was a similar problem with the area, which was fixed in a
    similarly ham-fisted way I will need to redo how the remove function works
    in core
  - added the method currentPlayingState to the player circuit, which returns
    data on whether playheads are playing or not
  - fixed two problems with the audio file player
    1. the needles were disappearing when you stopped/started them (see the fix
       at the top)
    2. the needle counter was giving the wrong number for multiplay mode. It
       didn't understand that not-playing playheads shouldn't be counted. Adding
       the currentPlayingState means that the unit can now figure out which are
       actually relevant
  - small correction to one of audio_file_player's voltage callbacks, which had
    a mistake in spelling. "vconstcurrent = ..." instead of "let current = ..."
  - more work on the Alpha document


2021-01-21
  - removed the 'curve' logo from Alpha's Amplifier
  - more work on the Alpha catalogue document, I've added it to the library (we
    need to redo how those covers are being arranged, and how they hover)


2021-01-19
  - more work on the Alpha catalogue document


2021-01-17
  - started on the Alpha catalogue document


2021-01-15
  - finished up (for now) on the CUIS document, created a section for the IEC
    and added the document. Also added descriptions for groups
  - added some words of encouragement to the main help page


2021-01-14
  - modified the control layer's queryString section, to make the demo loader
    only load demos, and have a separate url parameter finder for any address;
    "autoLoadScene" (which I might change)
  - began work on the CUIS document


2021-01-13
  - added more options to the help section of the menubar
  - modified library's functionListRunner to return a bool depending in whether
    a function of the provided list was run
  - modified the keyboard section of the system layer. Now in a key-down event,
    if a function on the function list is run and the 'command' key was
    involved (which only happens on MacOS) the "releaseAll" method is run to 
    release all keys. This is a rather ham-fisted solution to the browser not 
    sending key-up events for keys when a combination is released in a certain
    order, specifically for the command key on MacOS.
      For example pressing 'command' then 'z' will activate both keys; but
    releasing 'z' first will not register the 'z' key-up event. 'command'
    however will be when it is released. If 'command' is released first then
    'z', both will be registered. In the first case, any subsequent presses of 
    'command' will be interpreted as 'command-z' as the 'z' key will apparently
    still be pressed.


2021-01-12
  - more work on the help site (added an FAQ page with neat drop down boxes, and
    side-bar navigation to the 'Getting Started' page)


2021-01-11
  - started work on the "Getting Started" section of the help site, making
    little videos of things you can do (along the way discovering that pasting
    doesn't work)
  - fixed issue where the paste command wasn't working. The code that was being
    called didn't have the information that was needed. It was trying to call
    core.viewport.getMousePosition - which didn't exist as it had been renamed
    core.viewport.mousePosition - but even then, there was no mouse position to
    get as the values it would have been pulling from were never populated. 
    I've now moved this method to the callback section and have placed the 
    mousePosition method there. The callbacks which attach to the canvas are 
    now populating the mouse position data
  - updated the help option in the menubar to have links to the help places


2021-01-10
  - put together a document library site, which will showcase all the pdf 
    covers


2021-01-09
  - more work on the Acoustic Research Sigmoid's Affecter document


2021-01-06
  - started making a document for Acoustic Research Sigmoid's Affecter. This 
    is the first of the "technical" documents for the help section


2020-11-27
  - changed connectionNode_audio again to have an outputChannelIndex value, a
    lot like the inputChannelIndex from yesterday. This should be helpful to
    audio nodes with multiple output streams


2020-11-26
  - created a new unit for Acoustic Research; the Data Controlled Frequency
    Generator, which is exactly the same as the Frequency Generator, but the
    frequency is controlled by a data input. It uses the
    integrated_synthesizer_type_1 audio node directly, so, I'll need to create
    a circuit for it. Some very funky sounds are possible with this,
    particularly if you have two of them and you feed them into each other
  - modified connectionNode_audio to have a inputChannelIndex value, which can
    be set like the audioNode one is. With it, you can select which channel
    index the incoming audio node connection will be connected to on the 
    destination audio node. 
      This should remove the need for the "nothing" audio node, whose main job
    was to be connected to the non-zero index channels of multi-input audio
    nodes, in order to allow other incoming audio node connections to use the
    index 0. Circuits will have to be re-written, though by removing the
    'nothing' nodes we're reducing the number of audio nodes and thus the
    amount of memory and processing time needed to have them (as little as
    that probably was, considering how much they do (which is nothing (hence
    the name)))
      This also kind of removes the need for a 'circuit' for this audio node,
    and probably other nodes will follow suit.
  - modified Acoustic Research's gain node to use the gain audio node directly,
    using the features added above
  - modified the Point struct in the core wasm engine to have get_ref_x and 
    get_ref_y methods, which are then used in SimplePolygon's
    intersect_with_point, in a mad bid for speed.. I'm not sure it's done
    anything, though it hasn't hurt either
  - modified SimplePolygon's intersect_with_simple_polygon__intersect_only
    method to check to see if any of the a's points are within b - and vice
    versa - early in the function. This has spend up the determine_if_visible
    method in my test of moving the musical_keyboard around (in dev mode) from 
    ~5.5ms to ~1.8ms. About 3 times faster. I've also copied all the
    intersect_with_simple_polygon tests to make a set of
    intersect_with_simple_polygon__intersect_only tests, which say that the 
    change has been successful
  - I remember another reason for the circuits. They meant that the audio
    inputs always had input, even if it was zero.. this probably was always a
    bug but I just never discovered it somehow. I've fixed it in the
    integrated_synthesizer_type_1 audio node by having that node check to see
    if there is data for the input channel before attempting to copy it in.
    I'll have to do similar moves on other audio nodes


2020-11-24
  - modified the menubar (on the control layer) further to streamline the
    styles (and not have copied data) Styles are now stored in a "styleLibrary"
    Styles can be set using the _canvas_.control.gui.style.set method, with the
    name of the desired style
  - replaced the errorPage with an explainPage, which produces the same output
    as the old errorPage, but you can now create "info" pages too, that are
    less aggressive. You just need to set the "level" url argument to either
    "info" or "error". Urls that once used the errorPage have been changed to
    use explainPage, and the new "StartAudioContext" button thing in the
    menubar, now has a "why?" button that opens up an explainer page about why
    you need to activate the audio context
  - slapped together a development unit for the integrated_synthesizer_type_1


2020-11-23
  - modified the menubar (on the control layer) to have the ability to add
    right-hand-side items. There is now a "side" attribute which can be set
    to 'left' or 'right' (left being the default) The items stack right to left
    and their drop downs are aligned on their right side (like a mirror of what
    happens on the left)
  - added a new styling option "important". One  can now use the attribute
    "important: true" when describing the dropdown menu to indicate that it
    should use the 'important' styling
  - added menubar item (on curve layer) to give the option to activate the audio
    context. This item only appears on startup if the audio context is not
    already running, and will disappear when clicked
  

2020-11-22
  - oops! Used the wrong words in the synthesizer_2 circuit
  - began work on a new audio node; integrated_synthesizer_type_1
  - it seems that "exponentialRampToValueAtTime" works on chrome now, so I've
    removed the console message that said it woueln't
  - added error output to the connectionNode_audio _ondisconnect code, so, you
    can see the errors in future, but they won't stop the whole program


2020-11-21
  - created a circuit for the oscillator_type_1 (with the same name) and
    changed the Frequency Generator to use that instead..I'm flip-flopping
    around a bit, but I think the circuits are actually a good idea
  - same as above, but for the amplitude_modifier, bitcrusher, gain,
    lag_processor, sigmoids_affector and stable_amplitude_generator. Also the
    stream_adder, though I'd missed that one yesterday, so I didn't need to
    undo any work, only add the shutdown sections
  - threw out the white noise generator audio node, as no one was using it and
    you can get the same functionality from the oscillator_type_1 node
  - only code that uses the old oscillator interface circuit is the
    synthesizer_2 interface circuit, and no one uses that, so I've commented
    out both (there's some interesting code in there regarding control of the
    envelopes) These circuits weren't used originally (I think) because the
    system wasn't able to keep up with the js-based audio nodes that they used.
    Things are different now of course thanks to rust and wasm.


2020-11-20
  - modified the "nothing" and "oscillator_type_1" audio nodes to have
    'shutdown' methods, which stop the process loop, thus removing their load
    from the audio rendering thread. I'll need to add this to all audio nodes
  - updated the frequency generator to shutdown audio nodes on its deletion
  - modified the amplitude_modifier, bitcrusher, gain, lag_processor, sigmoid,
    stream_adder and stable_amplitude_generator audio nodes to have
    'shutdown' methods
  - modified a number of Acoustic Research's units to use audio nodes directly,
    instead of the circuits from the interface layer. These units also shutdown
    the nodes on deletion, which led to an issue with a double disconnect
    attempt on the nodes when the unit is deleted (while still being connected)
    I've had to add a "try/catch" statement around the disconnection node in
    the interface layer's connectionNode_audio.. its a bit of a messy solution,
    but it works.


2020-11-19
  - put together new oscillator "oscillator_type_1" which uses wasm for 
    processing
  - updated Acoustic Research's Frequency Generator to use this new oscillator.
    It also skips over the interface section, so, things are a little more 
    involved, but it just as good


2020-11-17
  - dark-mode / light-mode is now selected based on the time (on start up). So
    between 8pm and 8am, dark mode will be activated. Of course, the url
    argument still works as does the menubar's tool's checkbox


2020-11-15
  - small modification to the image element in core, so that it now deals with
    bitmaps and urls separately, and on initial creation, doesn't require the
    url to be loaded (even if that url is blank) Thus stopping the need for a
    double frame render to get the bitmap displayed


2020-11-14
  - upgraded the lag_processor audio worklet to use wasm (upgrading the 
    interface circuit accordingly)
  - upgraded the gain audio worklet to use wasm (upgrading the interface
    circuit accordingly)
  - fixed the import function for the stable_amplitude_generator


2020-11-13
  - did a little renaming of produced wasm files, so that now they are of the
    format "name"."mode".wasm. So, for example, you can have
    "core_engine.development.wasm"
  - shifted audio worklet rust compilation code into the main comp.sh file, so
    now there doesn't have to be comp.sh files in every "rust" directory of
    these audio worklet things 
  - simplified the way these new audio nodes request their wasm files, by
    pulling that code out into the function
    _canvas_.library.audio.audioWorklet.requestWasm. This removes repetitive
    code and shrinks down the nodes nicely
  - modified the bitcrusher to use a struct with lazy_static, which doubles
    the size of the wasm file, but does mean that I don't have to use Vector
    allocations and can just have static arrays defined upfront. I'm not sure
    if it actually goes any faster, but it does remove some lines from the
    processing code, and makes that a little simpler for me. You also don't
    have to pass pointers back to the processing function either
  - upgraded the sigmoid audio worklet to use wasm (upgrading the interface
    circuit accordingly)
  - removed all mention of the WebGl2textureFramebufferManager from the
    system. The file for it is still there, and the system wasn't using this
    code, but still an instance was being created and just passed around a
    lot. There's still a lot of "framebuffer_active" values around though.
    I'll just leave them for now. I've been watching the chrome debug output
  - as the site has been crashing lately - and noticed errors related to
    Framebuffers, so I figured I would just remove it, even if they weren't
    actually in use..I don't think it's helped though
  - upgraded the stream_adder and amplitude_modifier audio worklet to use
    wasm (upgrading the interface circuits accordingly)
  - slight change to the nothing audio node, now that I know that the .set
    method exists
    

2020-11-12
  - rearranged how the audio nodes section of the library is layed out, and
    initialised on startup, all in prep for the new audio nodes that have wasm
    elements.
  - updated the comp.sh script to have options for compiling the new 
    wasm-infused audio nodes. Also rearranged the "wasm" folder in "docs" to
    have subfolders for "core" wasm files and the upcoming audio node wasm.
    Also also updated the comp.sh script report section to give information on
    the compiled wasm files including when they were created, what size they
    are, and the first 10 lines of the twiggy output
  - wrote up a new version of the bitcrusher audio node which uses wasm to
    process the data
  - swapped out the old bitcrusher for the new one, in the interface circuit


2020-11-06
  - redid the core library's geometry shapes. Now, the detect_intersect code is
    all included in the shape's struct (with cross-back so all comparison
    directions are covered) I've also updated this code quite a lot, improving 
    its accuracy and adding new information to the returned result.
      Also the Polygon shape has been renamed to SimplePolygon, in preparation
    of...
  - added the Complex Polygon to core library's geometry shapes, which has
    holes. The shape is defined as a "body" SimplePolygon with any number of 
    "hole" SimplePolygons
  - polygon shapes have also had the "convert to sub-triangles" included into
    their structs
  - the polygon shapes detect_intersect code was a little sluggish - probably
    due to the amount of work it had to do to gather all the information for
    the result - so there is also a reduced version of one of the shapes
    methods (simple poly on simple poly) that only returns the "intersect" 
    value, as in some cases this is all that is required

  I need to get ComplexPolygon on ComplexPolygon comparison working, if I am
  to get polygons with holes (or Swiss polygons) working (needed for looped
  paths) I've spent a lot of time working on this new set of comparison methods
  though, and it's honestly started to depress me with how difficult it is to
  get working and how much detail and patience is required.. something I guess
  I've ran out of after the last week. Luckily we can get away without this
  shape for now and focus on other more exciting improvements and features.
  In future I hope to make a return however, and finish this mess off


2020-10-27
  - removed all the usage of framebuffer code, simplifying things (I'm going to
    give it another try)
  - core/beta added "Frame Skipping" activation control
  - modified the mouse zooming code. For a mouse zoom you have to discover the
    workspace point under the window point, make the scale change, then get the
    new workspace point under the window point and perform a position change to
    get the workspace point under the window point to be the same as it was
    before the scale happened. This used to all happen in the mouse code over
    in the control layer, but I've mode all that into a new viewport method
    within the engine. This is faster, as the math can all be done in wasm
    but more importantly; there isn't a double viewport change, thus no double
    visibility calculations.
      This new viewport function has to report back to the viewport
    representation what the new position is, however, which is done through a
    promise. Hopefully that will be fine.


2020-10-26
  - subframe working much better now, thanks to a few webGL tricks. However it
    is a little slow and so cannot be used for unit-by-unit subframes as I had
    wanted.. more work needed. Also the whole system is working off the texture
    one, where the root group should be using the renderbuffer-only one..
    little things


2020-10-25
  - work on the subframe. Still under development unfortunately. Modifications
    have been made to the way that the framebuffer for the root group is
    generated however, and there are new methods for the 
    WebGl2programConglomerate and WebGl2programConglomerateManager structures,
    which need review...


2020-10-24
  - updated comp.sh and the way compilation is done, a little. Comp.sh now can
    produce two versions of the core-engine wasm file, or more accurately, it
    saves the optimised and non-optimised versions under different names in
    docs/wasm; core_engine_development.wasm and core_engine_production.wasm.
    It also now modifies the min.js files to use this core_engine_production
    file instead of the default core_engine_development one. This was done to
    avoid the mistakes I was making of producing production versions of the
    program, then accidentally making a development version which would
    overwrite the optimised wasm file. This could make it look like the
    optimised version wasn't all that fast, where in reality the system was
    using the development version with the production js code. The updated
    comp.sh clears this all up by keeping the production and development code
    and files separate.


2020-10-22
  - small modification to stop the arguments for a stats command from being
    executed if stats is not active 
  - added way of setting whether the stats section should be active or not
  - added _dump method to stats


2020-10-21
  - updated the way timestamps are collected in the stats section, for better
    accuracy (and no more infinite fps, unfortunately)
  - added a stats section to core engine's wasm code, so it now can measure the
    percentage of frame skipped. (I also made an attempt at calculating
    something like this for all elements, but I think that might have been a
    little close to the sun.. and a little unneeded)


2020-10-20
  - slight change to the "frame" method in the rendering section of 
    core-engine's wasm code; which checks to see if the root group needs to be
    rendered. If not, it bails out of the entire function. This in turn means
    that no new frame is sent to the main thread, saving lots of time. This has
    brought back the famous "potentially infinite fps" stat
  - added "overscroll-behavior-x: contain;" to the same part of the engine that
    deals with overflow, so it will automatically be added when the mouse enters
    the canvas, though only when viewport.stopMouseScroll is active. This is to
    stop accidental back/forward actions
  - updated _canvas_.control.viewport.refresh so that it waits for the 
    _canvas_.core.meta.refresh() function to finish before refreshing the gui
  - fixed issue with player circuit which caused new audio buffer's to be
    generated constantly, not deleting any of the old ones and leading to issues
    with searching for buffers that could be reused, finding none. Causing the
    search to take longer and longer each time... I'll probably need to review
    this circuit. Maybe create a more specific one for the playback of short 
    samples that don't need to be looped or to have the needle jump around 
    within them. The Player circuit might be a little too general-purpose


2020-10-19
  - further work on full-frame render culling Seems to be working rather well
    now. I also have it multisampling to deal with the aliasing. You can also
    adjust the number of samples from the dev menu
  - fixed issue with list radio items not being able to display the number zero
  - updated comp.sh to use printf instead of echo for the report, as there was
    some issue switching between bash and zsh (I was using the -e argument
    with echo, which was fine on bash, but zsh was just printing it out like
    it was just another part of the test to be displayed)
  - fixed incorrect decimal point sizing on readout_sixteenSegmentDisplay
  - fixed jumping numbers on the readout of the audio_recorder unit (padding
    was set up wrong)

  : results
    -> core_engine
          core_engine.js 1052kb
          core_engine.min.js 346kb
          reduced to 32.94% of original size
    -> test
          test.js 3601kb
          test.min.js 1199kb
          reduced to 33.32% of original size
    -> core
          core.js 1568kb
          core.min.js 510kb
          reduced to 32.54% of original size
    -> system
          system.js 1579kb
          system.min.js 515kb
          reduced to 32.63% of original size
    -> interface
          interface.js 2768kb
          interface.min.js 824kb
          reduced to 29.79% of original size
    -> control
          control.js 2911kb
          control.min.js 874kb
          reduced to 30.03% of original size
    -> curve
          curve.js 3817kb
          curve.min.js 1207kb
          reduced to 31.62% of original size
        

  2020-10-18
  - work on full-frame render culling (adding sections to determine whether
    group's require a rendering, or if they haven't changed since the last
    render)


2020-10-17
  - modified updateGravity.sh to have a help argument and the ability to list
    what versions are available
  - modified comp.sh to have a help argument. There's a way of listing out what
    wasm editions are available, and it now automatically gets the appropriate
    js files for the selected wasm edition (and can tell you when an edition
    doesn't exist)
  - fixed mistake in how child visibility is determined when added to a group
    (I was using the wrong value for parent_clipping_polygon)


2020-10-16
  - updated core-engine
    - Alot of offset calculation is now done when the arrangement is modified
      instead of at render time.
    - All render judgement has also been moved to not be performed at render
      time, which has resulted in a noticeable boost to frame render speed.
    - In addition the "heedCamera" status of a group has been expanded from
      true/false to true/false/dontCare, which has allowed a more elegant
      computation of camera heeding at all levels of an arrangement.
    There's also a sort of master/beta/alpha file structure in the rust section,
    just so I'm not irreversibly breaking everything

    Noticed some issues with looping paths however. The system doesn't seem
    to be able to understand them at all in-fact, instead producing a
    regular polygon. Luckily this kind of shape doesn't come up that often 


2020-10-04
  - fixed issue where the connection nodes of units wouldn't be interactable
    sometimes. Turned out there was an issue with the group element's
    augment_extremities__remove function, which wasn't calculating the new
    extremities correctly. Seemed I'd forgotten (again) what the arguments
    were for BoundingBox::new, which was confusing the rest of the code
  - fixed Alpha's basicSynthesizer so that it can do gain and detune wobbling
    again. Detune was never implemented in synthesizer_2, so I've puled over
    the old method from synthesizer_1. Gain wasn't working because the gain
    node within synthesizer_2 wasn't set to the mode to have its value
    controlled by another audio stream.
      I've also adjusted the interface a little, to match what the 
    synthesizer_2 can actually do. Now, periods are only between 1 and 10 a
    second (it is the basicSynthesizer after all)
  - restructured things a tiny bit in the interface circuits. Now the
    synthesizer_2 is actually called synthesizer_2 instead of being
    referred to as synthesizer_2 but called synthesizer
  - Acoustic Research's MomentaryAmplitudeMeter wasn't working, because the 
    momentaryAmplitudeMeter audio worklet was getting into trouble. Seems
    the input sample array can be empty, which confused things. I've put a
    check in so that the length has to not be zero before anything is done


2020-10-03
  - replaced the old gravity with the new, fresh, sophisticated, educated,
    elegant and rather attractive Rust based one (which now has its own github
    repo https://github.com/metasophiea/gravity)


2020-09-30
  - I've learned Rust and WebAssembly
  - complete rewrite of the rendering engine (the core layer) to use
    WebAssembly (written in Rust) and the primary method of getting work done.
    Some necessary JS remains, though I will be working to remove as much as
    possible (mainly library functions. Some of the more complex ones I didn't
    try to convert, along with those that do the work of requesting multiple
    items at once from URLs, which is much easier to do in JS..primarily because
    there's no multi-threading in WebAssembly)
      System is still using the console/engine concept, thus much of the rest of
    the system can remain as it was, bar a few changes in naming. Overall the
    new system is a lot like the old, with a few differences:
      - the canvas element has been removed. Instead the Image is used in its
        place which had all the bitmap update code needed anyway
      - full-frame rendering culling has been removed. I plan on putting a 
        lesser version back in soon, but only temporarily as I work on a more
        advanced sub-rendering solution which should improve render performance 
        greatly with respect to scenes where much - but not all - of the 
        on-screen content is unchanging, which would cause a full-frame to be 
        rendered in the old method
      - the viewport positioning has been redone a little. Now the XY point
        will be correct, though this has the effect of ruining any positions
        that were in old saves. An easy fix if you just open that file,
        reposition and save
      - window scaling is being managed now. Before, I had assumed that there
        were only two pixel densities; 1 and 2. Which made sense as my
        desktop was 2 and my work laptop was 1. This is true for screens,
        but if you adjust the zoom of a page it can become any number. The
        engine can now account for this; adjusting the canvas size and pixel
        density to match what should be on screen. In effect, when someone
        with a screen of pixel density of 1, zooms the browser out to 50%;
        the canvas is now running at double the pixel density on a canvas 4x
        larger (2x in width and height) This now continues correctly for all 
        zoom types. I still need to test on a windows device however...I'm
        quietly confident.
  - improved the stop overflow activation code, so that now it additionally
    activates when the mouse first rolls the wheel, though is smart enough not
    to be constantly sending that css update. This was done, as if you refreshed
    the page with your mouse over the canvas, the overflow wouldn't be changed
    and mouse wheeling would cause the window to attempt to scroll. Not such an
    issue on more browsers, but on Mac it caused an unsightly attempted-scroll
    effect
  - fixed issue with the MRD-16, where buttons and selectors wouldn't glow
    appropriately when the scene was loaded
  - added a viewport lock to the tools menu


2020-06-25
  - perhaps something changed in chrome, but the tests weren't working anymore,
    as when one of them attempted to create a canvas (for graphing, like the
    library tests do) this would expand the number of canvases in the document,
    causing the global code allocation loop to run again on this new canvas,
    which would create a new canvas which would expand the number of canvases
    in the document, etc.
      It's fixed in the test.js file, but not the others. Something to watch
    out for. test.js now collects all the canvas elememts, but then filters by
    which have the "__canvasPrefix" as an attribute
  - misc test loadFileFromURL returned fail..I think jst because the test was
    wrong however. There had been some changes to the loadFileFromURL
    function's arguments which weren't reflected in the test
  - odd situation in the engine image element, where if you set the url to ""
    from the start; the element would be fine with this, until the data had to
    be called during render, which wouldn't be fine. Fixed it by setting the
    initial value of the url to "undefined" and also telling the hidden timeout
    thing to set the url to the defaultURL but I'm still interested in what was
    causing the url to be set to "". I think initially, the console just sends
    over all the information. It doesn't care if its defaults are the same as
    the counterpart's
  - updated the layer controller so that its more in charge of layering, and
    responsible for calling the functions of layers when lower layers have
    completed loading, taking this responsibility from the layers themselves
      This is the one sort of update that doesn't bump any version number, as
    this is a very low-level, basic, functional, managerial, funky sort of 
    part. Probably. Though it does require lines to be re-written in lots of
    places so that they use the new system of starting, instead of their 
    internal ones.. also had to remove that internal start-up code from all
    the layers.. just call me a bad programmer and move on


2020-05-10
  - fixed some spelling mistakes, added words to the readme to say that I was
    learning Rust and removed lots of redundant code from the workshop section.
    Also emptied the trash


2020-03-21
  - after some efforts, I've decided to switch back to the old synthesizer
    which used the built-in oscillator. I just can't get the custom one to run
    fast enough, or to not produce garbage collections. I've reinstated the old
    synthesizer as synthesizer_1, and named the newer one synthesizer_2
  - modified control.scene.unitManipulation.removeUnit to run the hidden
    _onDelete method after the connections have been disconnected
  - core_engine's arrangement.printTree service function didn't have the
    correct arguments
  - modified core so that when a group is removed, all its group children also
    have the remove command run on them, and runs the "onremove" callbacks
  - updated core's removal method, so that if the element to be removed isn't a
    direct child of the group, nothing is done
  - modified core's group element, to have a 'shift' method, which can be used
    to move a child around in the rendering order (though, it's not quite
    working during the delayed communication situation)
    ...sort of fixed it by removing the delayed communication situation code.
    It seems that the delay code sets up a callback that is called when the
    newly created element receives its ID from the engine, but the
    append/prepend method is also doing this, and obviously you can't shift an
    element in a group without it being part of that group; but creating that
    callback overwrites the callback created by the append/prepend method,
    thus stopping the element from ever being included. To fix, one would need
    to turn the callback into a callback list or something, or create an
    'insert' method that the append/prepend method uses, which would never
    be overwritten be the shift method, only have the destination changed.
      For now, it's pretty much fine. I have plans to rewrite core in webASM
    anyway, so, we can put it on the docket for then. Plus core isn't going to
    develop very far from here anyway, so we have space for these poor quality
    fixes...for now
  - all this, fixes a long running problem that I thought I had in the bug list,
    but it seems wasn't there. When units were being removed, they weren't
    removing their connection nodes correctly. This was because their 
    'onremove' callbacks weren't being called; only the 'onremove' callback
    of the master group. Now, these callbacks are called for every element in
    a group thus activating the connection node's 'onremove' callbacks, thus
    removing them correctly from the scene
  - removed some of the old workshop folders (they've safely stored away on
    my desktop)


2020-03-18
  - rewrote the 'perform' method of the synthesizer_3 circuit, to hopefully be
    more reliable. There's still some note dropping though
  - updated Alpha's launchpad unit, to better handle the sending of signals
    (sending slightly less now. Less needless ones)
  - updated the oscillator worklet to have envelope reporting as an option,
    instead of on by default.. the 'process' itself, might be a little heavy
    on the poor audio thread though


2020-03-17
  - modified the custom oscillator to take a velocity value when activating
    the start command
  - modified the synthesizer_3 circuit to send velocity data to the oscillators
  - finished jiggering around with Alpha's Basic Synthesizer, so that the new
    synthesizer circuit fits into it nicely. Changed the range of the two period
    dials, and their format too. Now, one can select how long the period is,
    between 0.001 and 2 seconds.

  synthesizer_3 circuit is better, but still a little weird. Sometimes on my
  laptop it skips notes and I can't tell why.. also, the internal LFO and
  external control system needs to be looked at, considering we had to fix up
  some of the dutyCycle stuff in the custom oscillator along the way 


2020-03-11
  - cleaning (removing commented out code, and renaming items like "thing_3" to
    "thing", if there's no other "thing_n" items around)
  - began expanding the custom oscillator to have more wave creation modes.
    Currently working on additive synthesis and phase modulation, which is
    going rather well
  - modified the oscillator and synthesizer circuits accordingly
  - updated the basicSynthesizer unit to have access to the additive synthesis
    features of the synthesizer/oscillator
  - somehow messed up the synthesizer's ability to play many notes quickly
    -thumbs up-


2020-03-10
  - wrote a license, as I'm a cool person now
  - trashed the "martinez.js" thirdparty code, as it wasn't being used
  - updated the thirdparty code "earcut" and "opentype" to whatever the latest
    version was (the other two haven't been updated in years) They seems
    stable.. we'll find out I guess. I've kept the old versions around anyway
  - replaced the internals of the basicSynthesizer unit, to use the newer
    synthesizer (I'll probably need to redo the unit a little, as I've changed
    the values of dials slightly)
  - commented out the old synthesizer and oscillator circuits
  - renamed those new synthesizer and oscillator circuits to remove the
    numbering (making them, the default essentially)


2020-03-09
  - updated synthesizer_3 to include a master gain
  - updated the oscillator2 worklet to output all phases as they change
  - updated synthesizer_3 to work with this new output (might need a little
    testing)
  - created the oscillator2 circuit, which houses the oscillator2 worklet
  - changed how the oscillator2 worklet calculates the dutyCycle in an attempt
    to balance out the different control inputs
  - made a start at updating the Frequency Generator to use the oscillator2
    circuit
  

2020-03-08
  - put together the Acoustic Research's Frequency/Amplitude Response
    Workstation (called "F/AR Workstation" because it's just a huge name) unit
  - updated grapher display part to handle situations where there's no styling
    information for a layer
  - updated the F/AR Workstation to handle multiple graphs more elegantly (6
    can be displayed simultaneously, though I think I'd like to remove that cap
    and have older ones simply fade away as new ones are added)
  - updated the frequencyAmplitudeResponseAnalyser worklet to return the
    collected data when the stop command is received
  - updated the F/AR Workstation to have LEDs which show progress, also all
    controls now freeze when the analyses is running. Also also, previous graphs
    can be stored on-screen (by not clearing them) and they will fade as new
    graphs are added


2020-03-07
  - more oscillator work. I'm pretty happy with it now
  - oscillator is now even more advanced, with envelopes for the gain, detune
    and dutyCycle aspects. They each use the graph slightly differently though,
    so you need to be conscious of that
  - put together a new synthesizer for the new oscillator (hopefully, it will
    replace the current one)


2020-03-06
  - more oscillator work (I think I might have cracked it)


2020-03-05
  - more oscillator work


2020-03-04
  - some adjustment to the positions of those voltage connection nodes from
    yesterday, as I wasn't super happy with where some of them were
  - began work on a new oscillator that includes an ADSR envelope. It's going
    well, I'm a little iffy about how the logic is, but it seems to work


2020-03-03
  - created a circuit for frequencyAmplitudeResponseAnalyser audio worklet
    (originally wrote it using private values, but apparently that's a bit too
    modern right now. So, I've re-written it in the old fashion way (like
    "_value") but kept around the old code when the world catches up)
  - updated all relevant Acoustic Research units to have signal and voltage
    connection nodes, to adjust their various options
    
      
2020-03-02
  - added "Reset Cursor" option to the dev menubar dropdown
  - added 'active' parameter to the momentaryAmplitudeMeter worklet, which can
    stop all calculations if set to false (0)
  - new work on the new frequencyResponseMeasure circuit/worklet is going much
    better


2020-03-01
  - finished off the Frequency Generator unit
  - added the momentaryAmplitudeMeter circuit
  - tiny bug-fix in the momentaryAmplitudeMeter worklet
  - added Acoustic Research's Momentary Amplitude Meter unit
  

2020-02-29
  - created Acoustic Research's Stream Adder unit
  - updated the custom oscillator to have a 'white noise' option (making the
    whiteNoiseGenerator worklet obsolete, probably)
  - created Acoustic Research's Frequency Generator unit


2020-02-28
  - more work on the custom oscillator
  - expanded the momentaryAmplitudeMeter audio worklet to include an on-request
    mode
  - set to work on the frequencyResponseMeasure circuit, but it's not totally
    working out.. I'll have to try again


2020-02-27
  - added the whiteNoiseGenerator circuit
  - created the streamAdder audio worklet and circuit
  - more work on the custom oscillator


2020-02-26
  - created a circuit for the new oscillator and put together a test unit for
    it.
  - began experimenting with oscillator with multi level phase modulation,
    which is pretty out-there and I've yet to figure out how to do it right
      frequency = 1
      phase1 = 4 amp1 = 1
      phase2 = 3 amp1 = 1
      phase3 = 2 amp1 = 1
      phase4 = 1 amp1 = 1
      func Z(x,freq,amp,phase,offset){
        return sin(x*freq*phase + (pi/2)*amp*offset)
      }

      A = Z(x,frequency,amp1,phase1,0)
      B = Z(x,frequency,amp2,phase2,A)
      C = Z(x,frequency,amp3,phase3,B)
      D = Z(x,frequency,amp4,phase4,C)


2020-02-25
  - even better progress on the custom oscillator audio worklet; now there's a
    way of skewing the triangle waveform into a sawtooth (in either direction)
    thus reducing the waveform modes to 3, but keeping every originally planned
    waveform and adding a lot of adjustability. There's also gain and detune
    inputs (though I'm not too sure on how detune should work..) which, along
    with the dutyCycle parameter can all be controlled normally or with an
    audio stream. Such control
    

2020-02-24
  - added a link to the "units" doc file to the menubar
  - good progress on the custom oscillator audio worklet


2020-02-23
  - wrote a new gain audio worklet which comes with the usual control, plus an
    input channel for amplitude control
  - updated the gain circuit to use the new gain worklet instead of the
    built-in one
  - created Acoustic Research's Gain unit
  - moved the 'nothing' audio worklet to production
  - updated the synthesizer circuit to use the gain worklet instead of the
    amplitudeControlledModulator, which I'm getting rid of
  - created Acoustic Research's Stable Amplitude Generator unit


2020-02-22
  - put together the first video demo (saved as demo number 6)
  - I think I've fixed the issue with the synthesizer circuit not being able to
    played the same note twice in succession. Now if such an event occurs, the
    circuit will create a new oscillator, but only if the existing one is set
    to be stopped
  - I think I've fixed the release issue too, seems the way oscillator
    selection was being done was wrong, where it wasn't allowing old notes to
    finish decaying if a new request of the same note came in. It's a little
    smarter now, allowing oscillators to finish their release before they free 
    themselves to be used again. New requests for the same notes that are
    releasing go to a new oscillator


2020-02-21
  - did a little bit or rearranging in the interface/circuit directory.. might
    need a little more


2020-02-20
  - created a citcuit for the Lag Processor audio worklet
  - put together the Acoustic Research Lag Processor
  - rearranged the audio worklets a little (need to do a clean up of these
    things, because I feel like there's some poorly named worklets and some of
    their functionalities overlap)
  - began on the Stable Amplitude Generator audio worklet and circuit


2020-02-19
  - corrected a mistake made in the modifications made to the Eight Track
    Mixer yesterday, where a value was being incorrectly set
  - fixed some issues with the player circuit (that I tried to improve
    yesterday by being more proactive with deleting audio buffers..seems I 
    was a little too excited and was having the circuit delete things that
    never needed to be deleted)
      Also, interestingly, the audio file player doesn't seem to play files
    right unless at least one of the output connections is connected to 
    something.


2020-02-18
  - wrote up a new audio connection node which doesn't use an internal analyser
    node. Instead, it requires that the unit description define what audio node
    to use, and from there the connection node manages the connections as
    normal. All units have been updated accordingly.
      It was written in a bid for speed, in the hope that a reduced number of
    audio nodes would improve performance and remove those audio glitches.
    Unfortunately that hasn't been the case, as it seems that the glitching is
    mainly caused by garbage colletion on different threads. There's a bug
    logged for in in the chrome site


2020-02-17
  - began on the "lagProcessor" audioWorklet (which, when used in conjunction
    with an amplitudeModifier inverting the same input signal and adding them
    together; results in a form of high-pass filter. The lagProcessor on its
    own sounds a lot like a low-pass filter. Acoustic Research making
    discoveries once again)
  - added the "nothing" audioWorklet, which is a node that does nothing at
    all to the stream. In one ear and out the other


2020-02-15
  - added more curve functions to library.math. "halfSigmoid_up" and
    "halfSigmoid_down". I should do a clean up of these functions
  - updated Sigmoid's Affecter's design to incorporate the new switches and
    functions..it's a little noisy but I think it's fine
  - created all the art and interface for the new unit, Accoustic Research's
    Amplitude Controlled Modulator. I'm a little worried about the layout
    though, as it seems the designs are getting more compressed


2020-02-14
  - more work on the new synthesizer, its less simple now, though I think does
    things in a more elegant way. For example, instead of using timeouts for
    gain modulation like the old synthesizer did; this one uses a LFO with an
    amplitudeModifier circuit attached.
      I haven't figured out detune modulation yet though..so that' just a dud
    value for now.
  - modified the audioWorklet 'amplitudeModifier' to be more straightforward
  - modified library.audio.changeAudioParam's "instant" mode, so use the
    instant value setting...I might switch that bad if it doesn't work out
  - updated the Alpha unit "basic_synthesizer" to use the new synthesizer
    (only needed to change one method name to make it fit)
  - named the new synthesizer just "synthesizer", commenting out the old one


2020-02-13
  - further modified the Sigmoid's Affecter to have switches. One allows the
    circuit to use "1" as a value for the sharpness (otherwise, 0.999) the
    other switches the dial into exponential mode, so help with detailed
    adjustment in the higher values. Artwork hasn't been changed however, so
    that will need to be done in future
  - began work on a new synthesizer, which uses oscillators more efficiently


2020-02-12
  - added 'sigmoid' curve functions to library.math (I might place the S
    functions with it)
  - redid the design for Accoustic Research's Sigmoid's Affecter and finished
    off its internals


2020-02-11
  - created the "Sigmoid" audio worklet in the library
  - created the "Sigmoid" circuit in the interface layer
  - replace the circuit inside the Accoustic Research Amplitude Exciter with
    the new Sigmoid one (will have to redo the art) It's also gained a gain
    dial, so the unit will have to be re-designed


2020-02-08
  - switched from Closure to Terser. The compression seems to be just as good,
    though one will need to install terser with npm/node.js before running 
    heavyComp.sh

    - results -
      -> core_engine
            core_engine.js 1287kb
            core_engine.min.js 422kb
            reduced to 32.82% of original size
      -> core
            core.js 1374kb
            core.min.js 380kb
            reduced to 27.70% of original size
      -> system
            system.js 1386kb
            system.min.js 385kb
            reduced to 27.83% of original size
      -> interface
            interface.js 2472kb
            interface.min.js 673kb
            reduced to 27.23% of original size
      -> control
            control.js 2608kb
            control.min.js 723kb
            reduced to 27.72% of original size
      -> curve
            curve.js 3295kb
            curve.min.js 986kb
            reduced to 29.94% of original size

  - added "printSurvey" method to core's arrangement section, which returns
    a count of all the types of element in the scene
  - updated core's arrangement.printTree method to include an option for
    getting it to print out the element's type along with the id
  - updated core-engine's group element so that it doesn't even start to
    render or do any of the calculations for doing so if there are no
    children
  - finished off the amplitudePeakAttenuator audioWorklet
  - added the amplitudePeakAttenuator circuit
  - added the amplitudePeakAttenuator unit (though I've discovered that the
    math for the worklet isn't right yet)
  - modified the on-screen stat readout to have a little less useless
    information, and a calculation of how many frames per second are
    theoretically possible 


2020-02-07
  - had another try at core-engine's image element, and I think it's gone much
    better
  - updated core-engine's element's "_dump" method to not use that 'report.log'
    function that doesn't exist. They just use "console.log" now
  - updated heavyComp so that it only runs closure on core-engine (I'm still
    trying to get it to work like it did before) When you try to make a unit
    with a custom AudioWorklet you get
      curve.min.js:427 Uncaught TypeError: Failed to construct
      'AudioWorkletNode': Please use the 'new' operator, this DOM object
      constructor cannot be called as a function.
  
  turns out the situation with the very slow rendering with the old image
  element wasn't only on the mac. Apparently Linux was just doing the
  mipmapping automatically (or something) with my own mipmapping now, the mac
  runs the test fine

  - fixed bug with the new image element, where if the url had been changed
    when a previous image had just finished loading, then that old image
    wouldn't be loaded at all, and could never be as now that section in the
    memory was no longer 'undefined'. Now the system saves the image data (we
    spent that long loading it) to be processed when it's required next
    
    
2020-02-06
  - some coding errors in the "loadImageFromURL" function in the library, all
    is well now
  - made some modifications to core-engine's image element, to include a step
    to perform mipmap generation. I found it to be rather slow, adding a lot of
    processing time to each element. So, I also added a class library to store
    previously processed images. This has drastically improved the load time of
    one of the stress tests, reducing the waiting from load to first render
    dramatically.
    ...but. It seems as though I've lost the test that showed that mipmapping
    was required. I have the old version of the image element still, but aside
    from the initial loading time it quickly speeds up the render-time to
    ~0.05 seconds. The newer element has the same render time...I'm not sure
    what I've done here. I've left the newer one in though, as I figure it's
    probably better anyway. I've kept the old one around just incase I figure
    out how to reproduce the old issue on a different machine
  - one more modification to core-engine's image element, so that now when a
    request for a differnt url is recieved, but the has been loaded in the
    past, that old data is used again. It's also shared amongst all the
    image elements
  - ...put a lot of bugs into core-engine's image element. Hopefully I've
    worked them out now
  - ...I haven't worked them out. Set things back to the old version. I'll
    need to do another draft of this


2020-02-05
  - modified core-engine's elements further, removing the "should render"
    judgements from the group shape, and placing them in each element (group
    get's its own judgement code to, but now its only for itself)
  - atop this, I've improved the "shouldRenderFrame" code from yesterday, so
    that the value is only set when the changed element is within the viewport.
    Thus changes that are made to elements that are not to be rendered anyway,
    do not trigger the render of a new frame. There's nothing worse than
    someone having say over a place they aren't in.
  - reinstated that newer "loadImageFromURL" in the library, and removed
    core-engine's image element's use of the old one. The new function has
    some more features than the last one did, though doesn't really use any
    of them... it sets the stage for those new features
  - made a small adjustment to the argument list of the
    library.misc.loadFileFromURL2 function (and subsequently, every where else
    that used it)
  - added new dev checkbox option that created a html section filled with data
    about what the system is doing, with the help of a new section added to
    core-console's stat section


2020-02-04
  - added "shouldRenderFrame" to the render section of core's engine. This bool
    is set to 'false' initially, and can be set to 'true' by any element. They
    do so when some aspect of themselves has changed (size, colour, position,
    etc) If it is set to true, when the next render request arrives, then a
    full render takes place, after which the value is set to 'false' again. 
    However, if the value remains at 'false' when the next render request
    arrives; then that render is completely skipped. No image is transferred
    out to core-console.
      The idea here, is that frames are only rendered when there's something
    new to show, otherwise the last rendered frame should do fine.
      The "wavey boxes" test sees an improvement of ~10%, with any
    still-image test improving 100% (basically not rendering at all)

    It might make further sense, to somehow sync the canvas refreshes..maybe

  - added an "autoPrint" method to core-console's stats section, just to make
    getting stats easier
  - added checkbox option to the dev dropdown, to give the option of allowing
    frame skipping (allowed by default)


2020-02-03
  - removed all references to 'static' from core's engine (they'd been
    commented out already anyway)
  - played around with creating a new "getImageFromUrl" function that sits in
    the library instead of being attached to the image element in core. Also
    tried to add mipmapping, but then discovered webGL has its own feature for
    this; "void gl.generateMipmap(target);" Investigation is needed


2020-02-01
  - seems closure can't handle the new custom audio node code..so we're back
    to just the plain unminified code now
  - updated Harbinger's dsds so that the voltage input now controls volume
    instead of rate..it's not super great, but it does work

  after some investigation, I think that the system would benefit from a
  webASM core-engine, as it would remove all garbage collection being
  processed, probably saving time. Also a lot of time seems to be spent doing
  extremity calculations, which could be faster in webASM


2020-01-30
  - more work on the new audioWorklet-based oscillator (I now have a nice
    square wave with adjustable frequency and duty cycle..though I'm having
    issues with the a-rate/k-rate non-instant adjustment thing)


2020-01-29
  - began work on a new audioWorklet-based oscillator


2020-01-28
  - updated the library.audio section to better handle waiting for the loading
    of its sections
  - rewrote the audioWorklets to expand to use the AudioNodes, encapsulating
    things in a really nice way. I've also updated the circuits in the 
    interface layer. Part of the re-write also includes better use of the way
    audioWorklets work, so hopefully this should make existing and future
    worklets operate smoother and with less audio glitching (which I'd noticed
    in the amplitudeModifier on the weekend when it was used with one of the
    units) Things still aren't perfect - for some reason custom 'options' don't
    work like they should - but I've learned some useful things which should
    help alot.


2020-01-27
  - changed Harbinger units' display names to the actual names instead of those
    codes
  - added interface methods to Harbinger's RDP unit
  - replaced the seletor parts in Harbinger's MRD unit with the newer, snazzier
    ones from the RDP
  - made a 'common' folder in Harbinger's image folder location, for images
    that are shared between different units. This should reduce the amount of
    space that the images for these units take up, and reduce the time it takes
    to add them to a scene. CurveTech is already set up a bit like this, so no
    common folder is needed there
  - replaced Harbinger's DSDS signal/voltage buttons with slightly larger ones
    (which are the ones that the other two units use, so they're in the common
    folder)
  - did some of the same moves for Acoustic Research, but only the dial is
    common there
  - put together a document with the codes for all the keys of a keyboard
  - began changing how key capture is done by units, where instead of the 
    unit using the character of the key, it uses the keyCode which represents
    its position on the keyboard, thus allowing more keyboard types to use the
    hotkeys. I've converted as many of the units that I could find that used
    the old method


2020-01-26
  - lots of work on the new bitcrusher unit, seems to be working good now
  - also added the Amplitude Modifier unit


2020-01-25
  - updated the sevenSegmentDisplay to include the characters 'a','b','c','d',
    'e' and 'f', thus allowing it to display hexadecimal
  - added method of setting the 'selectable' value in buttons
  - finished drawing up the Harbinger Rhythm Designer Pro (rdp-32) and have done
    all the circuitry apart from the interface. It needs a little testing, but
    seems good so far


2020-01-24
  - modified the amplitudeModifier to have floor and ceiling cap values
    (defaulted to +/- 10)


2020-01-23
  - redid the audioWorklet folder to be a little easier to manage. Also messed
    with the code of the momentaryAmplitudeMeter to add a way of selecting 
    whether you want it to do its calculations with all the data recieved
    since the last data was procuced, if if you want it to just sample in that
    momemt
  - started work on a signal response analysiser


2020-01-21
  - renamed the display name of the alpha collection's effect units to "Audio
    Effect Units" from "Effect Units"
  - played around with the help files a little more, adding one for Alpha's 
    basic_synthesizer, which works pretty nice, but just lacks excitement for
    me..I liked the idea that the help files would have little windows to
    samples of the units, to allow for an interactive experience, but...maybe
    the PDFs idea is enough?


2020-01-20
  - removed all references to 'static' in core (which as it happened, wasn't
    using this value anyway)
  - fixed an issue with core's image element, would would encounter problems
    when no url was provided on creation
  - renamed 'static' to 'canvasBased' in the interface layer, which is more
    descriptive name anyway
  - dial_continuous_image had it's needle image shape defined in the wrong
    scope, which is not the case anymore
  - modified core-console's genericElementProxy element's getAddress method,
    so that it won't print out the "/root" name at the beginning of an address
  - went through all the tests, and things seem to be working fine. Closure is
    compiling without error.

    - results -
      -> core_engine
        core_engine.js 1246kb
        core_engine.min.js 427kb
        reduced to 34.26% of original size
      -> core
        core.js 1341kb
        core.min.js 379kb
        reduced to 28.27% of original size
      -> system
        system.js 1353kb
        system.min.js 386kb
        reduced to 28.57% of original size
      -> interface
        interface.js 2432kb
        interface.min.js 680kb
        reduced to 27.98% of original size
      -> control
        control.js 2568kb
        control.min.js 735kb
        reduced to 28.62% of original size
      -> curve
        curve.js 3154kb
        curve.min.js 964kb
        reduced to 30.58% of original size

  - seems in core-engine's viewport section, the stopMouseScroll method was
    always setting the overflow to '' (?) have changed that to only when the
    value is being set to false. Could fix an issue I've been having with the
    mouse wheel affecting the position of the site along with the regular
    zooming (at least on macOS, where you get that rubber-site feel thing
    happening)


2020-01-19
  - completed the switch of the mrd-16 image files (just deleting the old ones
    and changing the names of the folders)


2020-01-18
  - updated the artwork for the dsds-8 and mrd-16 (making them both about 1.5
    times bigger)
  - removed the "change output type" hotkey button from the mrd-16 because it's
    too much of a risk to have around and you'll never need it that often or
    quickly
  - added hotkeys to the dsds-8
  - in a bid to remove the need for the heavyComp script to rename all
    instances of 'static' to '_static'; I've refactored core-engine a little
    to remove the uses of the 'static' variable, replacing it with "isStatic"
    (though not the method, which hasn't changed)
    There's still not a lot working elsewhere in the project, which will need
    renaming. The regular version still works fine, but Closure can't deal
    with it


2020-01-17
  - created the amplitudeModifier circuit
  - created the momentaryAmplitudeMeter circuit


2020-01-16
  - adding all kinds of crazy audioWorklets (in a developmental sense)
  - updated the AudioWorkletNode maker so that one can define the options in
    the array, with the name and blob
  - renamed "AudioWorkletProcessor" of library.audio, to "audioWorklet"


2020-01-14
  - updated the unload warning to include refreshing the page
  - added an option to curve's menubar's dev setion to reactivate the unload
    protection (it's off by default while in dev mode)


2020-01-13
  - shifted the audioWorkletProcessor section into the library, rearranging the
    audio subsection as I went. audioWorkletProcessors are now loaded and
    automatically get their own 'context.create' method (eg. bitcrusher ->
    context.createBitcrusher)
  - fixed issue in detectIntersect.lineOnPoly (for situations where a line was
    going from a point on the poly, through it, accross another point on the
    poly then to an outside point)
  - moved the old development units to the trash. Tis a sad day
  - renamed the 'workshop' unit collection to the 'development' unit
    collection
  - changed the key name of the newer 'dsds-8^3_2' to '_dsds-8^3_2' so that it
    doesn't show up in the menubar list
  - added "Reset Viewport" option to the Tools dropdown menu


2020-01-12
  - more drawing


2020-01-11
  - updated the presets of the dsds-8^3, also fixed up some bugs with the unit
  - began redrawing of Harbinger units to make the ~1.5 times bigger


2020-01-10
  - added 'radio' item to the list part, which is sort of like a sublist of
    only checkboxes, where only one can be checked at a time (with a minimum
    of one also)
  - updated curve's manubar to use the new radio item for the mouse wheel mode
    selection
  - rearranged the interface layer a little to include the custom 
    audioWorkletProcessor section. I've only placed the biscrusher in there
    and created a circuit for it which all seems to work fine. It does however
    rather slow down the start-up time of that layer, as a request/promise is
    being made for the creation of the bitcrusher webWorker. More audio
    worklets will be added, but I'm hoping that they can be loaded in
    parallel, reducing their load time weight. It makes more sense to me now
    to add some kind of loading screen
  - ...I've sped things up a little bit by removing the load checks for the
    bitcrusher. We'll see if that holds up.
  - fixed bug with player circuit which allowed one to start the same playhead
    again, thus resulting in many simultaneous audio streams of the same file


2020-01-09
  - created a 'Workshop' collection of units, within which I will develop new
    unit types...I should probably get rid of the development collection units
    instead and just use that name, but..maybe I'm a little sentimental
  - began work on a "bitcrusher" effect unit, which is made using an
   'AudioWorkletProcessor' Pretty cool stuff
  - seems the Alpha collection's synthesizer was starting out with a gain that 
    was different from what the default value of the dial showed. I've changed 
    it so now on creation it sets to what the dial's default is. I'm a little 
    worried the other settings have similar discrepancies.
    ...Also the interface was set up a little wrong.
  - added the import/export code to the dsds-8^3
  - made some modifications to the discrete parts to reduce the number of
    callbacks where nothing changed


2020-01-08
  - added a check to the compatability checker, which checks if 
    "requestAnimationFrame" works in a webworker
  - modified control.mouse's onwheel function to add a way of selecting
    differnt methods of mouse wheel calculation, along with some new options   
    in the 'tools' section of the menubar (done in a way that's a little ugly, 
    frankly) So now, zooming is pretty nice with a clicky wheel mouse
      

2020-01-07
  - the mrd-16 was having issues with the buttons, where if you clicked them a 
    certian way, they would appear to become stuck on "pressed". In reality, 
    when you clicked the button for the first time, the image element would 
    request the 'down' image (as is expected), but if you clicked too quickly, 
    the change to the 'up' image would be processed and completed fast (thanks 
    to the new image caching) but on completion of the 'down' image request, 
    the element would set itself to that image thus giving the appearance that 
    the button was stuck 'down' This has been fixed in the image element, 
    which now on completion of an image request, checks if the currently 
    active URL is the same as the one for the request that it just completed. 
    If so, all's good, but if not it automatically re-requests the currently 
    active URL.
  - updated library.math.detectIntersect to return more point information. 
    lineOnLine returns all points of contact, as does lineOnPoly ...its just 
    better now. There was an issue with detecting polygons that were exactly 
    ontop of each other, but not with the same points, but this is fixed now. 
    lineOnLine was also modified to return two points if the lines are on the 
    same line (thus producing a range of point values between) this is stored 
    as x1,y2,x2 and y2 values
  - added same style of modification that was made to the image element 
    yesterday, to library.audio's loadAudioFile function. Now, all url loaded 
    files are stored in a cache and called upon when that url is used again. 
    There's also a "forceRequest" argument to bypass the cache.
  - updated the generic connectionNode to use the current width/height of the  
    rectangle for calculating the attachment point (as apposed to the initial 
    values)


2020-01-06
  - modified core engine's image element, to reduce the URL request load. Now, 
    its saving the results of previous requests so that any image element that 
    requests from the same URL, will simply be given this data instead. Or, if 
    the request is in motion, the element provides a callback that will be 
    called when the origianl request is complete (there's success and failure 
    callbacks) There's also a way of forcing an update. I've already noticed 
    that changes between images (that are loaded) are much faster
  - modified the core-console genericElementProxy's "setupSimpleAttribute"
    function to allow for methods with extra arguments. Those extra arguments
    are not saved, but this is useful for sending additional, one off data.
      eg. image.url('-url',force=True) 
  - created the 'gain' circuit


2020-01-05
  - added sudo-catagory to curve's menubar creater in the create submenu, so
    that if you use it ("") the unit is added to the bottom of the main list
  - added the '^' symbol to library.font's reducedGlyphSet, and both default
    fonts
  - further work on the drum machine (the harbinger dsds-8^3)


2020-01-04
  - began work on a drum machine
  - updated dial_image_discrete's set function, so that it stops when the new
    value is the same as the old value


2020-01-03
  - fixed an issue with the MRD-16 not having the correct address for its
    images
  - updated core console's generic element simple attribute updater code so
    that it doesn't update values to what's already stored in the cache, as
    there's no need to set things to what they already are
  - changed the MRD-16 chackbox's to buttons (for the signal/voltage selection)
    as there was a little issue with clicking the mode that was already 
    selected and somehow having nothing selected
  - moved drum sounds into a new folder in docs and started putting together
    a collection of sample sounds (I have '78' and '808'. There's a few more
    on the way which I'm getting from Logic Pro X..probably questionable 
    legality, but we'll deal with the C&D when it arrives)


2020-01-02
  - seems a company called Harbinger have opened a shop in town, currently
    they're only selling the MRD-16 (Mini Rhythm Designer) which is a pretty
    nifty sequencer, though I'm told they have a number of other products on
    the way
  - added 'nudge' method to the discrete dials
  - added 'toggle' method to the checkboxes
  - fixed bug with core_engine's group element, where the 
    'calculateExtremitiesBox' function wasn't calculating the limits 
    correctly. Simply, the collection of if statements were not set up 
    correctly (there was if-elseif where there shouldn't have been) Along the 
    way I noticed some unnecessary 'boundingBoxFromPoints' work being done, so 
    that's been removed too
  - removed duplicated font code from the core layer (it was already in the
    library, just never used)
  - guess who hadn't written the if statement that used 
    "detectIntersect.polyOnPoly" correctly in the getTrianglesFromGlyphPath 
    function in the font section of the library, which caused the dots on i 
    and j characters to not show up, and probably other issues I hadn't 
    noticed yet? Not me anyway, that would have been silly


2020-01-01
  - core.render.activeLimitToFrameRate didn't have the cached values 
    implemented. However, that has changed now
  - added a "Limit Frame Rate" option to the Dev menubar panel
  - improved the date strings in the Dev menubar panel, so that they can    
    handle days and months with single digits (automatically adding the 
    leading zeros)
  - fixed issue with detectIntersect.pointOnPoly (same issue as last time in 
    fact, seems when a point is perfectly level with a point of the poly 
    things get confusing...I'd messed up the solution to this by making it 
    judge each point twice, thus flips would occur twice)
  - updated fitPolyIn to use detectIntersect instead of detectOverlap, along 
    with other sections that were still using detectOverlap
  - updated shortestRouteFromVisibilityGraph to return an empty route when one
    can't be found
  - commented out all of detectOverlap (I really should just dump it)
  - made initial attempts to bring in the cable routing code. So far, it works
    but feels messy. The system must calculate the visibilityGraph every time
    for each cable draw
  - ...processing is pretty heavy, so I've disabled cable routing for now
  - fixed issue with audio_file_player unit where if you pressed the 'load 
    file' button, but then canceled out of the file chooser; the unit would be 
    unable to play the previously loaded audio. Seems the load process in the 
    circuitry set the 'is file loaded' flag to false before attempting the 
    file load. I've fixed this by only setting that flag when the file has been
    loaded and is to be processed into the circuitry
  - did some new artwork for a new unit


2019-12-30
  - adding in oncreate and ondelete callbacks to the unit and parts, mainly so
    that intervals can be stopped when parts or units are removed
  - updated the parts and units that use intervals, so that those intervals
    are cleared upon that part or unit's deletion
  - created a small testing script and an error page for when a browser is 
    incompatible with the site in some way, currently it only deals with 
    OffscreenCanvas errors, but can be easily expanded. Page looks pretty nice 
    too


2019-12-28
  CoreV3
    - found edge-case error in the pointInPoly detectIntersection function,
      where the point could be level with a point on the poly. Some extra
      judgement code seems to have fixed things
    - odd issue with the file opener library function not working. Seems to be
      fixed by making it add the 'input' element to the document body, then
      'clicking' it. The element is removed after a second
    - setting things up for the switch over
  - performed the switch over and pushed
  - updated the readme
  - demo loader was asking for permission to change the scene, which doesn't
    make a whole lot of sense considering what the automatic demo loader is
    trying to accomplish


2019-12-26
  CoreV3
    - readded the curveTech units (there's an issue with the image element when
      it's given an image with transparency, which seems to not blend with the
      background at all, instead just with black)
    - fixed it! I'd misconfigured the webGL blend function
    - created a single canvas version of the sevenSegmentDisplay readout. Also
      accidentally removed the other static version, so, this is the static
      version now. It's pretty nice though
    - same, but for the sixteenSegmentDisplay readout
    - unfixed that webGL blend function thing. Seems by adjusting the blend
      function I knocked the blend function for the rest of the system out too,
      so, any shape with full transparency (a:0) and any colour, would still
      render that colour to the screen. Apparently its to do with a bad math
      function happening behind the scenes. Things are fixed by adding glsl
      code to the fragment shader, to perform the alpha calculations;
        outputColor = vec4(colour.rgb*colour.a, colour.a);
      which seems to be holding up well, though I'll need to copy this change
      to all the element's fragment shades (except the texture based ones, of
      course) Hopefully it doesn't have an effect on rendering performance..
      the calculations are so small, I can't see why; though why am I not
      doing the calculations in the vector shader instead of the fragment
      shader? Or in the updateGLAttributes function? Silly brandon
      ...done! Nothing has changed, as expected
    - trying for a heavyComp, some things are consts that shouldn't be (I've
      been a little liberal with the use of consts)

      - results -
        -> core_engine
                core_engine.js 1405kb
                core_engine.min.js 509kb
                reduced to 36.26% of original size
        -> core
                core.js 1329kb
                core.min.js 357kb
                reduced to 26.94% of original size
        -> system
                system.js 1340kb
                system.min.js 365kb
                reduced to 27.25% of original size
        -> interface
                interface.js 2360kb
                interface.min.js 644kb
                reduced to 27.30% of original size
        -> control
                control.js 2494kb
                control.min.js 697kb
                reduced to 27.97% of original size
        -> curve
                curve.js 3852kb
                curve.min.js 1237kb
                reduced to 32.13% of original size
      

2019-12-25
  CoreV3
    - christmas update. Things are now 27% more cheerful (though much slower)
    - fixed that checkbox issue from yesterday
    - there's something amiss with loading files on chrome that isn't an issue
      on chromium


2019-12-24
  CoreV3
    - rewrote the arrangement section of core's console, to be a lot more like
      the engine and use a group shape for the root, instead of some custom code
      that looked a lot like the group code and did essentially the same thing
    - turns out .splice doesn't work how I thought it did. Splicing from position
      -1, selects the last item in the array. Important note; use
      'library.misc.removeThisFromThatArray' in future, which is now prepared
      for this situation
    - readded most of the development units (I should probably just remove them)
      and the Alpha collection. Things have been pretty smooth, though I'm a
      little iffy about the static readouts, as they flicker a little. Also the
      checkboxes don't stop the mouse actions like they should
    - ...those readout need looking into. The decimal places looks a bit
      terrible. This probably calls for a rewrite of the part to not use
      individual segment displays


2019-12-22
  CoreV3
    - control layer seems to be all in now (except the gui) some cleaning needed
    - gui almost in, just some niggly bits to take care of
    - niggly bits handled, things seem pretty nice now, and all the old tests
      are working fine..this could call for a next layer
    - made a start on layer 5; unfortunately it's not the easy plop-in-place
      that I had hoped for, but with a little rejiggering things should work
      fine
    - fixed some edge cases with the detectIntersection functions
    - added the path finding code ('shortestRouteFromVisibilityGraph') that
      uses the visibilityGraphs, so now there's a way of finding the shortest
      path!


2019-12-19
  CoreV3
    - fixing up some things and moving some code to where I think it fits best.
      Looks like we're ready for the next layer
    - "pathExtrapolation" needs to be made faster. I'm convinced that it was
      much faster before I decided to add that external library for boolean
      opperations. Perhaps a hybred approach
    - made a start on the control layer (this one is quite interconnected, so
      it's a little messy right now)


2019-12-18
  CoreV3
    - rewrote the group. I'm nervous about it, but all the tests are working
      fine..


2019-12-17
  CoreV3
    - further testing to the 'polygonsToVisibilityGraph' and
      'detectIntersection' sections. It seems pretty solid now
    - back on the rewrite of the element proxies; re-drafting to a nicer and
      more private/public focused mode. The rectangle description is now
      remarkably short; 29 lines, with 16 of those being comments (13 lines)
    - rewrite going pretty well, I've finished everything but the group.. It's
      fine, but its a little weird looking.


2019-12-16
  CoreV3
    - finishing off the 'polygonsToVisibilityGraph' function, fixing up 
      'detectIntersection' code along the way
    - added in a few efficiencies to the 'detectIntersection' code (mainly
      around boundingBox computations and trying to be clever with logic) and in
      the 'polygonsToVisibilityGraph' (adding code so that it isn’t attempting
      to scan routes twice) A little tentative as I was rushing a little near
      the end, but it seems to have sped things up a lot


2019-12-15
  CoreV3
    - still on that pathfinding library function thing, but have now improved
      the 'detect overlap' code a lot (into a new section called
      "detectIntersection") and have code that can generate the visibility graph
      for a series of polys


2019-12-14
  CoreV3
    - started work on a new pathfinding library function


2019-12-13
  CoreV3
    - finished the rewrite on the way logging is done on the library layer
    - started a rewrite on the element proxies, using inheritance; which is
      going really quite well


2019-12-12
  CoreV3
    - more unit section tests..things are a little slow for my liking. I may
      have to look into ways of reducing the number of messages travelling to
      core, and ways of reducing the workload when they get there (I'm mainly
      thinking about parts like the gauge and meters, which used to use a method
      to stop the sub parts from running extremity calculations; but really,
      both those could just be re-written with canvases, which would solve
      everything just as well)
    - did a rewrite on the way logging is done on the library layer
    - started a rewrite on the way logging is done on the library layer


2019-12-11
  CoreV3
    - added in the last of the connection nodes
    - started work on the unit section (added the unit builder, validator and
      a test)


2019-12-08
  CoreV3
    - moved all of it into the engine (pretty happy with it too)
    - dynamic cables are in (which new a new version select argument)


2019-12-07
  CoreV3
    - made some adjustments to the system level's mouse interaction handlers, so
      now they store the old functions every time (which I'd removed last time.
      so I'm probably going to be fixing that again) and so that the onmove and 
      onend callbacks provide the workspace x and y points along with the event
      object
        - later -
    - yeap, fixed up the system layer's function holder thing, so now it's like
      before. The code now waits until the core layer is ready before looking
      for the functions
    - redid the .go() methods, so that one can now have multiple functions
      attached to it
    - sequencers part is in
    - the new mouse event callback handle was broken, so I fixed that (I'm
      probably going to move all of it into the engine, but it works for now)
    

2019-12-06
  CoreV3
    - skipped over the list_image part, because lets be honest; its never used
    - needleOverlay and grapher_waveWorkspace parts are in, though the
      needleOverlay is having some issues with certian interactions
    - fixed the system.mouse code slightly, so that the mouseInteractionHandler
      function save the old listeners correctly


2019-12-04
  CoreV3
    - after some jiggering, I think the list part is ready to go
    
    note: it always surprises me, how fast the system is when you add the
          -removeDev flag to the compiler


2019-12-03
  CoreV3
    - added "onFontUpdateCallback" callback to characterString proxy shape,
      which is called when the engine's element has successfully loaded a new
      font. Attaching a callback to this uses exactly the same method as
      attaching a mouse or keyboard callback, though behind the scenes it is
      dealt with differently (feels a little messy, though the front api is
      pretty nice)
    - improved core's callback operation even more, by adding a way of selecting
      what mode of element activation occurs: "topMostOnly", "firstMatch" or
      "allMatches". The first indicates that the callback should only be
      attempted for the element directly under the mouse. The second indicates
      that, for all the elements that touch the mouse point; only the topmost
      element with a relivant callback should be activated. The third just
      attempts the callback for all the elements who touch the mouse point
    - its a little shakey, but the list part is working now


2019-12-02
  CoreV3
    - added ".resultingWidth" to characterString proxy shape, which simply
      returns a cached value. That cached value is automatically updated by the
      engine's element when it completes its calculations for this value


2019-12-01
  CoreV3
    - got together the checkboxes, the checkboxgrid, the dials and the slides
    - also the rangeslides
    - switched-up how callbacks work, so now elements behind other elements,
      that have a mouse or keyboard interaction, are called. Before; if the
      element wasn't at the surface it wouldn't be called. This means I need to
      go over the already created control parts a bit; bit it does make things
      more like they were in the past, which is great because the list part is
      next and that relies on non-surface element callbacks being called pretty
      heavily. And the list part in a behemoth so, I want to change that as
      little as possible


2019-11-30
  CoreV3
    - after a couple days of work, I've kinda gotten the group element to work
      again. There were all sorts of issues with it, regarding elements being
      added to it at bad times, but hopefully I've worked that stuff out. It's
      a little messy so, I'm just hoping it holds. I also fixed up the
      characterString element as that was having issues too, ended up rewriting
      it and things are pretty smooth now.
    - got the rest of the graphers in and all the buttons


2019-11-27
  CoreV3
    - finished up on the proxy elements.. I'm still a little shaky about it, but
      things seem good so far
    - redid all the core tests for these new proxy elements
    - redid the system layer and its tests
    - began work on redoing the interface layer (little needs to be changed,
      thankfully. Infact, it's going to be a lot like the old system anyway)
    - put all the basic interface parts in
    - glowbox parts are in
    - added segment display and readout parts
    - added gauge parts
    - had a big issue with rapid group addition/removal/clearing, which seems
      to have been solved. The "__idRecieved" callback that the
      append/prepend/remove methods set up when the incoming element doesn't
      have an id, wasn't checking that the element was still to be added when
      the callback was finally run. In the error's case; the element was being
      created, added and removed before the element was given it's id; thus when
      the id arrived the callback was addition was still being performed
    - encountered another issue with the image element and timing.. it was
      checking the image.bitmap value to see if anything was there, and if not
      loading the default image. Of course, if a url had been provided and the
      data was being collected and extracted, the bitmap value would still be
      empty when the timer went off, so the url would be overwritten with the
      one for the default image. Thus it would look like the correct image was
      set, then suddenly switch to the default image. Now, the timer checks the
      url value instead, which is a little more sensible.
    - anyway, first grapher is in


2019-11-26
  CoreV3
    - started a new version of the element proxies, to remove all Promises and
      such asynchronous interaction. These new proxies handle all that work
      themselves allowing the user to work with the elements as was done in the
      past


2019-11-25
  CoreV3
    - changed some things in core's proxy objects so that the cached values are
      returned immediately when requested, instead of being passed through a
      resolved promise
    - added the level and gauges display parts


2019-11-24
  CoreV3
    - removed that extra code and just made a clone of the image element with
      the name changed to 'canvas'
    - added the sevenSegmentDisplay and sevenSegmentDisplay_static display parts
      as a single part where one can choose whether you want the static version
      or not with an argument
    - same as above, but for the sixteenSegmentDisplay
    - created all the readout parts for all types. Same idea with the argument
      to choose whether its static or not 


2019-11-23
  CoreV3
    - added all the basic interface, glowbox parts and the sevenSegmentDisplay
    - added the canvas element as a proxy object to the core layer (which uses
      the image element behind the scenes, which means there's a little extra
      code in the 'element' section of the console to handle this odd
      situation.. I might look into that. Maybe creating a 'canvas' element in
      the engine that is just a copy of the image element, but has a different
      name)


2019-11-22
  CoreV3
    - redid the core interface to use proxy elements
    - updated proxy elements to have caching (they all come with an argument to
      not use the caching) ..probably not the most useful feature, and I've
      written it in a way that it doesn't affect the interaction in any way
    - put back together the system layer, which seems to be working fine (not
      much change needed from the time before this switch to proxy elements)
    - started again on the interface layer. All the old circuit work has just
      been copied, and I've gotten together all the 'basic' parts (which of
      course is a rather simple task now thanks to the proxy elements)

  - for some reason, the queryString code was still using reference to a canvas
    with a particular name, instead of the generic "_canvas_" object, which was
    causing URL requested demos to not load (infact, they crashed the whole app)
    Tis all fix now, my liege


2019-11-18
  CoreV3
    - added a new layer to the layer stack (though I'm not giving it its own
      folder as its really just a sub-layer of the library) "_canvas_.layers"
      which is used to register new layers as they are loaded and has methods
      for discovering what their version information and a callback for when a
      new layer is loaded and ready


2019-11-17
  CoreV3
    - shifted the font code out from core into the library (where it seems more
      natural)
    - did up the library (again) to have the cool new logging
    
    unionPolygons is frightfully slow and is slowing the path element down
    tremendously 

    - added in the ability to add new elements while the system is running, by
      using the serialize/deserialize code found in the library... it actually
      runs surprisingly well
    - added the system layer (needs a little testing, but seems really good)
    - added a ".go" function to the system layer, which acts like the ".go"
      function of core; but activates only when the system layer is done all
      it's work (I just think this is so clever)


2019-11-16
  - oops; accidentally deleted the library tests somewhere along the way.. I
    think I actually just moved them into the workshop instead of copying them
    there, so an easy fix to put them back

  CoreV3
    - added the image element in
    I can't add the canvas element like before, as you can't have a regular
    canvas in a webWorker, only a webGl canvas. So, instead of implementing that,
    I've expanded the image element so one can transfer in a canvas from the
    main thread. Hopefully this will suffice.
      Obviously this means that there's a lot more control given over to the
    user, and no more 'resolution' controls. One must also be careful of
    selecting the correct size of canvas to transfer into the image element


2019-11-15
  CoreV3
    - added more shapes (only canvas and image left) though messed up the
      unifiedAttribute method along the way for all of them (in a bid to make
      things shorter, I totally forgot why they were long in the first place)
    - rewrote (in a hurry) 'characterString', so that it new uses the group
      element secretly inside itself, instead of being basically a
      reimplementation of the group element 

2019-11-14
  CoreV3
    - adjust the callback module, so that onmouseenterelement and
      onmouseleaveelement act more for what is visible on screen, over what is
      actually there. For example, now when two elements overlap, and the mouse
      moves from over one of the elements to a location where the two overlap;
      the system only considers the top-most element. It's as if the lower
      element has had the upper shape cut away. In the past these elememts
      would have been considered serperatly. (this should actually fix bug
      [2019-08-03:1])


2019-11-12
  CoreV3
    - began on draft 15, which is constructed more like how the actual system is
      There's also a more advanced comp.sh and heavyComp.sh scripts that have a 
      switch for removing all the development logging lines
    - added the meta method "createSetAppend" which can be used to create an
      element, set its attributes and append it to a group all in one message


2019-11-11
  CoreV3
    - began on draft 14, which uses a better designed API for Core


2019-11-10
  CoreV3
    - communicationModuleMaker has a new function type that gives the attached
      function a callback to call when it's ready to respond (as opposed to the
      regular way, where the returned value of the function is just sent back)
    - calling render.refresh returns a promise that only resolves when the 
      refresh process is complete
      
    A lot of the big differences between this system and the old one are to do
    with timing. Things aren't sequential anymore, so you have to be careful
    about asking for something to get done then waiting for it to be finished

    - working on adding callback functionality to the elements (in some ways
      removing the need for the "System" layer by having core run the callbacks
      for those elements itself, and giving the option of whether to call all
      the elements callbacks or just the frontmost one) Also, going to change
      the behaviour of the global callbacks to return all elements under the
      mouse point, instead of those with a similar callback
    - added new callbacks "onmouseenterelement" and "onmouseleaveelement",
      which will only return relevant elements


2019-11-09
  CoreV3
    - updated the rendering section to allow for high-density-pixel screens.
      Also added in the code for selecting the canvas' size (which is a little
      messy, honestly. But it doesn't move much, I guess)
      ...this new system of having to callback and forth between the processes
      is causing issues. I'm working them out, but hardly in the most beautiful
      ways. The 'render' section has become a bit of a mess with regards to
      setting the canvases up correctly, and can make a number of different 
      requests to the main thread for information, which take time and require
      the viewport re recalculate itself to discover the viewable extremities
      correctly...I've upt together a sort of 'this-section-is-busy' value
      within 'render' which the main system checks lots of times on startup to
      determine when the system is actually ready to be used (which in turn
      triggers a callback to the main thread called 'ready') I need to clean
      all this up... I guess like always, I'll just get it working for now,
      then come back to it some day in the future, when something eventually
      breaks and I'm become annoyed at now-me for not doing things the proper
      way like future-me thinks its obvious. Good luck future-me!
    - made a little space for core3 demo's (over in /docs/core3/) Just a cool
      little spot for putting pretty things


2019-11-08
  CoreV3
    all the main sections are in, with a little more work left on callbacks for
    individual elements (which is what shapes are called now). There's a new
    wavy boxes demo, with changing colours, which is rather beautiful. 
    - I also need to look into the run-time importing of new elements, as the
      main thread doesn't have access to Core's internals anymore. I think I
      could use the serializer from the library and just import them..
    - I tell you what though; I've had to turn off the framerate limiter, as it
      looks soooo smooth running at full speed (60fps) over what I thought
      would be enough (40fps). Like you can really see the jagged nature at 
      40fps, while 60fps is silky smooth. Again, like falling in love.
    - boatload messages are epansions on the standard commands; expect you can
      bundle together many similar commands together. They exist soley in the
      interface, so are nicely seperated from the main core code. (should
      perhaps make it a seperate section of the interface)
    - three spinning boxes demo is in and working (3.js)
    - ...there can be subtle changes in this new version that causes things to
      break; for example the .static value has become a method. This of course
      means that ".static" always evaluates as true
    - added that 'viewport adjustment' demo (4.js)

    ideas
    - a boatload method for making elements, that also sets attributes and adds
      it to a group (I've got a feeling that reducing the number of messages
      between the threads is a great idea)


2019-11-06
  - for the past few days I've been working on a new version of Core. This one
    uses a webWorker to offload the render process to a different thread; thus
    removing the resource contention issue we've been experiencing up until now.
    I haven't spoken must about (or probably at all) in these notes, but you can
    notice speed issues when loading realitivly complex scenes relatively, which
    usually appear as musical timing being off. Hopefully this new system will
    greatly improve this.
    I can't find any notes on FPS testing, but currently I have 5000 squares 
    being rendered at about 45fps on the work computer.
    Other speed notes: I've developed a rather advanced method of logging events
    for development purposes, with each section having is own logging colours
    and prefix and all sorts of cool stuff. Unfortunately, this does cost alot
    of time even when the logging is set to "false". So, I've developed the
    postfix "//#developmentLogger" which goes after every logging line. The
    heavyComp.sh has a new line that will remove every line that includes this
    tag. The improvement in speed is noticable, and I think it's alright to
    have logging removed like this for what is the "production" version


2019-11-02
  - updated gravity so that it needs less input arguments (updated comp.sh and
    heavyComp.sh accordingly, simplifying them along the way)


2019-10-26
  - changed the names of some things
  - fixed a issue with one of the core shapes (I'd put the version number thing
    in the wrong part of the glsl code)


2019-10-23
  - switched to webgl2 (nothing really changes, though the glsl needs a little
    rewording as the syntax has changed a little, but oy have to sort of opt-in
    to the new terms, so it can be done gradually) I've reworded;
    - rectangle
    - rectangleWithOutline
    - polygon
    - polygonWithOutline
    - path
    - image
    - circleWithOutline
    - circle
    - character
    - canvas


2019-10-22
  - fixed up the "heavy load" library function tests, after I discovered that
    the data generators weren't running properly. Things are quite different

                                      library.math.averageArray: 100000 cycles took 3.615 seconds    - average cycle time:0.000036150000000000005 seconds
                                      library.math.averagePoint: 10000 cycles took 0.829 seconds     - average cycle time:0.0000829 seconds
                                                                 (projected time to perform 100000 cycles: 8.29 seconds)
                             library.math.boundingBoxFromPoints: 100000 cycles took 6.209 seconds    - average cycle time:0.00006209 seconds
                              library.math.cartesianAngleAdjust: 100000 cycles took 0.018 seconds    - average cycle time:1.8e-7 seconds
                            library.math.convertColour.obj2rgba: 100000 cycles took 0.211 seconds    - average cycle time:0.00000211 seconds
                            library.math.convertColour.rgba2obj: 100000 cycles took 0.854 seconds    - average cycle time:0.00000854 seconds
                             library.math.curveGenerator.linear: 100000 cycles took 0.09 seconds     - average cycle time:9e-7 seconds
                                library.math.curveGenerator.sin: 100000 cycles took 0.199 seconds    - average cycle time:0.00000199 seconds
                                library.math.curveGenerator.cos: 100000 cycles took 0.107 seconds    - average cycle time:0.00000107 seconds
                                  library.math.curveGenerator.s: 100000 cycles took 0.56 seconds     - average cycle time:0.000005600000000000001 seconds
                        library.math.curveGenerator.exponential: 100000 cycles took 0.445 seconds    - average cycle time:0.00000445 seconds
                                 library.math.curvePoint.linear: 100000 cycles took 0.012 seconds    - average cycle time:1.2e-7 seconds
                                    library.math.curvePoint.sin: 100000 cycles took 0.014 seconds    - average cycle time:1.4e-7 seconds
                                    library.math.curvePoint.cos: 100000 cycles took 0.014 seconds    - average cycle time:1.4e-7 seconds
                                      library.math.curvePoint.s: 100000 cycles took 0.14 seconds     - average cycle time:0.0000014000000000000001 seconds
                            library.math.curvePoint.exponential: 100000 cycles took 0.061 seconds    - average cycle time:6.1e-7 seconds
                       library.math.detectOverlap.boundingBoxes: 100000 cycles took 0.042 seconds    - average cycle time:4.2e-7 seconds
              library.math.detectOverlap.pointWithinBoundingBox: 100000 cycles took 0.069 seconds    - average cycle time:6.900000000000001e-7 seconds
                     library.math.detectOverlap.pointWithinPoly: 100000 cycles took 1.43 seconds     - average cycle time:0.000014299999999999999 seconds
                        library.math.detectOverlap.lineSegments: 100000 cycles took 0.039 seconds    - average cycle time:3.9e-7 seconds
                 library.math.detectOverlap.overlappingPolygons: 20 cycles took 1.052 seconds        - average cycle time:0.0526 seconds
                                                                 (projected time to perform 100000 cycles: 5260 seconds)
      library.math.detectOverlap.overlappingPolygonWithPolygons: 10 cycles took 1.353 seconds        - average cycle time:0.1353 seconds
                                                                 (projected time to perform 100000 cycles: 13530 seconds)
         library.math.detectOverlap.overlappingLineWithPolygons: 10 cycles took 2.404 seconds        - average cycle time:0.2404 seconds
                                                                 (projected time to perform 100000 cycles: 24040 seconds)
                               library.math.getAngleOfTwoPoints: 100000 cycles took 0.045 seconds    - average cycle time:4.5e-7 seconds
                             library.math.getDifferenceOfArrays: 500 cycles took 1.06 seconds        - average cycle time:0.00212 seconds
                                                                 (projected time to perform 100000 cycles: 212 seconds)
                                library.math.getIndexOfSequence: 100000 cycles took 6.6 seconds      - average cycle time:0.00006599999999999999 seconds
                                 library.math.largestValueFound: 100000 cycles took 4.99 seconds     - average cycle time:0.0000499 seconds
                             library.math.normalizeStretchArray: 100000 cycles took 8.021 seconds    - average cycle time:0.00008021 seconds
                                  library.math.relativeDistance: 100000 cycles took 0.016 seconds    - average cycle time:1.6e-7 seconds
                  library.math.removeTheseElementsFromThatArray: 100000 cycles took 7.205 seconds    - average cycle time:0.00007205 seconds
                                      library.math.seconds2time: 100000 cycles took 0.011 seconds    - average cycle time:1.0999999999999999e-7 seconds
                                   library.math.cartesian2polar: 100000 cycles took 0.015 seconds    - average cycle time:1.5e-7 seconds
                                   library.math.polar2cartesian: 100000 cycles took 0.034 seconds    - average cycle time:3.4000000000000003e-7 seconds
                                      library.math.blendColours: 100000 cycles took 0.061 seconds    - average cycle time:6.1e-7 seconds
                                 library.math.multiBlendColours: 100000 cycles took 10.866 seconds   - average cycle time:0.00010865999999999999 seconds
                                 library.math.pathExtrapolation: 2 cycles took 2.04 seconds          - average cycle time:1.02 seconds
                                                                 (projected time to perform 100000 cycles: 102000 seconds)
                                         library.math.fitPolyIn: 1 cycles took 1.206 seconds         - average cycle time:1.206 seconds
                                                                 (projected time to perform 100000 cycles: 120600 seconds)

  notes
  - I discovered this issue while playing around with webWorkers. I've since set
    up a workshop test area (webWorkers/2) with a copy of the library (minus the
    audio bit) to see what improvements could be made. I had the idea of
    creating multiple instances of the library-worker to perform parallel
    processing. So far it works. I can perform 25 loops of
    library.math.pathExtrapolation in ~7.506seconds or ~3.662seconds when using
    the parallel method. It's certainly something to research. It is asynchronous
    however, so, that complicates things.
    By limiting the webWorker count to 10; I can do 100 cycles in ~11.7seconds
    (cycles could reuse workers) With 100 workers it took ~20seconds, so,
    there's certainly some sweet spot. 5 => ~10.2 seconds. 2 => ~18.5 seconds


2019-10-20
  - expanded the connection node logic a little to be aware of node direction,
    this fixes the bug of cables vanishing when two connection nodes of the same
    type were being connected (bug:[2019-10-19:1])
  - data_combiner was internally named voltage_combiner for some reason.. tis
    fixed now
  - added a new demo


2019-10-19
  - added proximityThreshold argument to connectionNode
  - changed connectionNode's '_addCable' method to check to see if the node is
    active, and if so to activate the cable (there's a new internal value that
    keeps track of whether the node is active or not)
  - the Esc key grows more powerful (now it runs "system.keyboard.releaseAll")
  - modified system.mouse and system.mouse.mouseInteractionHandler to change
    the way callback code was being saved and restored. This fixes issues that
    would arise when mousedown/mouseup events weren't being executed correctly
  - added 1 millisecond delay to all curveTech's logic units
  - added a new links in the help menubar dropdown, which show the idea list
    and bug tracker


2019-10-18
  - updated the connection node to use proximity snapping in mouse connecting
    (it's soooo much smoother)
  - added link to the ideas page in the menubar (under help)


2019-10-17
  - added a callback for 'onremove' to the group shape in core. It's called when
    a shape is being removed from the group
  - added a callback for 'onadd' to the group shape in core. It's called when a
    shape is being added to the group. There's a boolean argument to indicate 
    that the shape is being added to the front of the group or not (true for
    prepend, false for append)
    (core test 15 checks this functionality)


2019-10-15
  - added the single_bit_memory unit to curveTech
  - added the multiplexer units to curveTech (1-2, 1-4, 1-8)
  - added the demultiplexer units to curveTech (2-1, 4-1, 8-1)

  compilation results
    -> core
            core.js 1585kb
            core.min.js 417kb
            reduced to 26.34% of original size
    -> coreSystem
            coreSystem.js 1596kb
            coreSystem.min.js 422kb
            reduced to 26.44% of original size
    -> workspace
            workspace.js 2832kb
            workspace.min.js 746kb
            reduced to 26.35% of original size
    -> curve
            curve.js 4319kb
            curve.min.js 1304kb
            reduced to 30.20% of original size


2019-10-13
  - updated all the curveTech units to have the new artwork
  - added the REP and DUP logic gates to curveTech
  - added the adder to curveTech


2019-10-12
  - made the new menubar (with the new list part) the default menubar, and
    removed the old one
  - fixed list2's checkbox item to update the tick shape's colour correctly on
    creation
  - removed list part, and renamed 'list2' to 'list'
  - modified list part to allow one to set the item width of a sublist
  - redrew all the curveTech artwork


2019-10-11
  - still on the new list part
  - added a new callback to the button part (all of them) "onpressrelease" which
    only activates when the press and release were on the same shape (based on
    'click')
  - added hoverable option code to the basic button part (because apparently it
    wasn't in there)
  - redid the control/menubar to use the new list part


2019-10-09
  - rewrote the list part (needs a little work still, to fill out all the
    functionality)
  - expanded the button part to have styling options for the text (for when the
    button changes state) You can still use text_colour, and the system will
    default to that value if a more specific argument is not found


2019-10-07
  - curveTech's "Multi Option Signal Sender Type B"'s right connection node was
    the wrong way around
    

2019-10-06
  - added multi_option_signal_sender_2, multi_option_signal_sender_4 and
    multi_option_signal_sender_8 (called types A, B and C respectively)
  - added light_panel_2, light_panel_4 and light_panel_8 (called types A, B and
    C respectively)
  - apparently the audio_file_player unit was broken and I just never noticed
    (the multiPlay/singlePlay button was broken. It interacted with the player
    circuit incorrectly. It's all working now)
  - added the 'Logic Gates': NOT, AND, OR, XOR, NAND, NOR and XNOR


2019-10-05
  - drew up 10 new units for the new collection "curveTech" (15+ still to draw)
  - added button_panel_1, button_panel_2, button_panel_4 and button_panel_8
    (called types A, B, C and D respectively)


2019-10-04
  - wrote up performance test for the functions in library.math
  - some of the functions in library.math use "this" objects that don't seem to
    refer to the correct thing. I've changed them to be more explicit
  - added argument to library.misc.padString, so you can select what side to pad
    on. Default is the left

  what the performance output looks like (on the desktop):
                                    library.math.averageArray: 100000 cycles took 0.335 seconds    - average cycle time:0.00000335 seconds
                                    library.math.averagePoint: 100000 cycles took 0.843 seconds    - average cycle time:0.000008429999999999999 seconds
                           library.math.boundingBoxFromPoints: 100000 cycles took 0.402 seconds    - average cycle time:0.0000040200000000000005 seconds
                            library.math.cartesianAngleAdjust: 100000 cycles took 0.01 seconds     - average cycle time:1e-7 seconds
                          library.math.convertColour.obj2rgba: 100000 cycles took 0.087 seconds    - average cycle time:8.699999999999999e-7 seconds
                          library.math.convertColour.rgba2obj: 100000 cycles took 0.241 seconds    - average cycle time:0.00000241 seconds
                           library.math.curveGenerator.linear: 100000 cycles took 0.035 seconds    - average cycle time:3.5000000000000004e-7 seconds
                              library.math.curveGenerator.sin: 100000 cycles took 0.08 seconds     - average cycle time:8e-7 seconds
                              library.math.curveGenerator.cos: 100000 cycles took 0.081 seconds    - average cycle time:8.1e-7 seconds
                                library.math.curveGenerator.s: 100000 cycles took 0.32 seconds     - average cycle time:0.0000032 seconds
                      library.math.curveGenerator.exponential: 100000 cycles took 0.215 seconds    - average cycle time:0.00000215 seconds
                               library.math.curvePoint.linear: 100000 cycles took 0.008 seconds    - average cycle time:8e-8 seconds
                                  library.math.curvePoint.sin: 100000 cycles took 0.009 seconds    - average cycle time:9e-8 seconds
                                  library.math.curvePoint.cos: 100000 cycles took 0.008 seconds    - average cycle time:8e-8 seconds
                                    library.math.curvePoint.s: 100000 cycles took 0.037 seconds    - average cycle time:3.7e-7 seconds
                          library.math.curvePoint.exponential: 100000 cycles took 0.028 seconds    - average cycle time:2.8e-7 seconds
                     library.math.detectOverlap.boundingBoxes: 100000 cycles took 0.012 seconds    - average cycle time:1.2e-7 seconds
            library.math.detectOverlap.pointWithinBoundingBox: 100000 cycles took 0.011 seconds    - average cycle time:1.0999999999999999e-7 seconds
                   library.math.detectOverlap.pointWithinPoly: 100000 cycles took 0.498 seconds    - average cycle time:0.00000498 seconds
                      library.math.detectOverlap.lineSegments: 100000 cycles took 0.013 seconds    - average cycle time:1.3e-7 seconds
               library.math.detectOverlap.overlappingPolygons: 100000 cycles took 0.207 seconds    - average cycle time:0.00000207 seconds
    library.math.detectOverlap.overlappingPolygonWithPolygons: 100000 cycles took 1.323 seconds    - average cycle time:0.000013229999999999999 seconds
       library.math.detectOverlap.overlappingLineWithPolygons: 100000 cycles took 1.03 seconds     - average cycle time:0.0000103 seconds
                             library.math.getAngleOfTwoPoints: 100000 cycles took 0.009 seconds    - average cycle time:9e-8 seconds
                           library.math.getDifferenceOfArrays: 500 cycles took 0.708 seconds       - average cycle time:0.001416 seconds
                                                               (projected time to perform 100000 cycles: 141.6 seconds)
                              library.math.getIndexOfSequence: 100000 cycles took 1.11 seconds     - average cycle time:0.0000111 seconds
                               library.math.largestValueFound: 100000 cycles took 0.343 seconds    - average cycle time:0.00000343 seconds
                           library.math.normalizeStretchArray: 100000 cycles took 3.678 seconds    - average cycle time:0.00003678 seconds
                                library.math.relativeDistance: 100000 cycles took 0.008 seconds    - average cycle time:8e-8 seconds
                library.math.removeTheseElementsFromThatArray: 100000 cycles took 1.11 seconds     - average cycle time:0.0000111 seconds
                                    library.math.seconds2time: 100000 cycles took 0.006 seconds    - average cycle time:6e-8 seconds
                                 library.math.cartesian2polar: 100000 cycles took 0.009 seconds    - average cycle time:9e-8 seconds
                                 library.math.polar2cartesian: 100000 cycles took 0.008 seconds    - average cycle time:8e-8 seconds
                                    library.math.blendColours: 100000 cycles took 0.012 seconds    - average cycle time:1.2e-7 seconds
                               library.math.multiBlendColours: 100000 cycles took 0.204 seconds    - average cycle time:0.00000204 seconds
                               library.math.pathExtrapolation: 100 cycles took 0.88 seconds        - average cycle time:0.0088 seconds
                                                               (projected time to perform 100000 cycles: 880 seconds)
                                       library.math.fitPolyIn: 1000 cycles took 1.238 seconds      - average cycle time:0.001238 seconds
                                                               (projected time to perform 100000 cycles: 123.8 seconds)


2019-10-03
  - found a new method for calculating library.math.cartesianAngleAdjust. It's
    much shorter and a little faster
  - simplified the logic for library.math.detectOverlap.boundingBoxes


2019-10-02
  - added a way of counting what library functions are being used, and printing
    those results: library._control.logflow.active, .printResults and .log
  - tryed to speed up library.math.cartesianAngleAdjust by handling common
    arguments with less code


2019-09-29
  - added another attribute to the menubar settings for dark mode (to account
    for the new 'text' item)(I should probably redo that little section so that
    there's more control over the menubar style, and cleaner control too)
  - changed the name of the 'alpha' collection to 'development' and 'beta' to 
    'alpha'. Also added meta data and rejiggered the menubar maker in the curve
    layer to allow for a definable collection order. Also, there's a second
    list that is only appended when devMode is active
  - added a darkmode™ parameter to the url reader thing (...?darkmode)
  - broke the eightStepSequencer somewhere along the way, all good now


2019-09-28
  notes
  - created a windows 10 vm, and things seemed to be fine..hmm...

  - updated control.selection.selectEverything to have a "shiftToFront" argument
    and to select all units in a better, more robust way
  - added an new step to control.scene.load to select all the newly imported
    units and shift them to the front
  - fixed bug: [2019-09-26:1] "ending a note too quickly on the basicSynthesizer
               results in a snap sound"
    changed library.audio.changeAudioParam's "cancelScheduledValues" call from
        audioParam.cancelScheduledValues(context.currentTime);
    to
        audioParam.cancelScheduledValues(0);
    which seems to have fixed whatever collision was occurring

    this seems to have also fixed [2019-08-25:1] "synthesizer circuit:
    Regarding the wobble features, seems you can set them too high and
    collisions can occur"
  - rewrote the ruler to be a little more beautiful
  - rewrote the musical_keyboard to be a little more beautiful
  - rewrote the signal_switch to be a little more beautiful
  - rewrote the voltage_dial to be a little more beautiful
  - rewrote the signal_duplicator to be a little more beautiful
  - rewrote the voltage_duplicator to be a little more beautiful
  - rewrote the data_duplicator to be a little more beautiful
  - rewrote the audio_duplicator to be a little more beautiful
  - rewrote the signal_combiner to be a little more beautiful
  - rewrote the voltage_combiner to be a little more beautiful
  - rewrote the data_combiner to be a little more beautiful
  - rewrote the LED_board to be a little more beautiful
  - rewrote the voltmeter to be a little more beautiful
  - rewrote the data_readout to be a little more beautiful
  - rewrote the audio_scope to be a little more beautiful
  - rewrote the audio_in to be a little more beautiful
  - rewrote the distortion  to be a little more beautiful
  - rewrote the filter to be a little more beautiful
  - rewrote the reverb to be a little more beautiful
  - rewrote the eightTrackMixer to be a little more beautiful
  - rewrote the audio_recorder to be a little more beautiful
  - removed "drawingUnit" along the way


2019-09-27
  - added code to system.keyboard within the callback function for 
    core:onkeydown, so that if the Escape key is pressed; 
    system.mouse.setUpCallbacks is run again. 'system.mouse.setUpCallbacks' now
    contains all the code used to set up system, mouse interaction
  - rewrote the basic_synthesizer to be a little more beautiful
  - rewrote the amplifier to be a little more beautiful


2019-09-26
  - rewrote the eightStepSequencer to be a little more beautiful
  - rewrote the audio_file_player to be a little more beautiful


2019-09-25
  - updated the audio_file_player's import/export functions to include the
    settings for everything
  - updated the eightStepSequencer's import/export functions to include the
    current position
  - rewrote the launchpad to be a little more beautiful
  - rewrote the pulse_generator to be a little more beautiful
  - updated control.scene.printUnits to handle importing data to units where
    the import function fails
  

2019-09-24
  - updated a number of the units to have export/import data methods


2019-09-23
  compilation results
  -> core
          core.js 1577kb
          core.min.js 414kb
          reduced to 26.26% of original size
  -> coreSystem
          coreSystem.js 1589kb
          coreSystem.min.js 418kb
          reduced to 26.35% of original size
  -> workspace
          workspace.js 2698kb
          workspace.min.js 698kb
          reduced to 25.89% of original size
  -> curve
          curve.js 3707kb
          curve.min.js 1085kb
          reduced to 29.27% of original size

  - changed demo 1 to 0, and added a new demo 1
  - went back through the logs to find the last update dates for each layer,
    and add those values to the versionInformations


2019-09-22
  - fixed the position of the slider on the distortion unit
  

2019-09-21
  - added the audio_recorder unit
  - added a way to define the category order in a collection's drop down in the
    menubar
  - created a little family-portrait of the Alpha collection
  - enlarged the bumpers of the distortion unit slightly
  - changed the sizes of some of the signal and voltage nodes on some of the
    unit (just so they'd all look consistent)


2019-09-19
  - project files aren't being compressed when saved. Only because I never set 
    the appropiate argument. Tis fixed now
  - added import/export code to the pulse generator
  - faffed with making a unit validator function

    
2019-09-18
  - made a mistake with the fix to the launchpad yesterday. Easily fixed though
    (on first step, the system would attempt to dim the previously lit coloumn
    but ofcourse there wasn't a previous set coloumn. How it knows to skip this
    code on first step)
  - added the 'text' item to the list part (just a simple text element)
  - added "versionInformation" to every layer, which contains a date which
    (should) state when that layer was last modified (There's also a 'tick'
    value but I'm not sure what to do with it)
  - added "_canvas_.getVersionInformation" which gathers together all the version
    information from each layer
  - added an item to the menubar/dev section that displays the lastDateModified
    version information of each layer (starting at either 0/0/0 or today)
  - added links to the github and log files in menubar/dev


2019-09-17
  - made the launchpad more efficient with how it sends signals
  - fixed the issue with the 8 track mixer (I had the panning backwards)
  - adjusted the mouse panning code so that one can still deselect units when 
    mouseGripPanningEnabled is off


2019-09-16
  - added io code to audio_file_player


2019-09-15
  - replaced old needleOverlay and grapher_waveWorkspace with the newer ones
  - got the audio_file_player working (still not happy with it though)(it's
    also missing the io connections for controls)


2019-09-14
  - list_image mouse scrolling was broken, but now it's fixed -thumbs up- (the 
    cover.onwheel arguments list wasn't correct to what arguments were actually
    being provided)
  - new needleOverlay part (removed 'markers', added the ability to have lead
    needles (with all that involves))
  - new grapher_waveWorkspace (with the new needleOverlay)
  - began work on the audio_file_player
  
  notes
  - need to do a proper replacement of the old needleOverlay and 
    grapher_waveWorkspace, as right now there's just needleOverlay2 and 
    grapher_waveWorkspace2


2019-09-13
  - fixing up the new player circuit. it can do
    - looping
    - concurrent playing
    - definable limit to concurrent playing (or no limit at all)
    - individual or global control of 'playheads'
    - play area selection
    - playhead start/pause/stop/restart
    - rate adjustment 

    along with the retrival of information, such as playhead positions and
    waveform segments; and loading/unloading of audio data, etc.

  notes
  - grapher_waveWorkspace is going to have to be rejiggered to allow for
    multiple 'lead' needles


2019-09-12
  notes
  - the player circuit needs to be redone, to improve the looping, add multiple
    playback ability, "press play to restart" and "only play in the selected
    area" functionality

  - started work on the new player circuit


2019-09-11
  - added signal outputs to the musical keyboard, which adds both the
    functionality of having a key-press signal generator, and midi-to-signal
    converter (its already a signal-to-midi converter)
  - added core.viewport.cameraAdjust callback, which returns the viewport state


2019-09-09
  notes
  - A, the old multiband filter is a bit weird when it comes to displaying the
    frequency response graphs.
    B, there's no obvious way of getting the frequency response of multiple
    filters in a row, so, I'm going to have to build something myself I think.
    I think I'll make them from a new "manufacturer", bunding;
      - the histogram audio visualizer
      - the frequency response tester unit
        (it's got a "ddoooOOOOOIP" thing, and a magnitude response grapher
        thing)
    names, maybe..
      "Audio Research Technologies (ART)"
      "Accoustic Labratories LLC (ALL)"
      "Accoustic Research"
    there's already a real life company that makes audio equipment called "Audio
    Research" so I might just steal their aesthetic, or maybe "newtons4th"
    ...test equipment doesn't have the coolest of designs, but we'll work on it


2019-09-08
  - added the audio_in unit
  - did the artwork for the audio_file_player unit
  - lots of work done on the audio_file_player unit (everything working, except
    the multiShot-or-not checkbox)


2019-09-07
  - added the audio scope (there's something weird about connecting audio
    towards it, but from it works fine..)
    fixed it. Turned out the transparent portion of the backing was getting in
    the way. Placing the node in front of the backing was the solution
  - began work on the filter unit (I'm having real trouble figuring out what the
    values for the bands should be.. I need to add a frequency response output
    connection or something)


2019-09-03
  notes
  - thinking about renaming the beta units, as they're to be a part of the
    mainlist, they should have a better name than "beta" Besides, we should keep
    that name clear for future in-development units that really are
    to-be-beta-tested
    I'd like something that reflect their originally, by that I mean how they
    are the first collection and contain basic essential items. Originally I
    thought to call them "the essentials" but maybe "foundation"? "main"?
    "base"?
    ...Maybe just "Alpha" and any units that are actually in development can
    just be named that way (in the visible name) like "Alpha (under
    development)"

  - added '_collectionData' value to unit collections, which currently houses 
    the collections display name. 'alpha' has been renamed to "Development 
    Units" and 'beta' is now called "Alpha"
  - updated list and list_image part to allow one to define the arguments for 
    sublists differently from how their parent has them (though, if you don't 
    define one, the parent's is used as a default) It's handy for getting 
    sublists to be thinner or thicker than their parent
  - updated curve's menubar further to allow for more customized dropdowns. Now
    they all are a little bit tighter


2019-09-02
  - removed uses of the "constructor method" that had been used by units in the
    past, but seemed to have fallen out of use in favour of just storing the
    model name instead (I'm guessing that that was something I was trying to
    avoid doing back when I implimented the "constructor method" argument, but
    was only ever used by the cut/copy/paste code and the scene safe/load code.
    Both of which now rely on control.scene.documentUnits, which prefers to
    store the unit's collection and model names instead of links to the
    constructor code. All pretty soild though, so nothing to worry about)
  - fixed issue with connectionNodes when they're given bad callback code
  - straightened up the connection nodes on the combiners from yesterday so that
    they match those found on the duplicators


2019-09-01
  - added the pulse_generator
  - added the signal_combiner
  - pushed curve menubar to always display all the unit collections
  - added the voltage_combiner
  - added the data_combiner
  

2019-08-31
  - added darkmode™ option to the menubar (under tools)
  - created display part "glowbox_polygon"
  - created display part "glowbox_path"
  - added decimal points to "readout_sevenSegmentDisplay" and
    "readout_sevenSegmentDisplay_static"
  - began work on the pulse_generator


2019-08-30
  - added "Select Everything" and "Deselect Everything" hotkeys (ctrl-a and
    ctrl-shift-a respectivly) along with menubar items (under edit)
  - played with the colours of darkmode™ some more


2019-08-29
  - added 'cableConnectionPosition' argument to connectionNode element (all of 
    them), which allows one to set the cable point of the node as a percentage
    of the square
  - experimented with making a darkmode™


2019-08-28
  - fixed shift-to-select-multiple's shift-click to unselect feature (again?)
    Fixed by removing the "true" response from the other onmouseup function


2019-08-27
  - finished the control.actionRegistry test file
  - chaned how control.selection adds the selection glow (well, the name it
    gives the shape. It used to be 'selectionGlow-' followed by the address of
    the unit, but now its just 'control.selection::shape::selectionGlow' Which
    is good, because tying a shape to an address like that wasn't a great design
    choice to begin with)
  - control.actionRegistry.actionRegistrationActive is now a thing
  - the undo/redo for control.selection.duplicate is now done differently, and
    without bookends
  - updated unit grapple rotation code so that it maintains the xy position
    better
  - updated unit grapple rotation, to add unison rotation for groups of units


2019-08-26
  - updated core's shape 'group', so that when it removes a child, that child's
    parent value is set to undefined
  - updated control.scene.transfer to return the newly transfered units
  - created control.scene test file
  - started control.actionRegistry test file
  - apparently core.arrangement.getElementByAddress wasn't working properly (it
    was looking for 'root' in the root group)

  notes
  - I was thinking, the actionRegistry entries should be in/under the functions
    they're meant to relate to. I mean, there's already 'register action' code
    within those functions anyway


2019-08-25
  - added the voltage_dial unit
  - added the basic_synthesizer (some issues with the wobble features though.
    Seems you can set them too high and collisions can occur)


2019-08-24
  - fixed up system.keyboard, and/or perhaps learned how it works better
  - added "clearClipboard" to control.selection
  - added rectify arguments to control.grapple:alt / control.selection.duplicate
    / control.selection.paste to allow for a more natural duplication experience
  - duplication improved further, so if you click without movement while holding
    alt, the unit with rectify on mouse up
  - added ".ioRedraw" to unit builder (which just runs through all available io
    connections and runs their redraw functions)
  - completely replaced control.scene with control.scene2 (action registry needs
    to be redone, and more control.interaction switches)
  - trashed control.scene, renamed control.scene2 to control.scene
  - added some more switches to control.interaction
  - created the signal switch unit


2019-08-21
  - updated gravity to handle 'include' keywords without arguments
  - moved queryStringManager code from the curve layer to the control layer
    (renaming it 'queryString' along the way) Now, one has all the same control
    as before (actually a little more, you can set the query keys for demo and
    mod to whatever you like, you can sent the mod-list extension, set the
    default demo url prefix, along with the ability to request the mods of demos
    be loaded whenever you like (even by-passing the demoLoaders desire to wait
    for mods to be loaded)) but its packed away where it belongs


2019-08-19
  - expanded queryStringManager::loadDemo to accommodate numerical demo 
    requests (so, "?demo=1" is ok, and translates to 
    "https://curve.metasophiea.com/demos/1.crv") also removed the code that did
    this sort of thing from the index.html file in docs
  - added a little bit of test code for the new queryStringManager section. It
    automatically resets the URL to have the correct parameters

  notes:
  - I have questions in my mind about whether this mod loading code should be in
    the control section.. maybe the demo loading code should be there too


2019-08-18
  - redid the voltage_readout gauge backing


2019-08-16
  - started on advanced URL parameters ("demo" and "mod" URLs)
    http://0.0.0.0:8000/test.html?mod1=http://0.0.0.0:8000/mods/test_1.js
    http://0.0.0.0:8000/test.html?mod1=http://0.0.0.0:8000/mods/modListTest_1.cml
    http://0.0.0.0:8000/test.html?demo=http://0.0.0.0:8000/demos/1.crv
    'mod' loads code from a specified url and places it in its own <script>
    element
    'demo' is much the same as the system used elsewhere, but uses URLs to
    define the desired demo, instead of numbers. It does not run until all mods
    have been loaded

    all code in "5 - core/queryStringManager.js" and is cordoned off (might need
    a better name) Shouldn't matter too much anyway. Its more like a start-up
    script than an element of the program
  - control.scene.load now uses the library's way of loading things from a URL,
    instead of its own code for that job


2019-08-14
  - fixed a tiny issue in connectionNode_data (where the flash wasn't working
    properly after a disconnect)
  - turns out, none of the segment display parts could do .set properly. Tis
    fixed now, sire
  - improved the segment display parts (static versions) further, so that when
    you do a segment set or clear, it now actually clears and redraws properly
  - faffed with the reverb unit a bit, so that is has a little loading animation
    when it's loading the response file of choice. It also requests the initial
    response file more neatly, and isn't just hoping for the best from a silly
    timeout (nothing wrong with timeouts, some of my best friends are timeouts)
  - added some number safe-guarding to the meter_gauge and meter_level parts
  - messed with the voltage_readout a little (it needs to have its gauge's
    backing repainted anyway)


2019-08-13
  - did up the connection nodes and made a new test file for them (that actually
    tests things automatically too (except audio))


2019-08-12
  - readded double adjustment to core.render.adjustCanvasSize, as the canvas
    wasn't adjusting properly
  - faffed with the connectionNode more because the connectionNode_audio wasn't
    working (I really need to look at the connectionNode)


2019-08-11
  - added signal_readout
  - added voltage_readout (doesn't look all that great, honestly)
  - upgraded the gauge display part to use stenciling, and changed the
    'needleCover' shape into a 'fronting' shape
  - redid the voltage_readout unit.. gauge backing might still need a little
    work artistically, but it's got all the accurate markings you could need now
    (though they need to be a little more accurate still)


2019-08-10
  - added the glowbox_image part
  - added gauge part
  - added meter_gauge part
  - added gauge_image part
  - added meter_gauge_image part
  

2019-08-07
  - rearranged the docs/notes folder a little, so consolidate smaller files and 
    add 'ideas', 'bugs' and 'roadmap' files. 'ideas' is just a place to put nice
    ideas 'bugs' is to keep track of issues found and their solutions when they
    are found; 'roadmap' is basically a to-do list with an inflated sense of
    self-worth


2019-08-05
  - added the distortion unit
  - made some structural changes to the connection nodes, to allow for callbacks
    to be added after the part is created..I'm a little worried about it, so
    some testing is needed
  - added all the possible connection nodes to the distortion unit
  - augmented the reverb circuit to allow for more control over the wet/dry
    split
  - added the reverb unit
  - core's default fonts weren't calculating the default character correctly,
    tis fixed now, sire
  - added data_readout (thought it works fine, the printing system needs to be
    less silly)


2019-08-04
  - cleaned up the musical keyboard 
  - improved system's keyboard way of dealing with shapes that have 'onkeydown'
    of 'onkeyup' callbacks. Now shapes have to populate a .glyphs value and 
    system will only run the callbacks if a key with a glyph from that list is
    found. (fixes the duplication bug? maybe?)
  - moved the eight primary colours to the style object
  - added part 'glowbox_circle'
  - added the launchpad
 
 
2019-08-03
  - forgot to add the circuitry to the audio duplicator. Good job me
  - added the musical keyboard (as always, some review needed)

  bugs
  - buttons atop buttons don't hover right
  - sometimes duplicate mode is stuck on...I can't see why


2019-08-02
  - updated core.render.adjustCanvasSize::dimensionAdjust a little more to be
    more robust and handle more errors for the attributes


2019-08-01
  - updated core.render.adjustCanvasSize::dimensionAdjust again to allow the
    width and height to be set in pixels (eg, 300px)


2019-07-31
  - moved the new beta unit art from docs/prototypeUnits/2 to docs/images/beta
  - moved the ability to enable/disable that unload pop-up thing into the
    control layer.
  - added max/min width/height attribute functionality to
    core.render.adjustCanvasSize::dimensionAdjust. Also rearranged the math a
    little (should have no effect)
  - added "enableWindowScrollbarRemoval"

  bugs
  - control.interaction.mouseGripPanningEnabled when disabled doesn't allow for
    "click anywhere else" unit deselection


2019-07-29
  - changed the beta units a little to pull the url for the images out, so it's
    easier to change later. Also changed the name of all the files to remove the
    unnecessary prefixes
  - cleaned up the eightStepSequencer unit code a little
  - fixed the slider onclick issue. Seemed to run much deeper, down into core
    itself. The callback handling code for the system and core layers is rather
    messy...it probably needs a rewrite, though hopefully this messy version
    should be enough as is and so I won't have to do any work on it
    -thumbs up emoji-


2019-07-28
  - changed the button_image part to allow for missing URLs. Now if a state is
    requested for which there is no URL; no change is made to the image shape
  - managed to bork the slider mouse position calculation function without
    noticing, while fixing it on 2019-07-19. Good job everyone
    Adding the offset angle to the calculations added in the angle of parent 
    groups as desired, but also added the part's angle again. It should be fine
    now
  - added slide_discrete and slide_discrete_image parts, renaming 'slide' to 
    'slide_continuous' and 'slide_image' to 'slide_continuous_image' 
    (it probably all needs a clean)
  - changed some of the controls to not call their onchange callbacks when the
    set function is run at the end of their creation (need to make that change
    everywhere)
  - Ladies and gentlemen; the eight step sequencer (needs deeper testing, but
    looks pretty good...maybe a clean up)
  - Cleaned up the the ways parts are added to the partLibrary (now it's all
    nicely modular, and close to the part generating code)(also removes all
    those _main.js files)
  - added import/export to the eightStepSequencer

  bugs
  - mousedown on one slider and mouseup on another, causes an onclick on the
    second slider


2019-07-27
  - drew up and added the signal, voltage, data and audio duplicators
  - drew up the 8 step sequencer

  ideas
  - double click while rotating a unit to reset its angle
  - discrete slide
  - gauge part
  - image glowbox


2019-07-20
  - drew up the new amplifier unit (looking pretty snazzy too) and added it to
    the beta collection
  

2019-07-19
  - group select was borked. Turned out the changes made to the partBuilder
    weren't accounted for in the group select activation function (one of the 
    functions added to _canvas_.system.mouse.functionList.onmousedown)
  - rotated slider control didn't work as expected. It wasn't taking into
    account the offset angle of any containing group shape. Adding this to its
    calculations fixed everything
  - clink-n-drag cables now follow the mouse as it makes its way from one 
    connection node in search of another


2019-07-16
  - fixed issue with adjusting slide handles. They used to lurch around when you
    released the mouse, and attempt to centre the handle on the mouse point. Now
    they just leave it where you left it. Seems more natural


2019-07-14
  - ladies and gentlemen; the 'Eight Track Mixer' is now functional


2019-07-13
  - updated image based sliders, to remove the slot URL argument (which is
    superfluous as you can just put whatever graphics in the backing image) and
    allow for no backing image; which just doesn't add that image shape
  - more work on the new 'eight track mixer': completed (?) the backing panel, 
    created the unit with sliders and dials
    

2019-07-12
  - added a 'spaced' option to the core.arrangement.printTree function
  - had to put back in core.viewport.getHeight and .getWidth, because apparently
    I never put them in in the first place? Despite using them alot in the
    coreSystem test html


2019-06-25
  - improved core.render.adjustCanvasSize to actually get the adjustment right
    first time

  notes
  - thinking about redoing the interface parts section..started a document
    listing the parts and how they could be organised
  - I worry about the audio circuitry sometimes..I guess when I get back into
    actually making units, then they'll naturally rearrange and I begin trying
    to use them
    

2019-06-24
  - rewrote the tests for 'pathExtrapolation' (and put them in their own file)


2019-06-23
  - painting


2019-06-22
  - painting


2019-06-20
  - abandoned the "gauge" display part for now
  - reworked the interface/parts section, to allow for easier expansion of the
    collections (caused a lot of rewriting elsewhere too, thanks to the API
    changing)

  bugs
  - paths are pretty slow to generate when you get to ~100 points..in the
    grapher interface display part anyway...Its this union function man. Its 
    really rather slow


2019-06-18
  - started working on a "gauge" display part

  notes
  - need to divide out the collections in interface parts some more so that we
    can have more parts with similar names
  - need to expand gravity to accept "*/file.js" and to sort files from "*"
    alphabetically


2019-06-17
  - slight changes to the group shape's 'augmentExtremities_remove' function, 
    just to speed things up a tiny bit and add a comment


2019-06-11
  - updated the group shape again, this time to improve shape removal
    performance.
    - getChildByName now uses the 'childRegistry' (as is should do)
    - this.remove now activates a function called 'augmentExtremities_remove'
      which works to adjust the group shape's bounding box manually. It's smart
      enough to know when a shape is within the boudning box, and can bail on
      any recalculations of the boundaries if that is the case.

  notes
  - I've been thinking about re-painting all the beta units again, this time to
    include the little bumper piece in the image (I need to do a test on the
    rendering time of images verses shapes)


2019-06-10
  - improved the way the group shape calculates it's extremities when a shape is
    added (I think I somehow added and removed this method in the past, so, it's
    good to have it back)
  - more experimentation with WebAssembly. I created a function that emulates 
    the cartesianAngleAdjust found in library.math. It passes all the tests,
    however seems to run much slower that the original JS version. Upon research
    it seems that though the assemled code itself may be fast, the interface is
    still rather slow. Maybe in time this interface will get faster, or perhaps
    this feature is supposed to be used with larger, more completex operations.
    Perhaps rewriting the bulk of core in this way would be benefitial..quite a
    complex task however, and one I don't want to engage with for now.
  - further improved the way the group shape calculates it's extremities when a
    shape is added. Things are pretty damn fast now (the "check if name is used"
    code was slowing it down. Spead things along with a "childRegistry" object)
    Adding 580,000 shapes took ~4.5 seconds..couldn't render that many however
    (infact, the laptop started to freeze)

  ideas
  - maybe that beta distortion unit needs a redesign..
    

2019-06-09
  - began work on the beta basicSynthesizer
  

2019-06-08
  - updated the beta distortion unit's marking's image to have a higher
    resolution (it's not exactly like the original)
  - updated the beta amplifier unit's marking's image to have a higher
    resolution


2019-06-05
  - rejiggered the way the group shape does extremity calculation, so now
    there's less repeated code and it uses library functions more (so it will
    benefit when things start going WebAssembly down there)
  - added a transparent layer of markings to the distortion unit..it's not
    perfect, but it's pretty nice. Maybe I could redraw unit markings
    individually, and with higher resolution (also the in/out nodes are
    backwards)


2019-06-04
  - worked a little more on the beta distortion unit
  
  ideas
  - might be an idea to get a mostly transparent image of the distortionUnit
    that has all the markings on it. Saves me having to make it all with vectors


2019-06-03
  - rearranged the beta units folder to include custom shapes and parts
  - began work on the distortion unit

  bugs
  - the colours don't seem to be the same as the ones I use in the development
    painting..they're not even like what the numbers I put it say they should
    be.. :/ There seems to be something off with the way Chrome renders colour,
    because Firefox seems to be able to reproduce the colours fine


2019-06-01
  - connectionNode now has argument to select which version of the cable you
    want
  - added the amplifier unit (with the grill image)(pretty snazzy, though
    pretty simple)

  ideas
  - Could maybe make the amplifier grill vibrate with the sound?
  - change the unit paste function so that it places the units in the exact
    position first, and then does the springy corrections
    

2019-05-31
  - updated pathExtrapolation so that the joints and caps don't have that
    double-colouring issue. Tis good code now
  - updated polygonToSubTriangles and unionPolygons to cover more of the input
    and adhere to a more standard input type
  - moved "pathWithRoundJointsAndEnds" and "loopedPath" shapes to the trash

  notes
  - the new polygon union function works, but its a bit slow


2019-05-30
  - replacement library.math.pathExtrapolation going well, currently there's
      private
          function calculateJointData
          function path_to_rectangleSeries
          function rectangleSeries_to_sourcePoly
          function sourcePoly_to_polyWithRoundJointsAndEnds
          function sourcePoly_to_polyWithFlatJoints
          function sourcePoly_to_polyWithSharpJoints
      public
          path_to_rectangleSeries
          path_to_poly
          path_to_polyWithRoundJointsAndEnds
          path_to_polyWithCornerJoints
    needs better naming, but there's good functionality here

  - redid library.math.pathExtrapolation again, now there's only one function
    with a number of arguments
      function(path,thickness,capType,joinType,loopPath,detail,sharpLimit)
    everything is working pretty well, expect when a joint or cap is atop another
    joint or cap and there's some level of transparency.
  - changed the library, so that no-where can access the thirdparty functions.
    Instead, one must use a number of interface functions is different places for
    the same functionality. In this way, we can control access to that code
    someone else has written, potentially allowing us to replace it without much
    hassle.
  - upgraded the path shape to be able to do all the things the other variations
    of it can do. Also added warning messages to the other forms, that tell you
    to use path
  - upgraded the polygonWithOutline shape to have arguments with joint type
    (and detail, and sharpness limit)

  ideas
  - perhaps the shape "rectangleWithOutline" should use a path outline instead
    of the double rectangle thing is currently has..
  

2019-05-29
  - fixed up math.detectOverlap.pointWithinPoly
  - added PolyBool to the thirdparty library section
  - began work on a replacement library.math.pathExtrapolation

  Compilation Results
  - core.js                           1408 kB  (100%)
  - core.min.js                        392 kB  (27.85%)
  - workspace.js                      2392 kB  (100%)
  - workspace.min.js                   634 kB  (26.54%)
  - curve.js                          2863 kB  (100%)
  - curve.min.js                       816 kB  (28.50%)

  bugs
  - "pathWithRoundJointsAndEnds" is borked. Needs unborking.


2019-05-28
  - reworking core's callback system
  - updated all systems to use this new callback system (not a whole lot 
    different, just things need to prepend their argument lists with "x,y,")

  bugs
  - math.detectOverlap.pointWithinPoly is broken


2019-05-27
  - reworking core's callback system. New system has the ability to switch on
    and off shape callbacks for each type of callback. Along with just
    solidifying things


2019-05-26
  - added the audio duplicator unit
  - finalized on all the duplicator units

  bugs
  - there's something up with mouse selection of units
  - core's callback section is totally broken, yet somehow the rest of the
    system still works

  notes
  - I don't know what I did with core shapes' callbacks. It seems like it only
    activates the callbacks for 'onmouseenter' and 'onmouseleave'. But it will
    perform the callbacks for the system at large, and then layer two actually
    performs the callbacks for any of the shapes
    ..I think it's something to do with not wanting every shape's callback
    activated, but only the topmost shape...there needs to be a better way to
    achieve this, and get the functionality with just the core layer


2019-05-24
  - added the voltage and data duplicator units


2019-05-22
  - emergency fixes to units that used the checkbox_rectangle (as they were
    still calling it the checkbox_rect)


2019-05-21
  - rounded edge path working pretty well now, I think


2019-05-20
  - work on improving the state of line drawing. Things continue on the rounded
    edge path


2019-05-19
  - more drawing
  - started adding the new designs to the system. Currently the images directly,
    I think I'll convert them to vector designs in future
  - created the pathWithRoundJointsAndEnds core shape.. the rounds are produced
    by just adding circles, so transparent colouring of this shape doesn't look
    great, but with solid colours it looks just fine.
  - redid the signal duplicator in vector. Looking pretty good

  bugs
  - attaching a data duplicator to itself causes a "Maximum call stack size
    exceeded" error

  ideas
  - round-end/joint path/polygon
    

2019-05-18
  - some drawing


2019-05-17
  - expanded two of the tests to include examples of custom shape addition and
    usage
  - fixed issue with discrete dials not responding to the moouse wheel


2019-05-16
  - made a new type of dial; "dial_2_continuous" renaming the old one 
    "dial_1_continuous", while keeping 'dial_continuous' referencing it
  - opened up the interface parts builder library, to allow new parts to be
    added. Allowing future units to define their own parts and use them with the
    unit builder. #extensible


2019-05-14
  - added functions control.scene.absolute_documentUnit and 
    control.scene.printUnit (which are similar to, but different from their
    plural counterparts. I'd like to try and rectify that in future) 
  - renamed 'documentUnit' and 'printUnit' to 'absolute_documentUnit' and
    'absolute_printUnit' respectivly. Also renamed 'documentUnits' and
    'printUnits' to 'relative_documentUnits' and 'relative_printUnits' in a bid
    to clarify and distinguish what each function does
  - added the undo feature (adding the control.actionRegistry section) with a
    modular nature, so it should be possible to easily expand it in future.
    Currently it only covers:
      control.scene.addUnit
      control.scene.removeUnit
      control.selection.delete
      control.selection.duplicate
    to expand, one has to add a action registration function to the function
    they'd like to add the undo functionality too, then expand the switch
    statement with what actions to perform to undo it. Pretty straightforward.
  - control.scene.addUnit now has a new argument, which allows one ot force the
    name of the created unit (though if that name collides with another group,
    it won't be allowed)
  - added the redo function (which changes how undo works now too, but they both
    function together pretty nicely)
  - opened up the undo/redo method lists so that new actions can be added easily
    to both from anywhere (this is away from the original switch statement)
  - added undo/redo command buttons to curve's edit dropdown list on the menubar

  notes
  - this new code feels a little messy to me..I had to add new function into
    control.scene that are very like other functions that are already in there,
    so, that makes me uncomfortable. Also the control functions already have to
    deal with ability switches, and now actionRegistry commands, which makes 
    those function look rather rough...its all very contained though; none of 
    this new stuff touches any other layer, and they're kinda like parts of a 
    script anyway, so I can't think of a more elegant way of putting this 
    functionality in.
  - if there's any part of all this that we should accelerate with WebAssembly,
    its the extremity updating code. Then probably audio things, but maybe other
    parts of core before that.

  ideas
  - in light of the fact that making advanced dynamic cables is hard; what if 
    (for now) we add in little relay units? Tiny two-node items that are just
    used to pin cables to certian locations. They'd help clean up any confusing
    mess a bundle of the current cables would create


2019-05-13
  - added more tests for the library.math section
  - improved the tester funtions's ability to detect differences between arrays
    (and in turn, objects)
  - fixed up library.math.getDifferenceOfArrays
  - added library.math.detectOverlap.overlappingLineWithPolygons and a private
    function beside it "overlappingLineWithPolygon"
  - updated library.math.pathToPolygonGenerator to not blow up when drawing an
    overlapping path
  - began work on a more advanced cable (it's a little difficult)
  - painting
  

2019-05-12
  - more design work
  

2019-05-11
  - fixed up detectOverlap.pointWithinPoly
  - started designing the new units
  

2019-05-10
  - reduced the size changed the colour of the checkbox circle in list's
    checkbox item (its a little smaller and lighter now)
  - added more tests for the library.math code (having some issue with 
    detectOverlap.pointWithinPoly)

  bugs
  - audio player needle isn't right. If you're playing slow for a while then
    speed it up, the needle goes too quickly

  ideas
  - ctrl-z


2019-05-09
  - updated the way characterString calculates the vertically central point of
    text, using the character 'o' as the guide. Also added 'verymiddle' so one
    can still access the old way the calculation was done.
  - fixed the audio player unit's play-stop button overlap thing. The play
    button extended under the stop button

  ideas
  - Rust/WebAssembly for ultra speed? from what I understand, parts of the code
    could be rewritten and would work with the existing JS code...could be a
    great speed boost for core.


2019-05-08
  - pre-computed the vector values for the font 'defaultThick'
  - added unit position snapping (along with a new place in the menubar for it
    under "scene")
  - updated list's checkbox's 'function' name to 'onclickFunction' and added
    'updateFunction' which is run during item creation to set the state of the
    checkbox
  - unit adder now sets it's snapping on if necessary
  - updated library.math.fitPolyIn to allow for snapping
  - updated control.scene.rectifyUnitPosition to request 'fitPolyIn' use
    snapping, and provide it with the data
  - drawing a path back over itself (the way it came) caused the corner maker
    code to freak out. Fixed by adding a safty to the
    library.math.pathToPolygonGenerator function, which watches the
    'joiningAngle' to see if it becomes 2PI, and if so, changes it to PI,
    resulting in a flat ending (as if there was no third point at all) Probably
    need a nicer system in future.
  - list_image's checkbox item wasn't handling update or onclick callbacks. Now
    it does

  bugs
  - the way text centres itself vertically needs to be looked at (we need some
    form of "middle"/"middleOfBodyOfLetterIgnoringTheStemBitLikeOnTheLetter'h'")
  - collision with snapping, doesn't allow units to be placed right next to
    eachother (probably because they're taking up the same x or y value) (it's
    probably fine though)

  ideas
  - make list's checkbox item look better
  

2019-05-07
  - update the unit design description object thing, so that one can define if
    a unit should collide with others or not
  - removed parts of the unit builder which collects the designs category and
    collection name. If they ever come into use, I'll put them back. Collection
    name is now added automatically by the 'control.scene.addUnit' function  
  - pre-computed the vector values for the font 'defaultThin' (have began on
    'defaultThick')

  ideas
  - some kind of placement snapping
  - pre-calculate the default characters (instead of putting them through earcut
    during every start-up)
  - only calculate character points when that character is first used? (as
    opposed to calculating all the characters of a font, when that font is first
    used)

  bugs
  - mousing over the stop button on the player lights up the play button too


2019-05-06
  - 'create' dropdown menu order is now sorted alphabetically
  - list part's sublists weren't receiving the data needed to scale the sublist
    arrows correctly. Fixed that
  - updated the create menu in curve, so that when devMode is active, the drop
    down lists all units in all categories.
  - if a list part is created with no content; a single item is displayed
    reading "-empty-"
  - updated the way unit collections are stored, setting things up for the beta
    collection
  - first unit of the beta collection: a 100cm ruler
  

2019-05-05
  - fixed issue with adjusting the audioFilePlayer play head. It was entering a
    loop of some kind. Caused by the builder not lining up with all the
    arguments of the part's creator function

  ideas
  - make the order of the 'create' dropdown menu consistent


2019-05-03
  - changed the item__hover_glow__colour for the menubar dropdowns to be a bit
    more purple
  - fixed issue in list part's sublist closing, where 'space' not existing in
    the itemArray was causing problems related to the 'list' array
  - upgraded list_image part to be the same as the list part from (though
    ofcourse, with all images instead of shapes)
  - started thinking more seriously about what curve's units should be

  Compilation Results
  - core.js                           1283 kB  (100%)
  - core.min.js                        333 kB  (25.99%)
  - core.min.js(compressed)           78.6 kB  (6.12%)
  - workspace.js                      2199 kB  (100%)
  - workspace.min.js                   558 kB  (25.41%)
  - workspace.min.js (compressed)    119.8 kB  (5.44%)
  - curve.js                          2607 kB  (100%)
  - curve.min.js                       725 kB  (27.82%)
  - curve.min.js (compressed)        139.7 kB  (5.35%)

  ideas
  - search function in menubar, like in macOS
  - 'hover' for checkboxes? defaulted off I think
  - might have to rename the "signal" connection type to something else, so
    we can start saying that the thing that signal/voltage/data/audio
    connections send to eachother is a 'signal'. I need to reclaim that word.

  bugs
  - something is not right with the audioFilePlayer when you adjust the playhead
    backwards. It also doesn't seem to line up great with the waveform on speed
    adjusted play


2019-05-02
  - the new list is getting pretty solid, I've completely replaced the older one
    with this snazzy new one now, and updated all the places that used the old
    one to work with the newer interface. (need to update the image based one
    accordingly)
  - added sub-dropdowns for the menubar
  - created '_canvas_.interface.unit.collection.alpha._categoryData' which holds
    information about the categories of a collection. Probably not the best
    place for this data - its in the same space as all the units - but its there
    now


2019-05-01
  - redoing the list part from the ground. Things were getting a little messy
    with how things were scaled, so this version is simpler. Still in progress
    however, though mostly done. Needs some testing and a review.
  - added 'getChildIndexByName' to group shape


2019-04-30
  - added resultingWidth function to characterString shape, which you can use to
    discover what the with of the string is when printed.
  - added onFontUpdateCallback callback attribute to characterString
  - created the 'list2' control part which will replace the 'list' control part
    when its ready. Currently, it has all the old features plus named sections
    and checkboxes


2019-04-29
  - updated the tester function a little bit, to ease the comparison of numbers
    There's now: 
      if( Math.abs(item1 - item2) < 1.0e-15 ){return true;}
    This was added as tests were failing on firefox while passing on Chrome. It
    seems that firefox will display 17 digits after a decimal point, but chrome
    only uses 16, thus, those numbers will not match. This extra piece ensures
    that they do.
  - interestingly, if you make a comment like /*! hello */ the comment will
    pass through closure untouched.


2019-04-26
  - changed font loading, so that fonts are only loaded when they are to be used
    also expanded the character font functions out a bit, adding
    getLoadableFonts, getLoadedFonts, isApprovedFont, isFontLoaded,
    fontLoadAttempted and loadFont. I've also expanded the vector library 
    entries a little to recored whether an attempt has been made to load the
    font (to stop multiple requests)
  - added stereo version of the filter unit
  - created a new version of the sequencer using the more modern connections

  Notes
  - alot of these units need to be redone with more appropriate modern 
    connection nodes. I'm only worried that that will mess up the demo. I'm 
    thinking of just making a load of 'v2' versions, and remaking the old 
    demo...I'd rather do that on my desktop

  ideas
  - advanced drop down menus (extra branches, named sections, checkboxes, help
    search box (like on macOS))


2019-04-25
  - added getUnitsByModel to control.scene
  - fleshing out the curve units a little (adding pulse generators for signal
    and voltage connection nodes, same for duplicators and stereo versions of
    the distortion and reverb units)


2019-04-24
  - emergency fixes to where the fonts are stored and the no image image, as I 
    hadn't thought about access to that sort of stuff. There's now a /docs/fonts
    folder for all the fonts (in their ttf form)
  - fixed up the core demo file
  - updated the readme
  - little bit of work on a new universalreadout and pulseGenerator (using
    different connection node types)

  ideas
  - there probably should be some way that character shapes use one of the
    default fonts, when a requested URL font fails to load
  - change the unit connections that are sending essentially pulse commands, 
    away from using data connections and to using signal or voltage connections

  Compilation Results
  - core.js                              1303 Kb  (100%)
  - core.min.js                           331 Kb  (25.44%)
  - workspace.js                         2182 Kb  (100%)
  - workspace.min.js                      547 Kb  (25.09%)
  - curve.js                             2476 Kb  (100%)
  - curve.min.js                          668 Kb  (27.01%)


2019-04-23
  - fixed rotated unit collision (the way it was calculating the unit space was
    wrong)
  - fixed the connectionNode angle thing (I was using the wrong 'angle' value)
  - slightly improved the needleOverlay selection area resizing mouse situation
  - replaced the canvas version with the new webGL version (putting all the old
    code into the workshop) Things are going pretty smooth, except the core.html
    demo code, which needs a little fixing up


2019-04-22
  - started putting the old library tests back in
  - put the old system tests in
  - put 'fitPolyIn' back into the library, and re activated unit collision
    (still needs a little work, but that's outside the reactivation)
  - tried to fix the connection node rotation thing

  ideas
  - auto kerning? It wouldn't be able to do intersecting (like with lobster) but
    it could do alot anyway
  - need to fill out the tests

  bugs
  - rotating units and unit collision doesn't play well together


2019-04-20
  - fixed basic mixer (was using the wrong name for something)
  - fixed issue with One Shot (Multi) and One Shot (Multi)(8-Track) where the
    playhead didn't line up with what was heard when the region was
    set. Fixed it by replacing the math used to calculate the step size of the
    play head (changed some other things along the way, little things like
    removing pointless math and adding comments)
  - removed old character and characterString code
  - removed old characterFonts and renamed advancedFonts to characterFonts

  bugs
  - cables don't line up over the connection nodes when the nodes are rotated


2019-04-19
  - updated "extractGlyphs" to do a little normalization on the glyphs as a font
    is loaded
  - added some Helvetica fonts
  - added Arial font
  - added ability to adjust inter character spacing
  - updated layers to use the new font system (pretty nice so far)

  notes
  - I've just no idea what the data returned from opentype is about when it
    comes to kerning, so I'm leaving it for now. It's only really visible in the
    more flamboyant fonts

  bugs
  - I don't think the basic mixer is doing its job correctly


2019-04-18
  - things are looking pretty good on the whole font front. I have new library
    code for converting the files into usable data (in a new section of the
    library called library.font) There's also new character and characterString
    shapes which use them (which are a little better than the old ones, I think)
  - expanding the system's ability to accept new fonts, I tried out something
    called "Cute Font" which mostly works..a couple of the letters seem to be
    inverted. Lobster is working great though :D
  - also expanded one of the core test, so one can easily look through all the
    different characters of a font
  - changed "getTrianglesFromGlyphPath" to now reorder the glyph paths to sort
    them by size, before determining which is a hole. Which means "Cute Font"
    is working now


2019-04-17
  - gonna lose your mind in detroit; font city (working on core shapes)


2019-04-16
  - even more font work
 

2019-04-15
  - font work continued (rolling things together into nicer chunks)


2019-04-10
  - font work continued


2019-04-09
  - more font work


2019-04-08
  - font work


2019-04-05
  notes
  - more looking at the font thing...it's complicated, but I think it can be
    done. Earcut does most of the heavy lifting, all I really need to do is
    convert these paths to a series of points (figuring out where the holes are
    and decoding the bézier curves) and hand that data to earcut, which will
    return the triangles. It will need a new character shape (and probably a
    new characterString shape)


2019-04-04
  notes
  - I've done a little research on getting fonts. Found a post that talks about
    (https://stackoverflow.com/questions/25956272/better-quality-text-in-webgl)
    https://github.com/opentypejs/opentype.js which a program one can use to
    extract point data from TrueType and OpenType font files. It then says to
    use earcut to generate the polygon triangles. If we could get that system to
    work, we would have access to a vast array of quality fonts, further 
    reducing the visible difference between the canvas and webGL versions
    I've began some experimentation


2019-04-03
  - webGL experiment
    - finally finished "defaultThin" font
    - added 'spacing' attribute to characterString, and associated attributes to
      the buttons and list parts
    - updated the way that the default font is selected (and set it to be the
      new defaultThin)


2019-04-02
  - webGL experiment
    - further work on "defaultThin" (only one left)


2019-04-01
  - webGL experiment
    - further work on "defaultThin" 


2019-03-31
  - webGL experiment
    - further work on "defaultThin" font (sooo many characters)


2019-03-30
  - webGL experiment
    - further work on "defaultThin" font


2019-03-29
  - webGL experiment
    - fixed up the i and j characters
    - shifted the text in the recording unit a little (the button text isn't
      perfectly aligned anyway. The characterString shape judges the 'middle'
      as being the center of a capital letter)
    - added { and } characters
    - upgraded character encroachment, to allow more control
    - turns out 'event.x' and 'event.y' are relative to the window, not the
      element. So I've augmented the event object to have .X and .Y attributes
      with the correct positions (.offsetX and .offsetY), modified every 
      callback to calculate these numbers, and changed every reference to .x
      and .y to .X and .Y
      ...another rather buggy addition. so, be warned.
    - fixed musicalKeyboard's keyboard input
    - began work on "defaultThin" font

  future ideas
  - need to make a thinner font I think

  notes
  - program is at 21592 lines right now. Its crazy really. The log starts in
    april, but I'm pretty sure that this whole thing started over a year ago.
    We've come so far
  - you can't do multi screen with the test version


2019-03-28
  - webGL experiment
    - fixed up the ?, /, \, -,  1 and 3 characters and all of the lower-case
      letters. Along with expanded spacing from 0.1 to 0.15
    - adjusted waveWorkspace default size a little
    - did a little work on character kerning by adding the "encroachUpon" list
      to the vector list..it's doing most of the job.

  future ideas
  - image based text?

  notes
  - recorder buttons aren't straight-forward buttons, which means the text on
    them doesn't line up perfectly. So that needs to be changed
  - need to fix up the 'i' and 'j' characters


2019-03-27
  - webGL experiment
    - launchpad is working again
    - fixed sequencer issues
      - the sequencer sometimes stops working. Like all mouse interaction is
        ignored and passed through  
      - doing a group selection in a sequencer, then trying to do a general one;
        you instead are still doing a sequencer group select
      somewhere along the way, I had the interaction panes' heights being set to
      the width. An easy fix
    - fixed the needle colour on the 8-track player thing
    - added a frame-rate limiter to core rendering
    - fixed little issue with click-selecting locations on the needleOverlay 
      part
    - fixed the styling in the static audio grapher
    - fixed an issue with the slides (again related to that callback change I
      made last time)

  notes
  - can't properly test the audioIn unit without getting a HTTPS connection, so,
    that'll need a little more work. Things seem good otherwise
  - need to redo that font. The capital letters are all pretty solid (except
    Q and W), the lower case all need to be looked at, numbers are good (except
    1 and 3, and 2 a little) alot of the extra characters need to be looked at
    too


2019-03-26
  - webGL experiment
    - doubled the thickness of cables
    - fixed unit rotation
    - changed up the data that core's callbacks returns, so now it will only
      calculate the shapes under a point or get the workspace point when there's
      arguments for those things. Lots of things changed becase of this and
      required fixing, so, expect bugs related to it in future
    - fixed pasting with the menubar (it wasn't placing in the correct
      position)
    - added basicSynthesizer_img back in
    - ..issues with the new callback system go on. fixed up buttons. Will need 
      to take a deeper look at how core.callback is working

  notes
  - its actually starting to look like this is ready for the prime time (bar
    that silly font)


2019-03-25
  - webGL experiment
    - menubar will now close all dropdowns when the window is resized
    - changed the adjustZoom function in the sequencer part a little, to use 
      'forEach' instead of a for loop. I figure it's probably a little faster
      and nicer looking
    - created new version of the group shape that calculates its extremities in
      a more efficient (time wise and space wise) way. Things seem to have 
      drastically improved in demo 1...I'm not really sure what the difference
      was, but it was something to do with this.

  notes
  - now that the actively stenciling group automatically clears the stencil 
    buffer when it's done; it's probably going to effect any other groups that
    are doing stencil things too, like a parent of the group..perhaps its a
    niche situation, but still one to look out for.
  - group's extremity methodology needs to be changed too. It's just saving all
    the points of it's children, thus resulting in thousands of points being
    stored. (one of the test scenes has a group with 50000 extremity points) I'm
    thinking of only using the bounding box instead. The updateExtremities
    already runs through all the children's point extremities to built itself, 
    so I don't think it'll be a negative on performance...probably a boost
    actually.


2019-03-24
  - webGL experiment
    - fixed that crossover thing (it was to do with stenciling, where the groups
      weren't clearing the stencil buffer after they're all done)
    - fixed the sequencer zooming thing (classic case of trying to access the
      children of a group with '.children' instead of '.children()')
    - more issues with the GUI scaling fixed


2019-03-23
  - webGL experiment
    - midi sequencer unit mouse panning now updates the rangeslides
    - fixed rangeSlide-sequencer control issue. Turned out, the sequencer was
      doing too many update on an adjust (classic problem) using the fresh
      'stopAttributeStartedExtremityUpdate' attribute on shapes that don't need
      their extremities calculated, this was fixed

  bugs
  - zooming the midi sequencer unit is fine for the background, but bad for the
    note blocks
  - sequencer parts worksheets crossover onto eachother's space


2019-03-21
  - webGL experiment

  bugs
  - on the sequencer units, mouse panning on the sequencer doesn't update the
    rangeslides


2019-03-20
  - webGL experiment
    - added last of curve units
    - updated interface parts to have a more unified argument structure
      (particularly when it comes to styling)
    - updated image shape so that it doesn't reload its image, when the url is
      changed to the one it already has. This has fixed the list_image
      scrolling problem
    - the webGL version has reached ~21000 lines (the canvas version is at
      around 19000)

  notes
  - I need to redo these characters. I need to get a big grid together and draw
    them all beside eachother, so I can get them in better proportion to
    eachother

  bugs
  - using the rangeslide on the sequencer is super slow. The sequencer's
    interface functionality itself is fine (eg, spacebar and mouse to pan) so
    I'm guessing its something to do with how the rangeslide is interacting with
    the sequencer..perhaps the number of change requests it sends


2019-03-19
  - webGL experiment
    - added "circleWithOutline" shape (which uses a trick to draw its outline,
      so you can't get a ring with transparent centre...might change that in
      future)
    - unified core path shapes with "WithOutline" shapes, so the thickness
      values are all the same (I think)
    - added a number of curve units


2019-03-18
  - webGL experiment
    - work continues on the curve units. Along the way though, I discover issues
      with some of the interface parts, particularly the graphers


2019-03-16
  - webGL experiment
    - still working on layer 4. Unit selection is working pretty good now
    - GUI is back (that font is shocking)
    

2019-03-15
  - webGL experiment
    - fixed polygonWithOutline outline (the indexing math wasn't being done
      correctly)
    - fixed group clipping (by removing the "context.stencilMask(0x00);" line
      ...I don't know why this works)
    - on to the control layer again
    - mouse panning and zoom works again


2019-03-14
  - webGL experiment
    - turned out I was using a global by accident, so characterString is working
      now. Plus its got a more advanced aligning method too
    - we're back to having layer 3 working again


2019-03-13
  - webGL experiment
    - serious work on version 2 of the shapes. I'm paying special attention to
      what induces extremity calculations, and have hopefully kept things under
      control. I'm almost done with them all, just some niggly bits of the
      characterString shape remain
    - also added the "polygonWithOutline" shape


2019-03-12
  - webGL experiment
    - fixed some issues surrounding how long it takes extremities to be
      calculated, with calculations being redone needlessly. It's revealed a
      number of issues throughout the core system however..something I'l need to
      rewrite. Hopefully things will be fine but slow, thus allowing me to make
      those fixes in future without much issue
        It basically boils down to how the extremities are being done. In the
      past they were calculated on a virtual plane; the "workspace". But now
      they're being calculated on the canvas plane itself. Though not
      inherently bad, it means that the system is a little less intuitive,
      and point conversion is more complicated..I'd like to switch back to the
      old way..I need to think more about it though.


  notes
  - control layer is getting buggier and buggier, it's revealing issues in the
    interface layer too...I'm just going deep dive back into layer 1, 2 and 3.
  - turns out; extremities are being calculated this way to make camera movement
    easier. It's easier to shift everything to the left to make it look like the
    camera has moved to the right, then to additional calculations to convert
    "workspace" points to renderable canvas points


2019-03-11
  - webGL experiment
    - the display part "level" seemed to be taking a very very long time to
      update itself..at least, that's how it looks. Lots of recalculation going
      on. fixed by adding an advanced attribute to rectangle:
      "__stopExtremityUpdate" which stops any extremity update from happening.
      (Should perhaps look into doing something similar for the graphers? Though
      the sub-canvas kinda covers that ...really, there should be a canvas
      version of the level too)
    - fixed issue with character extremity calculation

  notes
  - ...the text is a bit shit, honestly

  bugs
  - zooming is borked. I've just left it commented out for now
  - group clipping seems broken too
  - unit grappling is borked too (probably because I removed group callbacks)

2019-03-10
  - webGL experiment
    - putting together the text shape (finally have all the character vectors
      together)
    - added ratios to those characters, which should make printing them a little
      easier
    - added characterString shape, with a couple options for how it attempts to
      produce the characters
    - added text to all the parts that were lacking it

  notes
  - the font is very stylized; not as friendly or unassuming as the old arial
    font

  bugs
  - the image-based list, doesn't render lots of the button images when you use
    mouse wheel to scroll


2019-03-08
  - webGL experiment
    - putting together the text shape


2019-03-06
  - webGL experiment
    - putting together the text shape


2019-03-04
  - webGL experiment
    - added in a default image for the image shape (using the old 'no image
      image' from way back in the Lavendel days)
    - added checkbox_image part
    - added rastorGrid part
    - added core.viewport.cursor function for changing the cursor icon
    - added needleOverlay part
    - added grapher_waveWorkspace part
    - added sequencer part :: thus completes all that parts
      

2019-03-02
  - webGL experiment
    - fixed rectangle and image anchoring
    - added new thirdparty code "earcut" for transforming polygon points into a
      series of triangles
    - updated polygon shape to use earcut, simplifying point design (and making
      extremities work again) 
    - added rectangle, circle and polygon checkboxes


2019-03-01
  - webGL experiment
    - added some basic checking to the core.shapes code, to check that the
      shape have the correct structure
    - finished up on "rectangle with outline" shape
    - cleaned up rectangle shape a little
    - added 'looped path' shape
    - replaced button_rectangle's rectangle shape with the rectangleWithOutline
      shape


2019-02-28
  - webGL experiment
    - fixed polygon so it can do more complex shapes now, though also made
      adding points more complicated too
    - added angle parameter to the circle shape
    - working on new "rectangle with outline" shape (I have it working, but it
      feels inelegant)


2019-02-27
  - webGL experiment
    - fixed small issue with connectionNode cable placement
    - added dial parts
    - working on buttons, seems I'm going to need a "rectangle with outline"
      shape, and probably a polygon and circle version too
      - added generic
      - added rectangle
      - added polygon
      - added circle
      - added image
    - added list and list_image control parts (scrolling is a bit jumpy for the
      image version. Not sure why)

  todo
  - text shape
  - rectangle with outline shape
  - polygon with outline shape
  - circle with outline shape


2019-02-26
  - webGL experiment
    - added cable
    - working on adding in the connectionNodes
      - connectionNode done
      - connectionNode_signal done
      - connectionNode_voltage done
      - connectionNode_data done
      - connectionNode_audio done


2019-02-25
  - webGL experiment
    - added slide_image control part
    - added slidePanel control part
    - added slidePanel_image control part
    - added rangeSlide control part
    - added rangeSlide_image control part


2019-02-24
  - webGL experiment
    - added tree printing function to arrangement
    - added 'getElementByAddress' function to arrangement
    - added glowbox_rect display part
    - added 'pointsAsXYArray' method of polygon and path shapes (and appropriate
      arguments to builder)
    - added sevenSegmentDisplay display part
    - added sevenSegmentDisplay_static display part
    - added sixteenSegmentDisplay display part
    - added sixteenSegmentDisplay_static display part
    - added level display part
    - added meter_level display part
    - added audio_meter_level display part
    - added in part circuitry
    - added in audio library
    - added rastorDisplay display part
    - added grapher display part
    - added grapher_static display part
    - added grapher_periodicWave display part
    - added grapher_periodicWave_static display part
    - added grapher_audioScope display part
    - added grapher_audioScope_static display part
    - readded adapter (I'm not sure it'll actually be useful though)
    - fixed getElementsUnderPoint
    - added slide control part


2019-02-23
  - webGL experiment
    - turned out alot of the point-conversion code was useless, so that's gone
    - readded system layer
    - redid things to be even more like the main system
    - added interface layer (slowly getting things back together)


2019-02-22
  - webGL experiment
    - > 2 shoring things up
    - experimenting with pulling the render judgement out of the shapes, and
      into the group shape rendering them. Sort of as a prep for clipped render
      judgement
    - added clipped render judgement
    - > 3 putting it together like the main system
    - added "__canvasPreFix" value, to determine what the system is called


2019-02-21
  - webGL experiment
    - little bit of cleaning with the image and canvas shapes
    - added group clipping
    - rectangle shape was miscalculating its extremities (it had left out the
      anchor) updated image and canvas shape accordingly (as they were based on
      the rectangle shape)

  notes
  - things what I need to add still: non-render calculations for shapes in
    clipped groups


2019-02-20
  - webGL experiment
    - updated rectangle shape 
    - did fps test, things are much much faster now
    - updated polygon shape
    - updated path shape
    - added image shape
    - added canvas shape (with transparency on, though one could easily make a
      second version of the shape with transparency turned off)


2019-02-19
  - webGL experiment
    - added image shape (it was frightfully slow, but it seems you can save
      buffer locations (so to speak) which speeds things up. Should try and
      impliment this for other buffers..)
    - updated point buffer in the image shape, to not update for every render.
      It works fine, so, I need to do this for the other shapes too.
    - updated uniform updaters too. Just squeezing as much as I can out of this
      image shape. It makes the 'updateGLAttributes' function a bit longer
      though
    - updated the circle shape in a similar way


2019-02-18
  - webGL experiment
    - slight improvement to the pathToPolygonGenerator (to reduce the number of
      for loops from 3 to 2, and other little things)


2019-02-16
  - webGL experiment
    - version 4 works! now for clean up
    - version 5, is a much cleaner version, and has replaced all other code in
      there


2019-02-15
  - webGL experiment
    - path shape still in development, it's a bit shakey right now, but I've
      gotten the resizing of connection points to work pretty nicely
    - version 3 seems to work a little nicer..not fully though


2019-02-14
  - webGL experiment
    - have rudimentary version of the new path shape working


2019-02-13
  - webGL experiment
    - added library function "workspace.library.math.getDifferenceOfArrays"
      which returns the items from each list that don't appear in the other
    - updated callback attachment/returning; now onmouseenter and onmouseleave
      work as you would expect
    - added keydown and key up sections to callback attachment/returning
    - updated onmousedown/onmouseup/onclick callbacks to have a smarter version
      of onclick (which only runs when the down and up occur over the same 
      shape)
    - work begins on 'path' shape (it seems that "LINE_STRIP" can only have a
      thickness of 1, so, I'm going to have to do some magic with
      TRIANGLE_STRIP or something)
    

2019-02-12
  - webGL experiment
    - made 'computeExtremities' a little more complicated in the rectangle shape
      in order to stop it from recalculating it's extremities where there was no
      change in it's position values or offset. It's done little to alleviate
      the speed problem
    - added 'augmentExtremities_addChild' function to the group shape, which has
      sped things up greatly. Now the laptop is capable of adding 10,000 shapes
      in just under 4 seconds.
    - added library function "workspace.library.math.getIndexOfSequence", for
      finding sequences of items in an array, and returning the index
    - added 'augmentExtremities_removeChild' function to the group shape
    - added the more advanced 'computeExtremities' code to the polygon and
      circle shapes
    - checked on shape callback attachment and returning, which seems to be
      working (after a little bit of fixing)
  
  
2019-02-11
  - webGL experiment
    - preformance review: group's "computeExtremities" is taking alot of time on
      test 2 (where it adds lots and lots of rectangles to a group)
      The hang up centers around the group calculating together the extremities
      of every child shape every time a new shape is added. An
      "augmentExtremitiesWithNewChild" function is required, though is something
      similar possible for child removal?
    - little bit of work; trying to make the offset pass though connected
      "computeExtremities" functions. Still under works...


2019-02-08
  ideas
  - I'm thinking about redesigning core one last time, mainly around this whole
    "static" thing. Right now there's a master group, and the 'camera' 's values
    adjust that group's offset. Originally, additional code was added to modify
    shapes' positions is they were selected to be static...which is messy.
      My idea, is to have the camera not effect the root group, but only groups
    that are the root's direct children, in an opt-in fashion. As such, this
    would allow one to select which master layers had movement, and how those
    layers were organised.

  - webGL experiment
    - fixed that alpha thing (turned out, there's extra setting one must set to
      select what the fragment shader does (I guess))
    - fixed derender
    - added static shapes (in the way described above)
    - added shape names and addresses


2019-02-07
  - webGL experiment
    - added derender
    - added shape selection based on point or area

  bugs
  - colours with alpha at anything below 1, don't render as expected


2019-02-06
  - webGL experiment
    - upgraded group shape
    - upgraded polygon shape
    - upgraded circle shape
    - added adapter functions 
        core.viewport.adapter.windowPoint2workspacePoint
        core.viewport.adapter.workspacePoint2windowPoint


2019-02-05
  - webGL experiment
    - fixed up positions, angle and scaling for all shapes
    - added a circle shape
    - added dot maker
    - stated on a more advanced version of the shapes
    - upgraded rectangle shape


2019-02-04
  - webGL experiment
    - fixed the thing from yesterday. Seems programs retain no data at all, thus
      basic point data needs to be reintroduced after a different program has 
      been selected for use
    - fixed scaling on screens with lower pixel density..still needs work when
      I get back to a high-density screen though
    - unborked polygon along the way
    - added camera positioning


2019-02-03
  - webGL experiment
    - there's something wrong somewhere.. I can't get it to render polygons and
      rectangles at the same time


2019-02-02
  - webGL experiment
    - added pixel density adjustment (mostly)
    - added stat taker
    - added polygon shape


2019-02-01
  - planned progress order of core2
    - basic drawing of shapes (with grouping) (essentially static shapes)
    - drawing of shapes, with respect to camera "position", "angle" and "zoom"
    - extremities and bounding boundingBoxes
      - calculation of extremities and bounding boxes
      - derender
      - shape selection based on point (or area)
    - static shapes
    - shapes with uniquie names (per group) and addressing
    - callback attachment and returning
    - path shape
    - image shape
    - canvas shape
    - clipping

  - experiment is ongoing. I've implemented versions of the cartesian2polar,
    polar2cartesian and cartesianAngleAdjust functions in GSLS, and things seem
    to be going quite well..


2019-01-31
  - been spending a few days looking into webGL. Core might need a bit of a
    rewrite (probably causing other things to be rewritten too) but we could see
    some major performance boosts
    

2019-01-23
  future ideas
  - core version 2? this time in webGL and with little changes to how some 
    other things are done ('getShapeUnderPoint' to actually return all shapes
    that are under said point, in the order they are layered)
    We could probable use roughly the same data structure for describing and
    organising shapes.
    ...now that I think about it..the "webGL" element needs only ot apply to
    the actual render of the shapes; and not to do with the graphical structure
    of anything like that..this could save alot of development time...maybe.
    I'll start a webGL experiment in the workspace at some point


2019-01-22
  - added way of selecting which colour to clear the canvas with (accessable
    with workspace.core.render.clearColour)
  - added similar method to control; workspace.control.scene.backgroundColour
  - played around with adding "tron-like" stylings to the basicSynthesizer
    (with some success)
  - added slidePanel_image (which has an overlay texture)
  - fixed slide_image a little. Seems to be a thing with the way shapes are
    selected from a point with a callback. Core will search down for a shape that
    has the callback, while system will use the frontmost shape and search up
    through parents. This sometimes means that callbacks attached to groups are
    not found. A solution is to use shape covers for callbacks that span over an
    entire object (layering other elememts as necessary so that other
    functionality isn't lost)
     Updated slide along the way. Both are working better now.
  - added rangeSlide_image (fixing some things about rangeSlide along the way)
  - added list_image
  - added checkbox_ (similar to the generic version of button) also
    checkbox_rectangle, checkbox_circle, checkbox_polygon and checkbox_image
  - fixed curve's menubar's calls to control functions
  - borked curve unit descriptions along the way (but also fixed them)

  bugs
  - strokeWidth's dissapear sometimes, making outlines very thin


2019-01-21
  - upgraded button_image, dial_continuous and dial_discrete to be able to deal
    with no image links (they just default to the non-image version)
  - added slide_image (with defaulting)

  future ideas
  - texture packs (of images so that all units can look the same thematically)
    It would be good to store them in /docs aswel, making them accessible to the
    web, and not impeding on /docs/images

      docs
        texture
          curve
            part
              button
                overlay.png
                off.png
                up.png                 press.png
                select.png             select_press.png
                glow.png               glow_press.png
                glow_select.png        glow_select_press.png
                hover.png              hover_press.png
                hover_select.png       hover_select_press.png
                hover_glow.png         hover_glow_press.png
                hover_glow_select.png  hover_glow_select_press.png
              dial
                overlay.png
                handle.png  slot.png  neelde.png
              slide
                overlay.png
                handle.png  slot.png  backing.png
              slidePanel
                overlay
                handle.png  slot.png  backing.png
              ...
            unit
              basicSynthesizer.png
              distortionUnit.png
              ...

    it makes sense that these textures are sorted as being specific to curve,
    as then one can also bundle in the unit textures. One could drag the part
    textures to other projects, but they aren't specific to the interface layer.
      They're specific to curve, as the part textures are to match the unit 
    textures.
      The question is; what should the default textures should be? Right now,
    I'm currently making them default to their non-image based cousins and in
    turn using their defaults


2019-01-20
  - fixed curve's dropdown problem from yesterday by adding category data to the
    unit's metadata 
  - added button_ (a generic version, for making more types of buttons faster
    and easier)
  - replaced button_rect with button_rectangle (a more advanced version)
  - added button_circle
  - added button_polygon
  - added button_image
  - added dial_image_continuous and dial_image_discrete
  - continued the basicSynthesizer (with an image for a background) to give it
    dials that had images for their parts.. doesn't look great (mainly because I
    spent 0 time on what the images are), but it totally works :D

  Compilation Results
  - workspace.js                         1243 Kb  (100%)
  - workspace.min.js                      378 Kb  (30.42%)

2019-01-19
  - improved workspace.library.math.fitPolyIn initial position finding routine
    by making is search in increasing circles of size, where the step between
    each circle's radius also increases, thus allowing for more accurate poly
    placement (particularly when sandwiched between two other polys)
  - created basicSynthesizer with an image for a background
  - removed the concept of "categories" from units
  - removed the concept of "alpha" from parts, and replaced with "collection"
  - began developing more advanced versions of parts, starting with buttons

  bugs
  - borked curve's create dropdown along the way

  future ideas
  - transparent image overlays for parts and units


2019-01-18
  - workspace.library.math.fitPolyIn is now working wonderfully
  - workspace.control.scene.rectifyUnitPosition has also been updated, which
    applies fitPolyIn to all units. Things are pretty sweet.
  - fixed problem of rotating a unit and the space not rotating with it
  - added 'enableUnitCollision' to control.interaction 
  - added "clippedImage" basic part to interface layer

  Compilation Results
  - workspace.js                         1196 Kb  (100%)
  - workspace.min.js                      354 Kb  (29.65%)

  bugs
  - when moving a group of things; they shouldn't collide off eachother
    ...probably?
  -  control.scene.getUnitsByType just doesn't work


2019-01-17
  - latest version of workspace.library.math.fitPolyIn is working pretty
    beautifully; it's still based on the brute method from before, but now does
    things is a more efficient way, and seems to be able to deliver an accurate
    offset very quickly.
   - developing workspace.library.math.fitPolyIn2 (almost there)

  bugs
  - rotation of unit doesn't rotate it's space at all


2019-01-16
  - redid control switches as "interaction"
  - added "getAllUnits" method to control.scene
  - added 'enableUnitInteractable' and 'enableCableDisconnectionConnection'
    methods to control.interaction (which runs through all units in the scene
    and activates their 'allowIOConnections', 'allowIODisconnections' and
    'interactable' functions as necessary)
  - activating devMode stops all changes to control.interaction from working (it
    essentially locks things in place, back before any of the interaction
    settings were changed to 'false')
  - renamed 'testUnit' to 'testUnit_1'
  - created new test unit 'testUnit_2'
  - added workspace.library.math.fitPolyIn, which is used for finding the closet
    place a poly can fit in a field. To be used with
    workspace.control.scene.rectifyUnitPosition
    ..it kinda works? Right now it's using a simple spiral algorithm, which does
    the job, just not very efficiently..or that well. Doesn't get the closet fit
    either. Needs work. Need to set up a proper testing environment for it.

    developed future to include a correction part..its really inefficient, but
    actually returns better accuracy, and is less jumpy too. Needs more work
    though
  - filled in workspace.control.scene.rectifyUnitPosition to use 
    workspace.library.math.fitPolyIn..which doesn't totally work yet, but we're
    getting there


2019-01-15
  - added "interactable" argument and methods to (all control parts)
      button_rect
      slide
      slidePanel
      rangeSlide,
      checkbox_rect
      dial_continuous
      dial_discrete
      list
      needleOverlay
      grapher_waveWorkspace
      rastorgrid
      sequencer
  - fixed problem with needleOverlay mouse interaction movement being borked
    by commenting out some "/2"s...need to check again how it is on mac (with
    its high density pixel display) and if things are good, remove the
    aforementioned commented out parts.
  - added "interactable" method to units, to allow blanket setting of all
    control parts (except connection nodes)
  - added "interactable" methods to units, to allow blanket setting of all
    IO connection nodes: "allowIOConnections" and "allowIODisconnections"
  - renamed "enableSceneModification" to "enableUnitAdditionRemoval"


2019-01-14
  - removed all shadow related things from core shapes and interface (which is
    everywhere)
  - updated connectionNodes so that one can disactivate mouse-started
    connection and disconnetion (while allowing programmable changes)

  notes
  - need to do this "disable mouse interaction" thing to all control parts, then
    add complimentary functionality to units


2019-01-13
  - fixed menubar scaling

  Compilation Results
  - workspace.js                         1202 Kb  (100%)
  - workspace.min.js                      349 Kb  (29.10%)
  - workspace.min.js (web compressed)     71.4Kb  (5.94%)


2019-01-11
  - updated the readme a little
  - put the test unit back into the interface layer, under a 'test' collection
  - redid the way testing is done, because it was over complicated. Now there's
    just one testing program file, and one html file to run it. No frils.
    The test.js master file in main now only includes the test/main.js file. The
    test files it includes are incharge in including what layers they need and
    starting rendering on their own. It's all a bit cleaner.

  future ideas
  - give parts a method to turn off human interface editability
  - give units a method to turn off human interface editability for individual
    or all parts, as well as a method to stop their own movement or copying etc
    by human interaction


2019-01-10
  - added new layer "5 - curve" which will contain much of what makes the "music
    application" different from anything else one could make from the layers]
    below. The main JS file is now called curve.js (and curve.min.js) and also
    there is workspace.js (and workspace.min.js) which won't have any of the
    code from this 5th layer
  - moved the contents of control's menubar to "5 - curve"
  - moveed all the units into "5 - curve". They're all kinda prticular to what
    curve is about, so it makes some sense. The original unit folders are still
    there, they're just empty now.
  - edited comp.sh and heavyComp.sh alot to reduce their size and amount of
    copy-pasted code
  - redid layout a little. Now there's three .js files to choose from; core, 
    workspace and curve. Each with their own .min.js, and their own .test.js
    All these files are now in a /js folder too. All the corresponding html
    files are still in the /docs folder
      Tests have changed too, they're now named, one for each of the .js files,
    with each of them setup to access different tests.
      The index file is just a copy of curve.html.

  bugs
  - there seems to be an issue with window resizing, when scrollbars are
    allowed. The function core.viewport.refresh/adjustCanvasSize/dimensionAdjust
    appears to adjust the size for when the scrollbars are present, but upon the
    next refresh only remove the horizontal bar's space, leaving an empty space
    on the right side where the vertical scrollbar used to be. The function has
    code to stop itself being run when there are no changes in window size.
    Removing this check allows the system to correct itself. So, the challange
    becomes how can one detect this issue and allow the function to run.


2019-01-09
  - fixed rendering issue with rectangles and images, and the anchor value (it 
    was being calculated fine for extremities, but not for the actual render)

  Compilation Results
  - workspace.js                         1211 Kb  (100%)
  - workspace.min.js                      340 Kb  (28.07%)


2019-01-08
  - fixed comp script to rename the workspace renaming from "core" (which was
    interfering with other definitions of core within core) to "coreGraphics"
  - fixed core.viewport/adjustCanvasSize/dimensionAdjust to add in 'px' when
    dealing with values that aren't percentages
  - added another demo to core.html (plus a little URL way of accessing them)


2019-01-07
  - menubar is not scaled correctly on non-hdp screens. Have added scale
    argument to menubar builder (and to control.gui)
  - updated heavyComp.sh to work better on different systems
  - removed "workspace.system.keyboard.pressedKeys" from structure.js (it
    violated the layered referencing thing. Now the function takes an array of
    "activeKeys" to perform the same job)
  - wrapped main code in encapsulation code, so 'workspace' isn't an accessible
    global anymore
  - added renaming stage for core.js to comp.sh, to rename 'workspace' to 'core'
    ..it's kinda pointless as the variable isn't accessible anyway


2019-01-06
  - moved trash into archive
  - got closure compiler working again, by having heavyComp automatically edit
    workspace.js to change the offending terms (namly "static" and "interface")
    (just two sed commands and a temporary file) Still a warning about
    "Suspicious" though, which I haven't been able to remove
  - added compilation for core.js, and added back in it's html demo

  Compilation Results
  - workspace.js                         1110 Kb  (100%)
  - workspace.min.js                      344 Kb  (31.04%)
  - workspace.min.js (web compressed)    69.4 Kb  (6.24%)


2019-01-03
  - demo location has been fixed
  - canvas experiment
    - fixed player unit's import of audio data
    - fixed oneShot_x not displaying needle position correctly
    - fixed adjustment of needleOverlay selected area
    - fixed problem with double-clicking and clicking on slider on unit (it
      would select the unit instead)(fixed by adding a useless "onmousedown"
      listener to slide. Have done something similar for the rangeSlide. Kinda
      kludgy)
    - can now adjust signal strength on sequencer on mac (the blocks now watch
      for 'command' in addition to control)
    - midi sequencer now has a background pattern that looks like a keyboard
    - fixed sequencer part (where the front interactionPlane wasn't being
      resized during zoom)
    - fixed double clicking slider on oneShot 8 track to reset
    - fixed pressing stop on oneShot 8 track leaving lots of mark behind
    - fixed midi sequencer not stopping signals on loop (things were still named
      "note")
    - fixed synthesizer not applying gui wave type setting on file load (the
      dial_discrete part wasn't running onchange properly)
    - fixed sequencers not remembering view areas (there was no import/export
      for it)
    - fixed "New Scene" not stopping audio (the function only cleared the
      shapes, now it selects all the units and deletes them)
    - fixed connectionNode_data flashing (classic timeout with things changing
      issue)
    - fixed problem with relative_documentUnits and unit connections (the way they were 
      being documented was wrong (and over-complicated))
    - system now stops you from leaving the page with a little alert
    - new demo mode (which currently just skips the leave-page alert)
    - new demo scene made
    - fixed problem with pasting units, and their positions being weird (classic
      case of converting windowPoint to workspacePoint twice)
    - added some master switches
        mouseWheelZoomEnabled
        mouseGripPanningEnabled
        mouseGroupSelect
        enableSceneSave
        enableSceneLoad
        enableMenubar
        enableWindowScrollbarAutomaticRemoval
        enableUnitSelection
        enableSceneModification
    - a few of the shapes didn't have code for adjusting to being staic, so I 
      changed that
        
    - canvas experiment has just become the main version!

    future ideas
    - the ability to stop interaction with cables and units, on a global and 
      case-by-case bases

    bugs
    - it appears that closure is unable to deal with the word "static" as a
      variable, so, looks like I'm going to have to rename some things in core
    - still need to do something for that autoplay policy thing


2019-01-02
  - canvas experiment
    - added code to the 'system' to account for mac keyboards. Now, when the 
      "command" key is pressed (which the browser interprets as "meta") and if
      the program is being run on a mac, a new pressedKey value of "command"
      will be added. Same for "option"
    - updated core.viewport.scale, so that if you set it to zero, it sets to the
      default scale instead
    - striped documenting/printing of units code out of copy/paste and into  
      their own functions under control.scene.
    - added scene export and import methods
    - added file load/save functionality
    - updated all alpha units to accept angle creation arguments

  issues:
  - the 'player' unit, doesn't seem to be exporting/importing audio data
    correctly. One should check the other file players too
  - saving units with audio data is slow


2019-01-01
  - canvas experiment
    - fixed problem in connection node rotation
    - added rudimentary unit rotation (shift and alt)
    - added 'forceMouseLeave' to button_rect, so now the list part doesn't have
      that left-over hovering when you scroll around
    - menubar dropdowns now close when there's a click in the main work area
    - added alt-click-drag to duplicate selection
    - upgraded functionListRunner to allow for the concept of 'or' so now, one
      can select different collections of required keys (previously "special
      keys") that are to be considered valid. A good example in deleting units,
      which can be done with the delete key or the backspace key
    - added keyboard hot keys for cut, copy, paste, duplicate and delete

  
2018-12-28
  - canvas experiment
    - fixed up unit copy/paste code (looking good now)
    - added in plumbing code for unit position rectification
      ( workspace.control.scene.rectifyUnitPosition(unit) )
    - added viewport size adjustment code to control, so now when the window is
      resized, the canvas will be too.
    - created menubar (with automatic width adjustment)(many functions still
      missing actual functionality)
    - disabled text shape derender (as its just not working)


2018-12-27
  - canvas experiment
    - added copy/paste code (needs a rewrite)


2018-12-26
  - canvas experiment
    - added click-and-drag group selection
    - added generic selection glow to all units (based on their space)
    - added update code to the unit builder so that it's personal space will be
      updated on moving it around
    - added 'delete all selected' function to selection control
    - added 'disconnectEverything' function to unit


2018-12-25
  - canvas experiment
    - began work on unit grapple and selection
    - unit movement working


2018-12-23
  - canvas experiment
    - created looper (unborked)
    - created oneShot_single
    - created oneShot_multi
    - created oneShot_multi_multiTrack
    - discovered that window.devicePixelRatio is a thing, and now things are 
      looking a little prettier
    - began work on "4 - Control"


2018-12-20
  - canvas experiment
    - turns out, you don't need to have the image element to draw a canvas onto
      another canvas; so now the canvas shape just direct draws it's internal
      canvas. This has made updaing the shape sooooo much smoother

    - I've decided to make sub-canvas versions of some of the more heavy parts
      in a bid for speed. This actually seems like a great idea, as it will
      reduce the render load on the main renderer (though it does sorta throw 
      away alot of the work done on core (derendering, shapes, etc..))
        I mean.. you don't really need to de-render the elements with a canvas,
      its just an image..it's really up to the part itself if it want's to
      optimise the drawing of itself.
        Core has all this functionality for shapes, hierarchys, derendering,
      viewports and interation and all sorts. The canvas shape is just a
      direct-draw method. Which for things like the grapher or other display 
      parts, is perfect, because they're all about how they look, and nothing 
      about how the user interacts with them...maybe I'm feeling something that 
      isn't there

    - created sevenSegmentDisplay_static
    - created sixteenSegmentDisplay_static
    - created readout_sixteenSegmentDisplay_static
    - updated multibandFilter to use readout_sixteenSegmentDisplay_static
    - marked improvement on performance now. Hovering arond 33fps now. This
      could be the answer to all our fps problems
      
    - updated pulseGenerator and pulseGenerator_hyper to use
      readout_sixteenSegmentDisplay_static
    - another performance boost; up at ~37fps now. Touching 40fps

    - removing the sequencers boosts things to around 43fps, that might be the
      next part to make static

    - shape count: 2292 (~1500 less shapes)

    - created recorder
    - began work on looper (seriously borked)

  notes
    the problem we have is that the main render loop has a lot of shapes to draw
    every cycle, which ofcourse is heavy on the machine. We've solved this with
    the grapher by saying "hay, these shapes don't change all that much; how 
    about I'll handle their particular renderings and you can just render this
    still image on your cycle"
      Which brings the question: maybe all parts could be sub-canvases? Or all
    units? Either way, we can certainly start with the readout part. That seems
    to have the most parts right now.


2018-12-19
  - canvas experiment
    - created grapher_static part (and renamed 'grapher' to grapher_active)
      which uses the new canvas shape to draw graphs. The update is a little
      glitchy-looking; but it works fine and speeds things up wonderfully.
    - slowed down readout_sixteenSegmentDisplay's text scrolling a little bit
    - created player

    I've just noticed that with all these unit's added to the one scene; the
    app is only running at 25fps (50+ is with nothing) This bugs me, as one of
    the main reasons for doing this canvas thing was to make things faster than
    SVG. Research is ongoing
    - shape count: 3781

    .. I think it might just be a overall speed thing :/

    ideas
    - maybe replace those readout displays with a sub-canvas version? There
      seemed to be a bit of a slow down when they entered the viewport. I need
      to improve their refresh however, it's a bit flashy right now.


2018-12-18
  - canvas experiment
    - redid layout
      0 - library
      1 - core
      2 - system
      3 - interface
      4 - control
    - also, renamed 'object' to 'unit', and 'canvas' to 'workspace'
    - pulled circuits out of 'parts' and into its own folder in '3 - interface'
    - did what I could to try and contain references to 'workspace' from within
      part and unit files.
    - compartmented circuits, parts and units into 'alpha' colletions
    - created pulseGenerator_hyper
    - created player (audio playback is pretty bad, and reduces the framerate
      to ~16)

    it appears that having a large waveform in the player slows rendering down
    temendously, so work is needed there to have still images. Even so, 
    removing that factor doesn't improve playback at all
    (possibly a position update feedback problem)

    - It was a position update feedback problem. Waveform image thing should
      still be done though.
    - added canvas shape to core, which is like an image you can use like a
      canvas. With resolution control, and direct access to the standard
      canvas methods.

  ideas
  - grapher needs a 'static' mode; where the graph is drawn to an image, and 
    that image is displayed instead. Only when the graph's "draw" command is 
    run, should the image be updated. This was sortof how it was done on the 
    old system. One would also have to select an image size, to account for 
    zooming around.
  - image shape needs image caching, so that a smaller copy of the image is
    generated when an image is loaded, and this copy is used when the shape
    is being drawn very small. A number of versions could be made in this vain.
    

2018-12-17
  - canvas experiment
    - created filterUnit
    - created reverbUnit
    - created multibandFilter
    - created launchpad
    - fixed problem with rangeSlide, where the onmousedown callback wasn't being
      attached to the invisible handle, but the handle group
    - created basicSequencer
    - created basicSequencer_midiOut (probably a little shakey)

  ideas
  - the cable will need to be able to access the 'space' value of objects, thus
    needs to know that objects are a thing, thus breaking the wall between
    section 3 and 4. My idea is to combine the two.
  - I'm probably going to pull the 'circuits' out of 'parts' too. One could make
    a strong argument for putting them in the library section

  note
  - the compiled file is almost the same size and the old one now. ~12,000 lines
    compared to ~13,000 lines. I imagine that once this transition process is
    complete, it'll be more that the old one.


2018-12-16
  - canvas experiment
    - twas less of a bug, more that I hadn't finished uncommenting everything
    - created distortionUnit


2018-12-15
  - canvas experiment
    - fixed text scaling problem (note: don't use the 'size' parameter again!
      only use the font string to define size)
    - created basicSynthesizer object
    - created audioScope object
    - created audioSink object
    - created audioIn object (audio working)
    - created musicalKeybaord

  bugs
  - musicalKeybaord's velocity dial doesn't effect anything apparently


2018-12-14
  - canvas experiment
    - created universalreadout object


2018-12-13
  - canvas experiment
    - created pulse generator object


2018-12-12
  - canvas experiment
    - wrote up the object builder
    - added 'declare object grapple' code, which has been renamed slightly to
      "canvas.object.builder.objectGrapple.declare"
    - shifting object movment, copying and selection code out into control
    - created test object (test/4 - object/2.js)
    - updated needleOverlay to have mouse interaction (which I guess I left out)
      shift-click for area, regular-click for select
    - created the object collections and the alpha colletion (with just the
      testObject right now)
    - copied all the circuitry parts in
    - created audio_duplicator object
    - created basicMixer object

  future ideas
  - might have to make the conection nodes a little darker


2018-12-11
  - canvas experiment
    - more polishing with the sequencer cursor
    - bug where if you held down both alt and space; an infinite loop would
      occur. Fixed it by not allowing interactionPlane_back.onmousedown to run
      if that was the case.
    - began work on object builder


2018-12-10
  - canvas experiment
    - added signal draw interaction to sequencer
    - added playhead and it's functionality to sequencer
    - added some more signal controls to sequencer
    - expanded system's keyboard functionality so that it now captures
      left/right commands as singular buttons (so, RightAlt and LeftAlt, both 
      activate an 'Alt' key, that can be found in the 'pressedKeys' object)
      This new code also opens the door for key translation (ie. converting 
      input depending on the OS being used)
    - further jiggering of the cursor changes in the sequencer (I think I've
      gotten things right now)

  future ideas
  - a more complex callback passthrough system? Kinda like the functionList way,
    where a callback say decide that the signal can be passed through to shapes
    below it


2018-12-09
  - canvas experiment
    - added second interaction plan to sequencer
    - added delete interaction to sequencer
    - added group selection to sequencer
    
    problems:
    - sequencer interaction is a bit borked (mainly concerning cursors)


2018-12-08
  - added CNAME to docs, so now curve.metasophiea.com is a thing n_n
  - canvas experiment
    - fixed buggy control problem on mac
    - more cursor types for sequencer events


2018-12-07
  - canvas experiment
    - started add cursor types to sequencer events
    - added shape-related callback detection to system


2018-12-05
  - canvas experiment
    - renamed blockRegistry to signalRegistry
    - added in signalRegistry test code (just the noteRegistry test code from
      before)
    - more sequencer work (added in block movement and resize)(which also works
      with multi selected blocks)


2018-12-03
  - canvas experiment
    - work continues on the sequencer
    - added blockRegistry to structures list (in library. Previously this was
      called the noteRegistry)


2018-12-02
  - canvas experiment
    - work begins on the sequencer


2018-12-01
  - canvas experiment
    - finished up on the needleOverlay
    - updated grapher so that one can position the background text in accordance
      with the viewbox values, instead of the grapher width/height itself
    - added the grapher_waveWorkspace (surprisingly short part)

    which ofcourse, now just leaves the beast:

    - parts left to do
        control
        - sequencer


2018-11-30
  - canvas experiment
    - added the ability to change the cursor, in core.viewport
    - still working on this needleOverlay (getting mouse interaction to work)


2018-11-29
  - canvas experiment
    - updated grapher a little to make the drawing of lines more efficient. No
      longer are lines drawn in segments, but the entire line is a single 'path'
      shape. Thus where once there was a thousand little straight paths in the
      group making up the line; now there is a single path.
        Also added back in the functionality to turn background text printing
      on and off, and also access to the text offset
    - added grapher_periodicWave display part
    - added grapher_audioScope display part
    - added 'contains' method to the group shape
    - began on needleOverlay

    - parts left to do
        control
        - needleOverlay
        - grapher_waveWorkspace
        - sequencer

  problems found:
  - if you click-and-drag a slider handle, then release the mouse button over
    the 'backingAndSlot' group of a different slider; that slider will take that
    as an 'onclick' call and subsequently move the handle to that spot.


2018-11-28
  - canvas experiment
    - added clipping functionality too the cirle and polygon shapes (and updated
      rectangle's a little) Text doesn't have a simple way of being added, image
      is just a rectangle and I've just left path out.
    - updated text shape a little, to allow one to set the text size (instead of
      just the font size)
    - wrote up the grapher display part

    - parts left to do
        display
        - grapher_audioScope
        - grapher_periodicWave
        control
        - needleOverlay
        - grapher_waveWorkspace
        - sequencer


2018-11-27
  - canvas experiment (which is now just the canvas future, now that I think
    about it)
    - wrote up the guts of the list control part, though it still doesn't have
      any way of hiding items
    - fixed up button_rect along the way
    - wrote up modifications to the 'group' shape, which allow for clipping.
      It works with other shapes to do the actual job of clipping, and requires
      them to have clipping ability (currently, only rect has this) It also
      doesn't do render-judgement for internally clipped shapes..it seems to
      work though
    - modifications to 'group' shape make hiding quite straight-forward for the
      'list' part
    - little bit of streamlining to group's render function


2018-11-26
  - canvas experiment
    - updated 'getElementUnderPoint' function, to add an argument that allows
      the function to gather every shape that the point touches (as an array)
    - updated core's callbacks, so that if the shape under a point doesn't have
      the callback core's looking for; it will search again and look for the
      next shape that does. (the callback 'onmousemove' seems pretty
      inefficient :/ ) Heavily commented

  continue:
  -> writing up the list shape


2018-11-25
  - canvas experiment
    - connectionNode_signal was kinda shaky, which just lead me to redoing all
      the connection nodes, resulting in the generic connection node from which
      all others are made. Works pretty well too. There's now one for audio,
      data, voltage (a number) and signals (true/false)

  future ideas:
  - tiny thing; stop mouse-wheel when mousedown event occurs? Sometimes when I'm
    on the mac and click-dragging it scrolls around sometimes. It's a little
    annoying.


2018-11-24
  - canvas experiment
    - fixed that weird problem with the button_rect sometimes having an outline
      (something to do with setting the strokeStyle to undefined)
    - finished up on the connectionNode_data (in blue)
    - addded connectionNode_signal (in red)
    - addded connectionNode_audio (in orange)
    - jiggered cable adding about as in the past, shape names weren't mandatory
      as they are in this system. Cables are still added to the
      middle/middleground pane, but now have a name based off their owner's
      address, for example:
      "cable-/root/middleground/middle/dynamic/test_connectionNode_audio2/"

  notes
  - one could argue that the connectionNodes should all be based of some generic
    connection node part thing, but I've already written them now, and it feels
    unlikely that I'll need to make new ones any time soon. Something to do once
    we've fully replaced the SVG version I guess.
    ....the signal version needs a rethink anyway.
  - parts left to do
      display
      - grapher
      - grapher_audioScope
      - grapher_periodicWave
      control 
      - list
      - grapher_waveWorkspace
      - needleOverlay
      - sequencer


2018-11-23
  - canvas experiment
    - button_rect unborked. There's still an odd problem though when you
      position the viewport just right, that an outline appears around the
      backing rectangle.
    - added level, meter_level and half of audio_meter_level (it needs the audio
      library stuff)
    - added 'stopMouseScroll' setting to core's surface, and changed things so
      one has to enable the functionality (which is now done in system/main.js)
    - added rastorGrid
    - added cable, halfway though adding the connectionNode_data


2018-11-22
  - canvas experiment
    - rewrote dial_continuous a bit to be a little nicer
    - added dial_discrete (which now uses the dial_continuous dial as it's base)
    - added button_rect (only a little bit of a mess. The text points calculator
      is still a bit iffy. The style arguments are crazy)(it's borked when
      rotated ):/ )
    - added checkbox_rect
    - added rastorgrid


2018-11-21
  - canvas experiment
    - turns out, 'deep compute' was broken, so that's now fixed
    - improved 'computeExtremities' a little, so that deepCompute-ing a shape,
      doesn't make every shape update all parents (it's kinda complicated, but 
      it works)
    - added rangeslide
    - added getters and setters to shapes, so that they will recalculate their
      extremities (groups do deepCompute) upon any change
    - added dial_continuous (which could do with a rewrite to look a bit more
      like the slider code. Thankfully the construction of the system means
      that poor coding can be easily contained)
      

2018-11-20
  - canvas experiment
    - added onclick and ondblclick to core callbacks
    - expanded mouse.js to iteratie over shape's (and their parent's) listeners
    - fix: group wasn't passing parent angle through correctly
    - created 'system.mouse.mouseInteractionHandler' function, for handling
      mouse interaction that centres around taking over the canvas mousemove
      input while the mouse is down
    - 'slide' part is now fully interactive

  bugs:
  - there's something wrong with how extremities are being calculated..or how
    rendering is being done...it's totally broken, basically


2018-11-19
  - canvas experiment
    - it appears that html canvas doesn't have a way of measuring height, but if
      you define a font's size in 'pt'; that number is the height. So,
      'pointsOfText' now assumes that the font's size is set in this way. With
      that said; this doesn't account for strings with no capitals, or letters
      with hanging portions..from what I understand, they're working on
      expanding the functionality to add ways of gathering this information, but
      it seems a little while off yet. Either way, text is unlikly to be used
      much, in favour of images of text. So I'm going to leave it like it is for
      now.
    - added path shape to core
    - reintegrated core with 'parts', I'm now adding back in all the parts (some
      rewriting necessary)
      - glowbox_rect
      - sevenSegmentDisplay
      - sixteenSegmentDisplay
      - readout_sixteenSegmentDisplay
    - ignored shapes are now a thing
    - static shapes are now a thing


2018-11-15
  - canvas experiment
    - core.js v4.1 ...ok, v5. But this really is the last one. This version
      wraps shape functionality up into the shapes themselves (as opposed to
      that sudo-object way I was doing before) It's cleaner. It also bites the
      bullet and makes a group shape the root arrangement node. Things are 
      pretty nice.
      
      To be implemented:
      - static shapes
      - ignored shapes
      - the text shape's hit box function (it's currently just using the
        rectangle)

      To be Fixed:
      - 'pointsOfText' function in library.math


2018-11-16
  - canvas experiment
    - core.js v4. Last one, I really mean it this time.

  notes
  - looks like we're heading for v4 of core. I need to rework static elements, 
    add in the new extremities calculation methods and add render judgement.
    ..this thing is getting pretty complex. Pretty advanced.


2018-11-15
  - canvas experiment
    - added circle shape
    - added 'library.math.pointsOfCircle' which can return a defined number of
      points of a circle
    - added "pointWithinCustomHitBox" function concept to core element library
      shapes (used within arrangement.getElementUnderPoint) so that calculation
      of whether a piont is within a shape's bounds doesn't have to rely on the
      shapes extremities.points for judgement (which is easy for a rectangle,
      hard for a circle, but frighful for text or any polygon of similar
      complexity)
        Calculation of extremities is still required though, mainly for
      judgement on rendering (and anyting to do with boundingBoxes)


2018-11-14
  - canvas experiment
    - added "append", "prepend" and "remove" methods to group element
    - added image and polygon shapes to core
    - connected new core to system and parts
    - added functionality for touch events to core
    - pulled common 'computeExtremities' code out of elements, and into a core
      function that they can use
    - expanded polygon functionality to deal with more complex connecting lines
      (quite badly though)


2018-11-13
  - canvas experiment
    - started new version of core. This one wraps itself in a ‘surface’ object,
      to cover over any important handles core uses publicly. It also has the
      group element as a plugged-in element and further pushes code out into
      those plugged-in element files. I’m planning on adding “.add” and
      “.remove” methods to the group object
      Hopefully this will be the last version; though the ‘surface’ object helps
      separate the code out more; becoming essentially an interface. Potentially
      making the upgrade to other graphical backends a little smoother.


2018-11-11
  - canvas experiment
    - redid layout
      the idea of the re-layout is to better enforce the concept of levels
      within the code, and of how lower levels shouldn't have code that deals
      with higher concepts (as described a little in 2018-11-10 's log)
        In addition though, I add level 0 "library" which is for code that isn't
      necessarily for any particular level, and could conceivably be used in an
      entirely different project (eg. mathematical functions or a wrapper for
      the browsers audio functions)
 
      Conceptual Layout:
        browser canvas -> core -> system -> parts -> objects -> control
        utility ->
        audio ->
      Actual Layout
        0 - library
            - main.js
            - math.js
            - audio.js
            - structure.js
        1 - core
            - main.js
            - core.js
        2 - system
            - main.js
            - mouse.js
            - keyboard.js
        3 - part
            - main.js
        4 - object
            - main.js
        5 - control
            - main.js

    - added anti-page scrolling option to core
    - started on part.builder
    - developed version 3 of core, which pulls out the drawable shape's code
      out into objects, within a separate 'coreElements' object


2018-11-10
  - canvas experiment
    - added keyboard events

  ideas:
  I'm splitting out some of the functionality that is in the equivalent system
  code chunks in the main version, as I want to create more of a distinction
  between levels of functionality. For example; the "declareKeycaptureObject"
  function should be up with the other object code, instead of down with the
  lower system code.
    Hopefully I can write in a way that will allow one to augment the system
  level code at a later date (thus allowing this separation)


2018-11-09
  - canvas experiment
    - added stat collection back into core (just frame rate right now)


2018-11-08
  - canvas experiment
    - finished work on core2 (which is now just core) fixing some bugs along the
      way) Things are pretty nice now I think


2018-11-07
  - canvas experiment
    - began work on core2 (a second draft of core, which just lays things out a
      little nicer)


2018-11-06
  - canvas experiment
    - static derender adjustment working

    future ideas:
    - core probably needs some renaming and rearranging of handles


2018-11-04
  - canvas experiment
    - renamed element.recompute to element.computeExtremities
    - element.getElementUnderPoint now checks a group's bounding box to see if 
      the point is within it (no longer just checked every element everywhere)
    - rearranged functions into objects
    - added getters/setters to the viewport location values
    - added element names and addressing
    - added the ability to declare an object as to be ignored (thus,
      getElementUnderPoint will not return it, or any of its children)
    - working on static elements, have getElementUnderPoint functioning, general
      rendering working, but derender still thinks they're moving 

    test:
    - my desktop seems quite happy to draw 10,000 rects. 20,000 slows things to
      ~27 fps
    
    future ideas:
    - the ability to set groups as immune to the viewport location values


2018-11-03
  - canvas experiment
    - fixed up canvas.system.core.element.recompute


2018-11-01
  - canvas experiment
    - expanded element.recompute to create bounding boxes for groups
    - expanded element.recompute to add parent elements to element (if parent is
      undefined, it means that this element is at the top of the tree, making
      the parent the arrangement)
    - added element.getPerent and element.getChildren functions
    - added element.getArrangement function
    - added add and remove functions (which now perform the element.recompute
      function when elements are added or removed, instead of the render
      function)
    - replaced context.translate in element.draw.rect with custom a function for
      performing the same task. Things are a bit faster now
    - no-render judgement moved so now it's the first thing that happens when 
      any element is rendered
    - began work on new element.recompute code. Going well but needs testing

  findings
  - the framerate is usually around 50fps on my laptop, but drops to 30 or so
    when I add 10,000 elements to the scene... I'm not sure if this will be a
    problem or not. Upon inspection; we're spending alot of time 'translating'
    the canvas. Perhaps the development of a drawing method that does not
    require this function is in order. Luckily, doing so won't effect the
    operation of the rest of the system in any way.
              - removes context.translate from element.draw.rect -
    things are faster now, sitting at around 47 when adding 10,000 elements.
    More work still needed (perhaps replacing the internals of rect with calls
    to poly? No canvas rotation needed that way)
              - tests with lots of polys -
    30fps. No translate there to remove either. Tell you what though; 10,000 
    polys off screen (and thus not being rendered)? ~52fps

  bugs
  - element.recompute isn't recomputing individual elements correctly
    (currently, one needs to compute from the arrangement) Need to expand it so
    that it goes up through the tree collecting x, y and angle offsets; returns
    with these calculated then computes all the lower elements
    (adding lots of elememts is quite slow)


2018-10-31
  - canvas experiment
    - rearranged the functions a little
    - renamed 'zoom' to 'scale' because it was bugging me
    - added rendered element getters/setters (none functional)
    - added element bounding box and points computer (stripping out this
      functionality from the 'renderElement' function)(in future, this function 
      will only be run when edits are made to the element arrangement list
      itself (and even then, only the elements that have been changed), instead
      of in every render loop)


2018-10-30
  : yesterday and today; I've been working on a canvas-only version of workspace
    It's currently only in the experiment area, but things are going well.
    Currently; I have what I'm calling the 'core' of the rendering system mostly
    down, which basically equates to the SVG system of the current main version,
    and bits of the "system".
    Development is ongoing, and I hope to incorporate much of the code that is 
    already created; though this is essentially an overhaul of the entire app,
    so, development won't be super quick. Could potentially allow for future
    graphical acceleration changes to be made in future though

    canvas version currently has:
    - core rendering object attached to canvas using 'animation frame' 
      rendering
    - rect, poly, image and dot elements; along with a 'group' element for
      grouping (what a coincidence)
    - image data caching
    - canvas element section from XY position
    - automatic canvas sizing (using custom html element attributes)
    - 'unseen' element non-rendering
    - some stat collection on canvas performance (currently just frame rate)
    - element grouping object, which contains all shapes to be rendered
    - mouse interface (missing a lot of functionality however)
    - panning and zooming (functional when angled too)
  
    currently works on chrome, firefox and safari


2018-10-18
  - split utility up into it's own little folder of code


2018-10-14
  - added super switch to disable object clipping (which is now disabled by
    default)
  - worked on shortening and tightening the system.mouse code
  - worked on shortening and tightening the system.keyboard code
  - fixed issue where the key 'V' wasn't being raised after a ctrl-V, as the OS
    was capturing it and taking focus from the window. Fixed by adding 
    "system.keyboard.releaseKey('KeyV');" into control's paste code
  - redid copy/paste code to use keys instead of that weird numbering system

  bugs found
  - pasting not working perfectly (don't seem to paste groups of objects in the
    right place (all to the right and below the pointer))

  future ideas
  - probably need to remove my usage of "system.svgElement" for storing
    temporary data

  Compilation Results
  - workspace.js                        885 Kb  (100%)
  - workspace.min.js                    290 Kb  (32.8%)


2018-10-07
  - menubar resizes when the window does
  - added object clipping (it's rather clunky, groups that move together too
    quickly will bounce off eachother and there's no sliding along object's 
    sides.... but it works. There's also a new design option to turn off
    clipping (that's accessible from the object instance aswel))


2018-10-06
  - removed gif
  - prefixed all the alpha objects with 'alpha'
  - fixed up loading / saving a scene
  - fixed "new scene" (clearing objects wasn't being done right)

  things to look into
  - system.utility.workspace.clear is now stuck on removing objects from the 
    middleground
  - adjusting the window should change the menubar size


2018-10-05
  - renamed "parts" to "part"
  - renamed "objects" to "object"
  - shifted 'elementMaker' into parts section, with the new name "builder"
    (system.utility.misc.elementMaker -> part.builder)
  - shifted 'objectBuilder' into objects section, with the new name "builder"
    (system.utility.misc.elementMaker -> object.builder)
  - renamed part.circuits to part.circuit
  - renamed part.elements to part.element

  future ideas
  - view controls in menubar (reset mainly)

2018-10-04
  - major upheaval to project structure
      we have only four global variables;
        system
        parts
        objects
        control
      which in turn, follow the dependencies track (and folder names)
      Perhaps folders could be rearranged aswel, to keep these four sections in 
      a section to themselves (and just for a general reorganisation):

    - renamed '__globals' to 'system'
    - renamed 'mouseInteraction' to 'mouse'
    - renamed 'keyboardInteraction' to 'keyboard'
    - redid folder layout:
        compilation/
          closure-compiler.jar
          gravity
          notes
          comp
          heavyComp
        docs/
          demos/      help/
          gifs/       notes/
          404.html    workspace.js
          index.html  workspace.min.js
          test.html   workspaceTest.js        
        main/
          control/
          objects/
          parts/
          system/
          main.js
          testMain.js
        trash/
        workshop/
          0 - experiment area/
          1 - system testing/
          2 - part|object development/
            elements testing/
            sequencer/
          3 - object finishing/
        README.md
  - rewrote the 'structure' section of the readme
  - rearranged the files within 'objects' (in a way that doesn't matter to the
    system, so, could be put in any way really, and this way isn't that great
    as it is)

  future ideas
  - just redo system.pane

  bugs
  - bugs everywhere. The change was slightly poorly done, so things are broken
    due to renaming of other things. Tests are passing however

  Compilation Results
  - workspace.js                        870 Kb  (100%)
  - workspace.min.js                    292 Kb  (33.63%)


2018-10-03
  - list breaks and spaces, a little more stable now
  - create menu is now sorted
  - group select works again
  - menubar has edit items now (that "bug" from yesterday was actually just me
    being silly (turns out; if you don't program it to do anything, it won't do
    anything))
  - button_rect now has 'text from centre' (which is the default for 'text')
  - fixed tiny thing in musical_keyboard
  - fixed issue with players where 'fire' connections were only pushing the
    'fire' buttons, and not releasing them
  - put safety on the 'new scene' menubar function, so now an alert pops up that
    you have to press "ok" on
  - shifted alot of code from 'keyboardInteraction' to 'control' (mainly scene
    effecting controls, like cut, copy and paste)(left things commented out,
    because this feels a little risky)
  - 'control' now holds the scene name
  - saveload.load now has a callback for when the load is complete, providing
    it with the metadata


2018-10-02
  - updated menubar dropdown colouring to match the menubar 
  - removed button_rect and button_rect_2, and changed the name of button_rect_3
    to button_rect (so, clean replacement)
  - clicking anywhere while a dropdown is open, closes the dropdown
  - renamed 'menu' to 'control' (need better names)
  - consolidating control and it's pane (I'm giving myself all sorts of ideas
    with this one)
  - fixed musicalkeyboard's release and midiIn problems
  - removed key_rect
  - button_rect now has 'text from left' and 'text from right' arguments (though
    you can still use just 'text' to mean 'text from left')
  - swapped save=ctrl-f2 and load=ctrl-f3, so it's now save=ctrl-f3 and 
    load=ctrl-f2
  - added 'breaks' and 'spaces' to lists (little wonky)

  

2018-09-30
  - all current objects have had their key_rect and button_rect elements switch
    to button_rect_3
  - button_rect_3 now has that key-rolling thing working (broke menubar in the
    process)
  - fixed menubar
  - added "New Scene" function to clear the scene (no safety on that, so be
    careful)

  Compilation Results
  - workspace.js                        877 Kb  (100%)
  - workspace.min.js                    301 Kb  (34.37%)



2018-09-29
  - button_rect_3 now has 'pressable' option, which determines if the graphics
    should change when the button is pressed
  - button_rect_3 handles selection of itself now (click to toggle)
  - created new version of the list control element, replacing the old
  - updated menubar to have better drop-down lists, with all the functionality
    currently available


2018-09-18
  - fixed bug where one could drag the menu bar around


2018-09-16
  - developed button_rect_3 which replaces list.item (now with 'active' setting)
  - all sorts of giffing

  future ideas
  - object collision
	
  to do
  - replace all button_rect and key_rect parts with button_rect_3
  - add text edit control to button_rect_3
  

2018-09-15
  - updated README to point to this log
  - object view reordering, now is aware of what pane it's working on, and can
    rearrange objects within their panes
  - the utility 'disconnectEverything' is back and looking good
  - new utility 'deleteObject' which is well named
  - the two additions above replace most of the code that was in
    __globals.selection.delete
  - wrote up the list part (and it's sub-part, the list.item)(complete with 
    scrollability, selection of items, glowing, range selection (with shift)
    adding items, removing items and all sorts of styling options)
  - created rudimentary object creation menu panel (with automatic object list
    population, a 'close' button and header grapple thing)(needs a way of 
    opening it once it's been closed..maybe a key combo?)
  - 'help button' changed from "ctrl+f1" to just F1, also added
    '__globals.keyboardInteraction.releaseAll' to keyboardInteraction.js
  - added object metadata code for better help url listing and object "Screen 
    Names" to all objects
  - began working on button_rect replacement (currently button_rect_2) based
    off list.item
  - added 'menu bar' which sits at the top of the window. There's one 'objects'
    button which calls forth the object creation menu panel thing (the menu 
    pane has the object reordering like other frames, but it makes it possible
    to trap the panel behind the bar. I'd like to limit how high you can drag
    the panel (like on a desktop), load and save buttons and a little report
    thing in the top right (I'm having trouble getting the HTML to update while
    around load/save operations)

  check out for problems with
  - pressing the button for loading an audio file, then hitting cancel and 
    trying to work with the object again
	
  Compilation Results
  - workspace.js        864 Kb  (100%)
  - workspace.min.js    296 Kb  (34.30%)

2018-09-08
  - equaliser levels fixed (along with that update problem)
  - multiband filter v2 now has a more advanced frequency response updater (it 
    tries no not do recalculations when it's not necessary)
  - multiband filter v2 creation has option to select between having high/low
    pass filters for the highest and lowest bands ("frames"), or just band 
    passes everywhere
  - multiband filter (object and circuit) pushed to main objects and circuits
    lists (removed the 'v2')
  - selecting an object now pulls it to the front of the view order

  bugs found
  - looper symbol isn't allowing mouse clicks through

  future ideas
  - drop shadows

  Compilation Results
  - workspace.js                        825 Kb  (100%)
  - workspace.min.js                    281 Kb  (34.15%)

2018-09-01
  - further work on the equaliser, things are going well; it's got a nicer
    object with colour coded channels, manually selected channel frequencies
    and a master out (still working on getting the 'zero' levels correct)

  future ideas
  - slide panel spacing argument, handle width, slot width

2018-08-31
  - fixed demo 1
  - more work on the super adjustable equaliser (weird thing where auto setting 
    values isn't pushing the changes through to the actual filter circuit. Also 
    the frequency spread is nice, but for a human it's kinda silly)

  bug found
  - it seems the BiquadFilter's "getFrequencyResponse" method doesn't always
    work. Sometimes it just returns an array of just zeros.

2018-08-19
  - pushed the new filter to the main objects list
  - fixed some backwards logic in the sequencer
  - added glow options to the dials
  - began work on the super adjustable equaliser
  

2018-08-15
  - added 'relativeDistance' and 'lineCorrecter' to utility.math (added some
    tests)
  - redid graphers (pulled some of the functionality out into utility)


2018-08-14
  - (you're going to have to fix the viewbox thing in graphSVG (and probably 
    grapherCanvas too))
  - developed the grapherSVG and filter object further. Filter now has a freq 
    range of 0 to 20000, and the graph is logarithmic. Needs more detail though.
    (Grapher part needs development overall)

  future ideas
  - the filter object's dials should glow and dim when they become active and
    inactive

  Compilation Results
  - workspace.js                        783 Kb  (100%)
  - workspace.min.js                    265 Kb  (33.83%)
  - workspace.min.js (web compressed)   94.4 Kb (12%)

  (there seems to be a nice consistency of removing 2/3 of the original size)


2018-08-13
  - tried rewriting the sequencer in canvas, but it's way way too slow. The fix
    I made for the canvas in foreignObject bug thing, causes hugh lag when the
    pixels are transferred into the image. I think that things will get much
    faster when the bug is fixed in Chrome. Until then...
  - updated how things are done in the sequencer and in the get and set
    transform utilities, which seems to have sped things up a bit..its still not
    enough though. Alot of time is being spent on recalculation and rendering,
    so that canvas equivalent is becoming a requirement :/
  - fixed grapherSVG to do background lines and text better (no drawing outside
    the box (mostly), more control of what the text is)


2018-08-09
  issues:
  - sequencer is very slow when alot of notes are added. Panning is fine, global
    panning is fine; but zooming causes huge lag. Removing the background 
    doesn't help, it seems most time is spent recalculating the size of the 
    note blocks. I'm not sure that converting it to canvas would help.


2018-08-08
  - corrected small thing in noteRegistry where a judgement was being done when
    'rightLimit' was set to -1. Fixed so that the judgement is ignored in this
    case
  - 'generateSelectionArea' was using 'temp' as a global instead of a local.
    Changed that
  - working on midi import; the direct conversion to noteRegistry seems to work
    pretty well. I'll have to rewrite the sequencer object though.
  - updated 'basicSequencer_midiOut' object to deal with midi numbers better.
    Also added a viewArea attribute to the import/export functions. Also added
    Vertical zoom/scroll rangeslide
  - updated demo 2 to use new midi sequencer better
    

2018-08-07
  - further experimentation with parsing midi files


2018-08-06
  - updated utility.misc.openFile to have an argument for "readAsType". One can 
    select between 'readAsBinaryString' (the default) and 'readAsArrayBuffer'


2018-08-03
  - rejiggered the system testing folder a little 
  - added 'blendColours' and 'multiBlendColours' to utility.misc (also added 
    tests for them)
  - added colour change effects to the sequencer note blocks (depending on their
    strength)
  - click-control dragging on sequencer note blocks changes their strength
  - did up the colours on the sequencer note blocks
  - sequencer note blocks now ignore mouse clicks when spacebar is pressed (
    redirecting to the interaction pane)
  - sequencer note blocks now have a minimum length (so that they don't just
    disappear when their length is zero)
  - changed "double click on sequencer note block body" from 'delete' to 'reset
    strength to default' (also added a default strength variable)

  Compilation Results
  - workspace.js                        768 Kb  (100%)
  - workspace.min.js                    261 Kb  (34.04%)
    (almost a megabyte on the raw version. Crazy crazy crazy. ~12,000 lines)

  bug update
  - things from yesterday continues; seems to also happen in the "elements test"
    test situation, but only sometimes.

  future ideas
  - need to look into better filters, which puts us on route for more advanced
    synthesizers


2018-08-02
  - added zooming method to the new sequencer (its a 'select view area' thing)
  - pushed updated sequencer, and did-up the sequencer objects (it now has a
    second rangeslide just for moving around and zooming, and a check box that
    when checked will try to keep the playhead in view by moving the rangeslide
    (ish..it's moves the view then tells the rangeslide ot move))

  bug found
  - seems that sometimes, the sequencer's viewport clip-path is not cutting
    correctly, resulting in the notes and backing and such leaking out the left
    side, and leaving a little black line on the right. It's recreatable
    currently in the second demo on the top two sequencers, but not the bottom
    one. The bottom one is the same object as the middle. Even copying the
    objects preserves the glitch in the new objects. Recreating the scene isn't
    helping. I can't find anything different between the objects in the elements
    listing.
      One can manually change the clip-path from
    polygon(0px 0px, 0px 170px, 780px 170px, 780px 0px)
    to
    polygon(1.5px 0px, 781.5px 0px, 781.5px 170px, 1.5px 170px) which will fix
    things, but ofcourse, using the objects view adjust undoes all this. It 
    appears as though the clip-path itself is misaligned by 1.5px to the left.
    Shifting the element that contains this attribute doesn't help, it just the
    problem with it.
                    As it is; I've no idea what is causing this.



2018-08-01
  - updated keyboard interaction further; so that it now checks every element
    for an event handler.
  - finishing up on the unlimited-length sequencer (delete/backspace key to
    erase, now with kinda-sorta zoom functionality)
  - pushed the new sequencer, replacing old one (the change seems to havae gone
    well, though it seems the right side of the loop is missing in demo 2...
    curious. Stranger still; one of the three objects is fine, and it has the
    same sequencer dimensions as another ):/ )

  future ideas
  - package workspace up into a proper little package thing. Currently there's
    three globals '__globals', 'parts' and 'objects' Which causes problems when
    one tried to have multiple workspace elements in a page (though frankly, the
    system was never designed to have multiple instances of itself)
      One could use the old Presenter idea, and bundle things up into the main 
    SVG element. I'm also thinking about expanding the production line, so that
    there's 'stable' versions and 'dev' versions, instead of hoping that my
    updates don't break the demos.

      With a cursory test, it's clear that two or more workspace elements won't
    work, the way things are now. Moreover, the sealing I tried ages ago and
    commented out for 'dev' purposes, also breaks things when uncommented, when
    there's two or more instances. It seems to work alright when there's only
    one.


2018-07-31
  - updated keyboard interaction to allow for individual elements to accept key
    events. It currently prioritizes object input over individual elements,
    though I could change that if necessary.
  - further work on the unlimited-length sequencer (there's panning now, and you
    can create notes)


2018-07-30
  - started into unlimited-length sequencer
  
  future ideas
  - slide: click to empty area then drag


2018-07-28
  - fixed rageslide


2018-07-27
  - added 'staticBackground' pane to very back of hmtl structure, plus a
    'setStaticBackgroundStyle' utility which creates a 100% rect in it. Thus,
    you can now set the background with a solid colour


2018-07-26
  - the viewport position is now saved in a save file
  - scene loading now runs the clear command to wash out the previous scene
  - during saving and loading a scene, master volume is set to zero (to stop
    hanging notes ringing out as the machine is busy)
  - added super global interaction switches /enable/disable mouse wheel zoom
    "mouseWheelZoomEnabled", mouseGripPanningEnabled" and "readOnlyMode"
  - started on a help site for the basicSynthesizer, using a windowed version of
    workspace (group select doesn't work (the mouse point is off) but I disable
    that anyway)

  future ideas
  - some kind of function that can fill the background with a solid colour
  - better windowed mouse selection


2018-07-25
  - 'tester' can now compare function code
  - importScene/exportScene now uses a slightly more efficient way of storing 
    constructor functions in file (and the option to not store them at all)
  - got a compression library (first thirdparty code) for saveload.serialize
    (it's in tests still, but currently we're getting 61.7% removed)
  - all kinds of funky new functionality added to utility (along with a little
    rearranging)(is utility getting too big? ~1600 lines..it's just a collection
    of functions...)
  - saveload has been completely moved to utility.workspace
  - added the ability to load scenes from files from the internet (should
    simplify demos alot)

  future ideas
  - have the ability to adjust master volume, independent of any object. Shut
    sound off during a save or load operation (where the machine will hang from
    all the processing) 


2018-07-24
  - more work on saving and loading (moved the file into a test area)(also tests
    are being made)(also removed some things from utility, that were put there
    yesterday related to all this) going pretty well though

  future ideas
  - add string compression to saveload.serialize


2018-07-23
  - added "saveData" and "loadData" to utility
  - began work on a way to save scenes (the 'saveload.js' system file)


2018-07-22
  - created new 'basicSequencer_midiOut' object, which is like a sequencer, but
    outputs midi commands
  - fixed bug where sequencer playhead wasn't being accessed properly, thus was
    causing problems when multiple sequencers were in a scene. Just had to
    change 'playheadPosition' to use 'obj.children.playhead' instead of just
    'playhead' for the 'setTransform_XYonly'
  - added interface methods to basicSynthesizer object
  - redid demo 2 to have drum and bass sections (and a chord section that is
    left disconnected)
  - cleaned up notes file into notes folder
  - fixed bug in 'sequencer.noteRegistry' where the updating of note positions
    wasn't being dealt with properly and things were ending up off the side. The
    logic has been re-written to be better now (new tests for it too)
  - added help/save/load function keys (F1, F2 and F3)
  - began help folder, which can be linked to from the app by pressing F1 ove an
    object

  Compilation Results
  - workspace.js                        688 Kb  (100%)
  - workspace.min.js                    242 Kb  (35.25%)
  - workspace.min.js (web compressed)   47.3 Kb (6.8%)


2018-07-20
  - pushed pianoroll part into main parts (now called sequencer)
  - shipped all the sequencer testing code over into testSituation 1, and then
    redid the testing code that was already there to use the snazzy new test
    checker function thing (it all looks very nice now)
  - wrote together a nice new basic sequencer object (and pushed it)
  - updated oneShot_multi_multiTrack to accept 'pulse' and 'hit' data signals
  - removed 'trash folder' (have it saved elsewhere for now, but will probably 
    delete fully later)

  bugs found
  - rangeslide handle movement is a bit weird

  Compilation Results
  - workspace.js                        733 Kb (100%)
  - workspace.min.js                    254 Kb (34.76%)
  - workspace.min.js (web compressed)  49.6 Kb (6.76%)
  


2018-07-19
  - continued work on pianoroll, slowly adding features back in, in a nice way 


2018-07-18
  - added code that checks the URL for a dev parameter. If it is present, the
    page unload code won't be activated
  - started on the next version of the pianoroll part..starting with testing the
    sub parts


2018-07-17
  - wrote up rudimentary 8 channel audio mixer and channelMultiplier part (both
    pushed)
  - fixed musical keyboard cloner, which was trying to make a launchpad


2018-07-16
  - added code to stand in the way of a page unload (just the standard "are you 
    sure" box that comes built in with the browser)(commented out for dev 
    purposes. It's (currently) the first line in system/misc.js)
  - added workspace.mouseInteractionHandler to utility (so now hopefully we
    don't have another one of those rangeslide incidents)(perhaps change
    everything to use this?)
  - added velocity interface to musicalkeybaord
  - updated rangeslide so that the values are stored only as 'start' and 'end'
    (instead of having mixed in array indexes)
  - changed some of the pianoroll interaction, to make mousing around easier

  future ideas
  - adjustable keyboard mapping (when switching between mac or linux or windows)


2018-07-15
  - updated pianoroll a little to make it easier to change the x count
  - wrote different music into demo 2 and added reverb
  - added bits of interface to the reverb object
  - fixed rangeslide which had sloppy mouse-move code, which would replace the 
    main system's mouse interaction code and never put it back


2018-07-13
  - pianoroll inner workings improved; now it keeps track of what notes are
    playing. So when it's progression loops; it will insert the ends of those 
    notes into the loop-start events. In effect; stopping notes that have end
    events which are outside the loop from sounding forever. It also means I can
    get rid off all that silly -1/100000 stuff, so things are sounding better
  - key_rect callbacks 'onkeydown' and 'onkeyup' renamed to 'keydown' and 
    'keyup', as the previous names were clashing with the keyboardInteraction 
    system (this could be a wider problem, but probably only for this part (due
    to it's name))
  - fixed detectOverlap again; turns out the order that the boundingBox points
    are in is very important. I've added sortation code, but have also tried to
    make it so code that provides bounding boxes, always puts the higher-valued
    point at the start of the array (the 'left/right'/'top/bottom' metaphor and
    naming scheme I used is pretty mangled now)
  - rushed pianoroll part and object through so that I could put together demo 2
    The way things are, one can continue to develop those items without
    affecting the demo, thus the demo can be updated at a leisurely pace.

                * Workspace (unminified) surpasses 10,000 lines *

  future ideas
  - slide needs to be rewritten. It's just old and rangeslide does things in a 
    nicer way
  - audio mixer

  Compilation Results
  - workspace.js                        655 Kb  (100%)
  - workspace.min.js                    231 Kb  ( 35%)
  - workspace.min.js (web compressed)    46 Kb  (  7%)


2018-07-12
  - added argument to the audio_in object and part, to make it not instantly try
    to connect when it's created
  - wrote up data-duplicator and pushed it into the 'finished' objects pile


2018-07-11
  - fixed the bug from yesterday; turned out, the number conversion is normal,
    and it was my own 'getTransform' code that was not reading the produced 
    style string correctly. I redid the regex, things seem to be working better
    now (though it all seems a little inefficient)
  - fixed smoothSet in rangeselector to actually work properly now (and get the
    timings right)
  - pushed rageslide to main parts
  - replaced both slide in the pianoroll object with the new rangeslide


2018-07-10
  - wrote up rangeselector part (which allows one to select a range on a
    slide-like area. Comes complete with handles that bump off eachother, area
    panning and expand/shrink mouse wheel)
  
  bug found
  - __globals.utility.element.setTransform setting very small numbers 
    (eg. 0.000097500000000) causes something somewhere to convert them to 
    exponent notation (9.75e-05) which breaks the style string


2018-07-09
  - in light of the ctrl key not working on Mac, and the Meta key not working on
    linux; I've created a "super globals" file which controls what key to watch
    in an event. Hopefully this means the system can adjust depending on the
    host
  - faffed with the pianoroll a bit more, and managed to cobble together a 
    basic "advanced launchpad" playing the guitar riff off Thunder Struck. Works
    pretty alright too.
  - added sorting section to the 'eventsBetween' function of the 'noteRegistry'
    as there was a problem where notes that started and ended within the
    selected range, weren't having their events performed in the correct order
  - added way of selecting the looped region in the pianoroll object..it's a bit
    terrible, but it works. I probably need to write a new control object for it


2018-07-08
  Compilation Results
  - workspace.js                        572 Kb   (100%)
  - workspace.min.js                    200 Kb   ( 34.96%)
  - workspace.min.js (web compressed)   38.8 Kb  (  5.78%)




2018-07-06
  - fifth rewrite on the pianoroll, things are going pretty well this time. The
    'noteBlock' element has gotten an upgrade and the mouse interaction is being
    made a little nicer. So far there's alt-click to add, click-n-drag, 
    shift-click-n-drag to group select, click anyway to deselect, alt-drag to
    clone, right and left handle drag to lengthen, and all that springy
    boundaries thing. Still playing with the interaction logic of it all till it
    feels natural.
  - fixed duplicate events problem in noteRegistry


2018-07-05
  - another draft started of the pianoroll (4) this time I'm trying to split
    more of the functionality into the block elements..we'll see how it goes


2018-07-04
  - re-wrote the pianoroll.noteRegistry for better storage and retrival
  - created rudimentary playback for pianoroll (seems to work rather well,
    there's no needle yet however)


2018-07-03
  - multi-delete note blocks in the piano roll editor
  - fixed problem in detectOverlap bounding box judgement (which just didn't 
    work)
  - click-n-drag group selection note blocks in the piano roll editor


2018-07-02
  - single block ctrl-drag duplication on the piano-roll editor
  - multi-block select, movement and length adjust
  - multi-block alt-drag duplication on the piano-roll editor (changed from 
    ctrl-drag)


2018-07-01
  - piano roll editor now uses the noteRegistry more vigorously, allowing it to
    set limitations such as maximum note length and maximum limit to an event on
    the right. Also added method that can return notes who have events between
    two defined times


2018-06-29
  - further development into the piano roll editor (which is starting life as an
    advanced launchpad)
    future development ideas
    - ctrl-drag to clone
    - ability to select groups of notes (and move around/clone)
    - shift-drag empty space to select area
    - shift/alt-drag used space to adjust velocity (and colour)
    - playfield that goes off the slides (zooming, panning, etc)


2018-06-28
  - fixed synthesizer octave adjust which wasn't doing anything (I'd changed the
    '__globals.audio.num2freq' argument list)
  - the basicSynthesizer and audio_duplicator have interesting backings. They]
    create the regular backing, bet set it's alpha colour to 0, then create a
    new shape with the same points to act as a backing with the desired colour. 
    This allows for the connection nodes to sit under the shape, thus saving on
    all that precise point placement.
  - began work on the piano roll editor


2018-06-27
  - fixed that launchpad sequence data duplication copy bug thing
  - added closure-compiler to build chain, creating a 'heavyComp' command along
    the way (to differentiate between the dev 'comp' command) 'heavyComp' runs 
    gravity on only 'main.js' (and can detect if an error occurs stopping the
    script if so) and produces 'workspace.js'. This file is given to the closure
    compiler, which produces 'workspace.min.js'
  - closure managed to find two places where things weren't written right; good
    job closure. (one where i was setting a value to null, then attempting to 
    delete that value; another where i was producing a string to print as a
    warning, but had never actually put that string in a printing function)
  - heavyComp now has a handy little report on the reduction performance
  - added sync button and connection node to pulseGenerator
  - created a musicalkeybaord object
  - fixed non-functional panic button in the basicSynthesizer
  - added musicalkeybaord object to 'finished objects' area
  - fixed universalreadout to interpret the 'data' segment a bit nicer (by
    converting things to JSON)


2018-06-26
  - updated oneShot_multi circuit to have a panic and playback rate features
  - added rate slider and panic button to oneShot_multi object
  - added rate slider and panic button to oneShot_multi_multiTrack object (also
    changed the 'dynamic design' section to use closures in functions instead of
    parsing the IDs of their parents)
  - accidentally left is possible to set the playback to 0 in the oneShot_multi
    circuit (which the browser did not like) the minimum is now set at 1/1000000
  - loadURL interface added to the oneShot_multi object (these interfaces should
    save time when doing scripted jobs)
  - some more interface work on oneShot_multi_multiTrack and the pulse generator
  - reworded demo 1 a little bit, what with all these interface changes
  - updated demo 1 again, now including riffs from the old party calculator app
    and extra launchpads

  bug found
  - copying launchpads duplicates the internal sequence data, but doesn't copy 
    it


2018-06-25
  - added light feature to the multitrack and single track multishot audio file
    players
  - also added the ability to select a region to use within the audio track
  - forgot to hook up the fdail in the reverb object

  bug update: I'm really not sure of how to fix this missing playhead thing..
              it really seems like a processing issue; if you step through the
              program manually, everything is set..It seems to work fine
              sometimes and not others..I think I'll leave it for now. I've
              added lights to the multi track object anyway.

  future ideas
  - multi track multi shot thing, should have a panic button
  - zoom features on waveWorkspaces


2018-06-23
  - updated demo1 to have sound and sequencing
  - launchpad object importData method updated to deal with missing values
    (something that should be done everywhere probably)
  - oneShot_multi circuit load method callback protected against missing 
    function
  - launchpad circuit now runs the pageChange callback after importPage or 
    importPages


2018-06-22
  - added symbols to the rest of the audio file players
  - pushed the audio players and circuits to the 'finished' folder
  - pushed audio recorder and circuit to the 'finished' folder
  - created and added a universalreadout and launchpad to the 'finished' folder
    ('launchpad' has been split up into the object and internal circuitry, in
    turn creating a parts.circuits.sequencing area, and 
    parts.circuits.sequencing.launchpad circuit (which probably needs a rename))
    (also the universal readout doesn't print to the console, but to some text
    in the viewport)
  - created and added a pulse generator
  - did import/export code for the launchpad
  - redid the comp command, so now there's two files produced; a 'test' edition
    that's the same as the old one, and a 'regular' one that has none of the test
    situation code. In this way I can now test and develop like normal, while
    having demo pages that are unaffected. Both still don't have the wrapping
    enabled, so, there's work to be done still.
  - created demo file of the multi-track audio file player hooked into a 
    launchpad and pulse generator..still needs audio files ofcourse

  bug found
  - odd bug in audio file player looper, where hitting the play button
    repeatedly would always restart the audio, but sometimes the play head would
    disappear. Seems to be caused by the style of the needle not being set in 
    time before the request to move the needle to the other side of the viewbox
    occurs (the style has a transition setting). The commands are being 
    performed in the correct order..it might be the browser not computing the
    style in time


2018-06-21
  - updated continuous dial callbacks to be wrapped in try/catch blocks
  - redid the distortion unit and moved it to the developed objects folder
  - jumped ahead and reorganised all the parts into 'elements' and 'circuits'. 
    Have to rewrite alot of stuff to use the elementMaker now
  - pushed distortion, reverb and filter into the "finished" objects area
  - added symbols to some of the audio file players

  future ideas
  - splitting up 'parts' into 'elements' and 'circuitry', where 'elements' are
    the graphical parts that a user would interact with (slides, dials, button,
    graphs, labels, lights, etc) and 'circuitry' are parts of pure code that do
    work (like distortion units and data processors)
      Right now, 'parts' is almost entirely 'elements', so I'll wait till the 
    circuitry parts come out of development more. I'd have to rewrite the 
    element maker..though it's name and function is already correct


2018-06-20
  - created a rudimentary multi-track oneShot file player object. The idea is
    that one could load up drum beats, hook that into a launchpad or some pulse
    generator, and have it perform drum beats for you
  - added math.normalizeStretchArray to utilities (and fixed it up along the 
    way)
  - added math.curvePoint functions to utility, and fixed up other aspects of 
    curve generation
  - updated smoothSet in the slider and continuous dial parts, in a bid to make
    them more efficient and time conscious..I think it's worked
  - started on revamping the testSituations folder

  future ideas
  - continue with 'testSituations' do-over, while updating partially developed
    objects, and pushing them to the main list


2018-06-18
  - wrote up a recorder object (with state lights and time readout)(the controls
    are honestly a little more clunkly that I'd like, but it works)


2018-06-15
  - added 'export' functionality into recorder2 (in prep for the audio disk)
  - little bit of development on audio disks (which I'm going to shelve for now)


2018-06-14
  future ideas
  - audio disks (that you can move in and out of audio recording devices and
    playback devices, etc)(they'd be a simple object that just contained one
    audio-encoded blob)


2018-06-13
  - developed audio recording object and circuitry to include pause/resume
    functionality, along with the ability to get the recording length at any 
    time. I've also simplified the input/output audio nodes somewhat. The 
    object is pretty sparse at current however.
  - worked on simplifying audio channels; turns out things are already pretty
    simple as they are (I was worried that the audio streams were mixing channel
    counts, and didn't know how that was effecting things. Seems only the audio
    file player was suffering from this. Need to be more vigilant about channels
    and streams in future)

2018-06-12
  - created rudimentary audio recording object. Currently all it does is record 
    the audio given to it, and then save that audio to a file when you press
    the stop button.

  future ideas
  - going to have to change all audio connections to single channel, instead of
    this sudo-single channel we have currently


2018-06-08
  - there's now different types of oneShot circuitry; one that allows multiple 
    instances to play, and one that doesn't (named oneShot_single and 
    oneShot_multi)
  - wrote up looper circuitry and object. It just takes a file and always loops
    it while playing. The circuitry has the ability to loop a sub-section of the
    file, but the object doesn't have that feature
  - wrote up new version of the generic audio file player, which is written a 
    bit nicer, with some small changes
  - test situation 10 / 2 / 2 is looking good, now with each player type in an
    object (and labels)


2018-06-06
  - upgraded the needle-positioning on the oneShot player object. It now uses
    a transition instead of constant updates to the position.. I need to
    investigate whether a similar technique could be used for other players
  - needleOverlay now has the ability to disable regular selection and area
    selection
  - gave the oneShot object a trigger data input
    

2018-06-05
  - turns out there was a flaw in how 'positionFromMousePoint' was being used.
    'getCumulativeTransform' doesn't do a great job in getting the actual X/Y
    point, so 'getTruePoint' has been created which does much better
  - 'positionFromMousePoint' replaced with 'getPositionWithinFromMouse' which 
    has the same functionality, but a nicer interface
  - updated grapher_audioScope and grapher_PeriodicWave to the new way of
    selecting what type of graph you want
  - updated testObject to have all the latest graphers
  - added 'loadAudioBuffer' to utility.audio
  - wrote up 'oneShot' audio file player circuit and object (object needs work)


2018-06-04
  - needleOverlay work complete, seems pretty solid now
  - worked on integrating the needleOverlay with the audioFilePlayer object. You
    can now select the loop region, move it around and deactivate it. It's a 
    bit rickety, but it works (you might want to check up on the 'loopCompute'
    and anything to do with getting the current time in the audioFilePlayer
    audio part. It works on my machine!)
  - cleaned things up a bit in test situation 10 - 2


2018-06-03
  - more work on the needleOverlay; seem to have basic mouse interaction working
    now


2018-06-01
  - redid the original grapher to be more like the new canvas grapher, and
    subsequently made it possible (and easy) to switch between the two. Parts
    that use a grapher part, now give the ability to chose which you want to use
    (canvas is default)
  - upgraded the slider to to have 'click to go to this position' 
    functionality. Also the handle has a little more grapple area than is
    visible
  - began on overlay control object (which will be used with the waveWorkspace
    later)


2018-05-31
  - finished off canvas-based grapher, and put it into the audioFilePlayer 
    object
    this move better now (as expected)
  - created wave form workspace with grapherCanvas. It's pretty nice too.
  - added rudimentary selection-area to grapher_waveWorkspace (need to work
    on backward selection)


2018-05-30
  - there's a problem with putting a canvas in a svg element. It appears to be a
    known bug on chrome, but no-one has dealt with it since 2015. There's a note
    on the bug reporting site that's from 2018-02-14 that seems to claim that 
    they'll be able to fix this bug..nothing after this though.
      It seems I can hack together a fix where an image element is actually 
    used, and a canvas element is hidden. The canvas is drawn to, and then a
    'print' command can be run which prints the canvas data to the image
    element. It's essentially the same (I think). Problems now are to do with
    detail, but I think that can be fixed...probably user selected


2018-05-29
  - current time in audioFilePlayer now accounts for playback rate (but not
    detune, which is just a different way of changing the playback rate, so I've
    removed that feature)
  - developed rudimentary waveform viewer; but its causing a lot of strain of 
    then browser. I'm working on integrating a canvas element to deal with
    this. There's still a lot of time spent on gathering the points to graph
    though..


2018-05-28
  - redid the slider and slider panel; things are simpler now and I've thrown   
    out the horizontal and vertical versions of both, in favour of just using an
    angle value.
  - wrote up new version of the audioFilePlayer (developing with a new object)
    (the 'currentTime' method doesn't account for playback rate changes..need to
    fix that)


2018-05-25
  - added 'seconds2time' and 'padString' utilities under math (the second isn't
    really math though..I should make a 'string' category or something...)
  - fixed up play/pause/stop functionality in the audio file player, and added
    the ability to get the current time
  - horizontal slider has been updated to override programmatic 'set' calls
    when the user is pulling the handle..it works, but needs work. Also it needs
    to be copied to other such controls
  - audio file player object now has a scrubber (everything needs work)

  future ideas
  - there's some 'detune' and 'play rate' methods in the audio source buffer
    thing somewhere..


2018-05-24
  - got upload of audio files to work. there's features for looping, starting
    mid track and graphing the waveform too that need to be worked on now
  - expanding audio file playing object to display the name of the loaded track,
    and have play/stop buttons (pause is under development)


2018-05-23
  - began work on the overlay menu
  - updated svg element layout to have different global panes, also there's an
    improved system for finding the scale of those global panes
  - changed how object.requestInteraction works; now it requires a global pane
    name to work with. This is so one can differentiate between actions for the
    workspace and ones for the menu. Currently, most mouse actions aren't really
    necessary - buttons and sliders work by their own anyway, and menu items
    aren't moveable - but things change and things should be open to this.


2018-05-22
  - redid audio_scope and audio_duplicator in new style, and put them in the 
    objects folder
  - successfully got the audio producing node to split the loaded track into its
    left and right channels


2018-05-21
  - another day, another attempt at that shebang thing in gravity
  - redid the basic synthesizer object with the new object builder system
  - created basic audio playback object (still working on 'uploading' files)


2018-05-18
  - redid the paste fix from yesterday, to put the 'declareObjectGrapple' back
    into the object builder
  - fix in audio_meter_level, where not setting the angle value would produce
    the element upside-down. It now defaults to 0 so that doesn't happen.
  - redid object builder to have z position control, it's also just flatly
    better now
  - making all the element callbacks lower case (it was inconsistent before)
  - another attempt at making gravity work everywhere (now mac works..we'll 
    see)


2018-05-17
  - fixed keyboard interaction from yesterday (the logic was broken) there's
    now also the option of 'all' so you don't have to declare everything
  - fixed onmouseup problem in button_rect (it's that this/timeout thing)

  bugs
  - the new object-design concept has totally broken the paste functionality :/
  -> scratch that; I fixed it by pulling the 'declareObjectGrapple' function 
    out ..still a little wonky I feel


2018-05-16
  - created readout using sixteen segment display
  - wrote up a pretty snazzy audio-input object with input select

  bugs
  - the logic in keyboardInteraction/declareKeycaptureObject/keyProcessor is 
    broken


2018-05-15
  - created sixteen segment display


2018-05-14
  - updated gravity shebang so it'll work in other systems (hopefully)


2018-05-11
  - fixed preservation of indentation in gravity
  - wrote up objectBuilder (a bit crude, but it's there)

  future ideas
  - you could probably delete that 'parts/modifiers' folder


2018-05-10
  - test situation 10 "recorded audio" / 1 "microphones" works, and rather
    simply too. All very gentle and nice
  - created rudimentary audio-in object


2018-05-09
  future ideas
  - audio in / import-export / playback / record / edit
  - look into "DynamicsCompressorNode", "DelayNode" and "IIRFilterNode"


2018-05-08
  - seems the feedback problem was caused by the 'Q' being set way too high. It
    used to be at 10000, but now it's at 0.1 and things are much more 
    reasonable
  - wrote up simple filter object

  future ideas
  - none of that 'power on' stuff to get round the new "no auto-play" features,
    instead, I'll just rely on some other activation method external to the
    main system. Keeps things clean I think


2018-05-04
  - chrome's "no autoplay" feature has arrived, and it's causing problems. You
    can go into 'chrome://flags/' and turn it off, but this is only a 
    development solution. There's going to have to be some sort of activation
    method..perhaps a gain dial on the audio sink that's set to zero.
    - added a 'power' button to the audio sink, but this will have to be
      changed to something else eventually
  - wrote synthesizer 3 which is gainJourney based (though it accommodates the
    velocity of a note)
  - wrote up a reverb unit and object, which uses those impulse responses from
    before. There's an output gain dail, a method of selecting between the ~38
    types and a wet/dry dial

  - filter unit has strange feed-back loop I can't seem to find the root of ):/


2018-05-02
  - wrote a pile of notes on synthesizers
  - fixed a little problem in basicSynth_2 where setting the rate dials to max
    would stop the wobble completely
  - start test situation 9 "audio effect units"
  - pushed 'changeAudioParam' to '__globals.utility.audio.changeAudioParam'
  - wrote up simplistic distortion box (complete with in/out gain adjust,
    distortion, resolution and over-sample controls. Seems to work pretty well)
  - added 'onRelease' callback to 'dial_discrete'
  - the 'onChange' callback for 'dial_discrete' is now only called when the
    value actually changes
  
  future ideas
  - reverb unit
  - EQ unit
  - multi-band distortion unit
  - mixing units


2018-05-01
  - added adjustment dials to new gain-wobble synthesizer (for period and depth)
  - updated gravity to ignore files which have names that begin with a dot
  - created synthesizer 2 and it's object (which incorporates gain and detune
    wobble; with dials for depth and rate)

  future ideas
  - need to do layouts of potential new synthesizers


2018-04-30
  - rewrote basicSynth into new style (it's actually longer than the original)
  - pushed the new synthesizer into main place (should probably rename it)
  - renamed synthesizer to synthesizer_basic
  - wrote up prototype versions of a synthesizer with gain and detune wobble
    (much better efficiency) and a prototype synthesizer object with gain wobble

  future ideas
  - we're going to have to make more self-contained synthesizers instead of this
    multi-unit idea, as things are pretty heavy on the processor, and there 
    seems to be a lot of time spent on fixing things that aren't that necessary
    (like the warbler sending the correct gain adjust signals fast enough, and
    the dial being able to keep up..slow moves are pretty much fine)
      It goes slightly against my desire to do everything in atomic parts (or at
    least, have the option to) but here we are. Audiotool is contained like 
    that. Logic, Acid, etc. all the same. I suppose its a battle between
    wanting to make things as open as possible, which led me to this
    everything-atomic way, but I think I can provide the same level of control
    with a more integrated (and efficient) units.


2018-04-27
  - new audio sink now has left and right audio channel input and a meter for 
    each
  - fixed a problem with cable redrawing which I hadn't noticed before
  - fixed slow duplication on the periodicWaveMaker, which had to do with
    calling update loops with the slidepanels. Slidepanels now use their own
    code more and don't rely on the individual sliders for panel-wide updates
  - audio meter part; complete with level; slow-moving background level and 
    markings (looks pretty pro too)
  - tried making a 'warbler' which changes the gain of a synthesizer a lot. 
    Seems to break manual control though, and if you go fast enough the dial
    doesn't move 
  

2018-04-26
  - finished redoing utility (that was bigger than I expected)
  - rearranged test situation 8 and some of the objects to look nicer
  - periodicWaveMaker now sends its settings on connecting
  - worked on redoing the audio sink to have an audio meter (working on an audio
    meter while I'm there)


2018-04-25
  - redoing utility


2018-04-24
  - redoing utility


2018-04-23
  - redoing utility


2018-04-20
  - updated keyboard interaction, so now objects have to declare what keys they
    want to use, and what modifiers will go with them (none, meta, control, alt
    and shift) The system behind handles everything else, and knows to run the
    global functions if nothing matches. Objects will also be told about 
    modifier keys that accompany a key.
  - wrote up an audio duplicator and added it to test situation 8

  future ideas
  - onmouseleave for objects?


2018-04-19
  - periodicWaveMaker's slides were entering values upside-down, so, fixed that
  - renamed 'compiler.py' to 'gravity' on Dylan's suggestion as it sounds cooler

  future ideas
  - make the audio connection nodes and cables flicker with the audio that they
    are carrying
  - redo keyboard capture, so object don't capture the entire thing when they
    only want one key. Have the objects declare what keys they want.


2018-04-18
  - fixed a problem with the dial_continuous, slide_horizontal and 
    slidePanel_vertical where applying overlapping smoothSets caused confusion
    in the animation. Now, the previous one is just cancelled and the new one
    takes over from where the old one left off
  - updated the synthesizer to incorporate different transition curves in attack
    and release (exponential still doesn't work though)
  - had to reverse sin/cos periodic wave input in the synthesizer..curious
  - began work on an audio scope, it can accept audio data and visualize it,
    there's also a 'hold' key and a dial for adjusting the refresh rate

  future ideas
  - audio duplicator
  - audio combiner


2018-04-17
  - fixed key_rect in test situation 1 test object (remember not to on
    onmouse-anything. It's all onkey-something)
  - added curve maker into utilities (linear, reverse_linear, sin, cos, s,
    exponential)
  - added smoothSet to dial_continuous, slide_vertical, slide_horizontal,
    slidePanel_vertical and slidePanel_horizontal
  - in test situation one, the rect_button now causes some new functions
  - updated the synthesizer to have smooth transition options when setting gain
    and detune (exponential doesn't seem to work though; but user-defined does
    ..curious)
  - updated basicSynth to accept smooth changing values for gain and detune, and
    adjust the dials and synthesizer accordingly along with the stored value for
    any new oscillators that are created during the time of transition

  future ideas
  - change attack and release in basicSynth and the synthesizer to incorporate
    different transition curves


2018-04-16
  - started log
  - added glowbox to test object in test situation one
  - deleted unneeded files
  - fixed up the first test situation a little to use the latest writings
  - looked into adding curve-based movement to the synth and continuous dials
    dials