Put a project's files into the current id form when they were read in the old one. Ids became integers; a .dgm written before that holds uuids, and every load allocates integers for them afresh. The mapping is deterministic, so the design works either way - but nothing on disk ever changes, so the ids in the file match nothing anyone can see in the running app, and every open pays the conversion again. Opening the project is where it is settled, once. The WHOLE project or none of it. Component ids are design-unique, and admitting the sheets re-mints any that collide - so a sheet whose own ids were already integers can still have come out of the load different from its file, and writing only the uuid ones would leave the design half-converted. Not for a project Issie may only write nothing to - the shipped demos read from the read-only static directory, a folder on a read-only share. There is no asking in advance whether a directory can be written, so the first refusal is the answer: the write is attempted, and a project that refuses it simply keeps its old ids. Said in the log and nowhere else, because nothing about the design is wrong and there is nothing for the user to do. A library sheet belongs to its library and is never written back, whatever asks. A library opened AS a project is written like anything else - its components are the sheets - and needs no exception here: one whose ids are already integers needs no conversion, so nothing is written for it. Returns the sheets, and the names of those actually written - empty when nothing needed converting, and empty when the project could not be written. That is what the caller tells the user about: this is a legacy conversion, it changes every file of the project, and it should not happen silently.

returns a WaveSimModel option if a file is loaded, otherwise None

maybe no longer needed...

Take one project off the recent list. The project itself is untouched.

extract SavedWaveInfo from model to be saved. Takes the design to walk rather than reading it off the project, because the selection is saved as label paths and the project's copy of the sheet being saved is the version before the save - see designWithSheet, which is what every caller passes.

What is directly inside each sheet of the project: one pass over each canvas, and so a cost that is the design's own size whatever that design expands to. showLibrarySheet: a library sheet it answers false for is left out, and so are the instances that would put it inside someone else - a library component is one thing, not a sheet with innards. It has to be decided here rather than by filtering the project first: the shapes are read off each sheet's canvas, so a sheet removed from LoadedComponents still leaves its instance naming it, with nothing to find under that name. A predicate rather than one flag for the lot, because a library component the user has asked to look inside appears in the Sheets menu while the rest of the library stays hidden. The sheets are given as a list rather than as a project, because not every hierarchy is drawn from the project: the wave selector draws the design that was SIMULATED, which the simulation carries as a list of exactly the sheets it needed.

Get the subsheet tree for all sheets in the current project, library sheets included.

Get the subsheet tree for all sheets in the current project. Returns a map from sheet name to tree of SheetTree nodes. Every sheet is a root here and every node is built: callers that draw one hierarchy, and that can leave part of it unopened, should use getSheetShapes and materialiseTree directly.

Which library sheets the Sheets menu and the design hierarchy show: none, unless the developer toggle is on, or the user has asked to look inside that particular component.

Make a poup with menu to view and select a memory data source

Build the part of a hierarchy that is going to be looked at. `expand` is asked of each node's SheetPath: a node it says false to comes back as a leaf and nothing below it is built at all. That is what lets a design many routes reach one sheet in be drawn without being walked, since the drawn tree is then the only tree there is. `fun _ -> true` builds the whole thing, which is what the Sheets menu asks for. allInstances = false collapses several instances of one sheet inside one parent into one node, dropping the others BEFORE their subtrees are built rather than after. Instances of a sheet expand identically - same children, same depth - so this is the same tree; what it is not is the same amount of work. A sheet reached from inside itself is not descended into. The guard is on the ancestor path, so the shapes may name each other in a cycle and this still terminates.

The sheets that more than one route from the root reaches, and which therefore appear more than once in its hierarchy. Worked out from the design graph - each sheet's parents are counted, not its occurrences - so a design whose expansion is astronomical still costs its own size. Everything below such a sheet is one too: a sheet inside a sheet that appears twice appears twice itself, however singular its own parent is.

open an existing demo project from its path

Open a sheet of the project, SAVING the one being left if it has unsaved changes. That is what every ordinary way of changing sheet goes through - the Sheets menu, following a custom component into its sheet, and the waveform viewer's jump to a sheet. Whether it has changes is worked out here rather than read off Model.SavedSheetIsOutOfDate: that flag is only recomputed on DRAW BLOCK messages, so a change made by anything else - the Properties pane setting a sheet's array settings, or its parameters - left it saying what was true before the change, and the switch then dropped the edit. See ModelHelpers.currentSheetIsOutOfDate.

Open the specified file, saving the current file if needed. Creates messages sufficient to do all necessary model and diagram change Terminates a simulation if one is running Closes waveadder if it is open

Open a component library as a project, so that its components can be edited where they are. The catalogue's door to what the project browser reaches by navigating to the folder: one open path, so the refusal above and the recent-projects entry are the same either way in.

open an existing project from its path

Works out number of components and connections changed between two LoadedComponent circuits a new ID => a change even if the circuit topology is identical. Layout differences do not mean changes, as is implemented in the reduce functions which remove layout.

temporary shim for compatibility while dispatch is still being used.

return an option containing sequence data and file name and directory of the latest backup file for given component, if it exists.

One row of a recent-projects list: the project, which opens on a click, and a cross that takes it off the list. Only opening a project ever put one here, and only opening four others ever took it away - so a project opened once by mistake, or one whose folder has since been moved or deleted, sat at the top of the list of five for as long as it took to open five more. The cross is worded and coloured as removal from a list rather than deletion, because that is all it is: nothing on disk changes.

The recent projects to offer, newest first. Read the list through this rather than from UserData directly.

Remove file.

Write every sheet that differs from its file, except the open one, and clear its flag. ONLY THE OPEN SHEET MAY BE UNSAVED. A change to one sheet routinely reaches others - binding a parameter writes it on every instance, reconciling ports rewrites the sheets that hold them, setting the top sheet rewrites the flag on all of them - and a closed sheet left waiting for a save is a sheet the user cannot see, did not knowingly edit, and has no reason to save. Several places used to mark such sheets and leave them, so the state existed and had to be handled at project close. A library component's sheet belongs to its library and is never written back, whatever asks; it is left alone here and not called unsaved either.

Save the sheet currently open, return the new sheet's Loadedcomponent if this has changed. Do not change model. update Symbol model with new RAM contents.

save current open file, updating model etc, and returning the loaded component and the saved (unreduced) canvas state

Save the sheet currently open, return updated model dispatch not needed. currently errors in saving are not processed: because without dispatch we cannot add an alert. this could be changed by using the Notification field in the returned model

Make the named sheet the current top sheet governing parameter display, clearing the flag from every other sheet. The flag is per-sheet view state persisted in the .dgm file. Every sheet but the open one is written at once, so the choice survives without a manual save.

Load a new project as defined by parameters. Ends any existing simulation Closes WaveSim if this is being used

Which sheet a project opens at. The most recently saved sheet says what the user was WORKING ON; it is rarely what they want to look at first. A subsheet opened on its own is a block out of context - the design it belongs to is not on screen, its parameters show whatever its own defaults give, and the first thing anyone does is climb back up. So the timestamp picks the DESIGN, and the design is opened at its top. The top is the highest sheet EVERY route to the last-saved one passes through. Where the project is one tree, which is nearly all of them, that is simply its root. Where two roots both reach the sheet it belongs to two designs and there is no saying which was meant, so the answer is the highest sheet they have in common on the way to it - which may be the sheet itself. Note that a sheet reached by two routes is not by itself an ambiguity: one design using a block twice still has one root, and that root is still what opens. Climbing while there was a single PARENT would stop at such a sheet and open a block out of context, which is the thing this exists to avoid. Library sheets are left out of the graph entirely. A library component is one thing rather than a sheet with innards, so it is neither a design to open nor a route that makes one ambiguous. Only a sheet the user made is a candidate for "last worked on" - a generated or protected sheet carries a timestamp from something the user did not do - but any of them can be climbed through, since a design is opened at its top whoever wrote the sheets in between. The cost is a walk of the design graph per sheet above the one chosen, which is the project's own size squared and not its expansion - and it is paid once, while a project is being opened. None only for a project with no user sheets at all.

Drop library sheets that nothing instantiates any more, deleting their files. Run when the project is saved rather than when an instance is deleted: undo restores model snapshots, so deleting the sheet at deletion time would leave undo unable to bring it back.

A recent list as it came out of the settings file, in the form the rest of the code holds it in. Settings written before paths were normalised have the same project under two spellings, and one written by an older version can be longer than the limit; tidying on the way IN means the next write of the settings file heals it, rather than leaving that to the next project opened.

Return LoadedComponents with sheet name updated according to setFun. Do not update model.

return current project with current sheet updated from canvas if needed. Do not update model.

Write Loadedcomponent comp to a backup file if there has been any change. Overwrite the existing backup file only if it is a small, and recent, change. Parameters determine thresholds of smallness and recency return () - display an error if the write goes wrong.

Write Loadedcomponent comp to a backup file if there has been any change. Overwrite the existing backup file only if it is a small, and recent, change. Parameters determine thresholds of smallness and recency return () - ignore errors

Write a sheet to the file it came from, whichever of the two forms that file is: an ordinary .dgm, or a component of a library opened as a project. See ComponentLibraries.writeSheetFile.