class DataCatalog

Maps are now sorted on export to sql and xml to ensure that ordering is consistent for tracking in version control.

DsPart

The following functions on DsPart account for PartSpecial information now.

// adds specialFlattenableKey() to tail of key
public str flattenableKey() {}

// returns PartSpecial price if found
public double basePrice() {

As of 16.0, preview image support has been implemented for core Parts and is no longer exclusive to DsParts.

As a result, the following changes have been made to DsPart:

• global constant dsPreviewColumn has been removed from DsParts overridePartColumns() function
• previewImageUrl() function overrides the core Part version and now has an added default parameter
• overridden interface added

Old: public PartColumn[] overridePartColumns() {
		return [PartColumn: dsPrdCatalogColumn, dsPreviewColumn, dsTagPartColumn ];
	 }
New: public PartColumn[] overridePartColumns() {
		return [PartColumn: dsPrdCatalogColumn, dsTagPartColumn ];
	 }


Old: extend public Url previewImageUrl() {}
New: public Url previewImageUrl(bool generateIfNotFound=false) {}


Added: public Image previewImage(sizeI size=cPartPreviewImageSize, bool generateIfNotFound=false, bool regenerate=false) {}
Added: public bool allowRenderPreviewImage() {}

DsPData

DsPData has undergone a change in it's public double price(SpecOption[] specOs=null) function. The function now returns a base price that does not include SpecOption prices. As of 16.0, upcharge() has been implemented in cm/abstract/part/part.cm and SpecOptions contain a price value. customListPrice now returns the base price plus the upcharge value.

The public void queryDialog(Snapper snppr) {} function has also been changed with the new QueryDialog implementation. It no longer opens the old DsQueryDialog implementation but utilizes the new QueryDialog.

The following has been changed in DsPData:

// price function
Old: extend public double price(SpecOption[] specOs=null) {
		double price;
		price = basePrice();
		if (!specOs) specOs = specOptions().:SpecOption[];
		for (DsSpecOption specOpt in specOs) price += specOpt.price;
		return price;
	 }	

New: extend public double price(SpecOption[] specOs=null) {
		return basePrice();
     }
	 
	 
	 
// queryDialog function
extend public void queryDialog(Snapper snppr) {
	if (proxy) {
		...
	}
	
	Old: DsQueryDialog(anyFrameWindow, snppr);
	New: dsOpenQueryDialog(snppr);
} 

class DsPData

The code of DsSpecOption is now constructed based on the option code instead of the option valueS to fix a bug where the dropdown selection of options in sub-features of numeric order features is not populated in the calculation dialog.

class DsPart

Added optional parameter to the constructor for partSourceId. Added new constructor for convenience.

Old:    public constructor(Snapper snapper, DsPData data, double price, double qty=1)

New:    public constructor(Snapper snapper, DsPData data, double price, double qty=1, str partSourceId=null)

New:    public constructor(Snapper snapper, DsPData data, str articleCode, str description, double listPrice,
               double quantity=1, double inPrice=0,
               bool flattenable=true, bool group=false, partStyle style=psNone,
               str flattenableKey=null, bool allowOtherParent=true, str partSourceId=null)

Removed:     private str _itemTagInfoKey;

_itemTagInfoKey has been moved to ProdPart in cm.abstract.part .

Preserve Ind. Tag customizations

User modifications to Ind. Tag are part of the flattenable key now when the user turns that setting on.

ItemTagInfo

Methods for managing Ind. Tags were moved to ProdPart .

class DsSpecOption

Remove field price

Removed: public double price;

class DsRextileLengthPartColumn is renamed to DsMaterialQtyPartColumn

MR: Rename Textile Length column to Material Quantity

Previous:    public class DsTextileLengthPartColumn extends BasicPartInfoTreeColumn


New:    public class DsMaterialQtyPartColumn extends BasicPartInfoTreeColumn

DataSymbol

With the new QueryDialog, interface has been added to DataSymbol to opt-in to utilize the new dialog. DataSymbols are defaulted to utilize the new QueryDialog. Any subclasses of DataSymbol must opt-out if the new dialog is not to be utilized.

The acceptQuery function is checked before adding the query context-menu item to a DataSymbol and the openQueryDialog function is utilized to open a QueryDialog for a DataSymbol.

The acceptQuery function returns true and openQueryDialog opens the new QueryDialog.

The following interface has been added to DataSymbol:

// QueryDialog helper functions
Added: public bool acceptQuery() {}
Added: public void openQueryDialog() {}

class MhEngineSnapperEntry

The toConstructionEntry method now also ensures the imported props of the snapper entry are transferred over to the newly created construction entry.

    /**
     * To construction entry.
     */
    public MhEngineConstructionEntry toConstructionEntry(MhEngine engine=null) {
        MhEngineConstructionEntry res = createConstructionEntry();
        if (snapper) {
            ...
            // Transfer import props to be part of construction entry.
            if (!engine) engine = snapper.engine;
            var env = engine.?engineEnv();
            for (k, _ in snapper.importProps(engine)) {
                if (k in [mhPrevNeighborsKey, mhNextNeighborsKey]) continue;
                Object v = env.getProp(snapper, k);
                if (v) res.putSnapperImportProp(k, v);
            }
        }
        
        return res;
    }

MhSnapperFilter changes

In accepts(Snapper snapper) method, if the childDepth is not the same, it will instantly return false.

    public bool accepts(Snapper snapper) {
        if (owner.childDepth != snapper.childDepth) return false;
        ...
    }

Change in logic for post engine run and appending engine functions

We are moving away from utilizing post engine run functions. Previously when an engine is currently running functions and a new engine function was appended during this (particularly during the export function), it would have been appended to the same engine run that was being executed. This new engine function would then be executed during the post engine run. There was an issue where with a multi-assortment setup during the export function, new engine functions could be appended to the wrong engine run with the wrong assortment. Those functions would not be executed due to the mismatch of assortments.

We have now updated the logic such that when an engine is running, newly appended engine functions would be appended into a new engine run instead of the currently executing engine run. The current exception to this would be for the animation export MhSystemAnimationExportFunction where we still allow new engine functions to be appended and executed during the post engine run.

public class MhEngine extends CxEngine {

Old:
    /**
     * Engine run
     * Return a current run to append functions to it
     */
    extend public MhEngineRun engineRun(MhEngineRun currentRun, MhEngineRun[] currentList, MhAssortment a) {
        MhEngineRun run = null;

        if (runByRegistrationOrder) {
           if (currentRun) return currentRun;
           if (!run) for (r in currentList) { run = r; break; }
        } else {
            if (currentRun and currentRun.assortment == a) run = currentRun;
            if (!run) for (r in currentList) if (r.assortment == a) { run = r; break; }
        }
        return run;
    }


New:
    /**
     * Engine run
     * Return a current run to append functions to it
     */
    extend public MhEngineRun engineRun(MhEngineRun currentRun, MhEngineRun[] currentList, MhAssortment a) {
        if (runByRegistrationOrder) {
           if (currentRun) return currentRun;
           for (r in currentList) { return r; }
        } else {
            if (currentRun.?assortment == a and currentRun.?allowFuncReg) return currentRun;
            for (r in currentList) {
                if (r.assortment == a and r != currentRun) {
                    return r;
                }
            }
        }

        return null;
    }
}


public class MhEngineManager extends CoreObject {

Old:
    /**
     * Register run.
     */
    extend public void register(MhEngine engine, MhEngineFunctionRun func) {
        ...
        
        MhEngineRun run = engine.engineRun(currentRun, list, a);

        if (!run) {
            if (run = createEngineRun(a)) {
                run.assortment = a;
                
                init? list();
                list << run;
                engineRunList.put(engine, list);
            }
        }
        
        run.?append(engine, func);
    }


New:
    /**
     * Register run.
     */
    extend public void register(MhEngine engine, MhEngineFunctionRun func) {
        ...

        MhEngineRun run = engine.engineRun(currentRun, list, a);
        if (!run) {
            if (run = createEngineRun(a)) {
                if (currentRun) run.postRun = currentRun.postRun + 1;
                devassert(run.postRun <= 5) {
                    pln("Exceeding number of recursion allowed"); return;
                }
                
                run.assortment = a;
                init? list();
                
                int index = -1;
                if (currentRun) index = list.indexOf(currentRun);
                if (index >= 0) list.insert(index + 1, run);
                else list << run;
                
                engineRunList.put(engine, list);
            }
        }
        
        run.?append(engine, func);
    }
}

public class MhEngineRun {

New:
    /**
     * Temporarily allow same run function register.
     */
    public bool allowFuncReg;
}

MhBayUpdateFramesFunction changes

MhBayUpdateFramesFunction now include children to framesToUpdate to get updated if the classification is eval to its parent.

MhLevelArrangeFunction changes

MhLevelArrangeFunction now only sort children that are levels.

MhBayShape changes

MhBayShape will now adjust to its owner's parent if it is also a bay.

    public bool adjustTo(Snapper toSnapper, Object env=null) {
        ...
            } else if (isBay(owner) and toSnapper.isBay) {
                box b = owner.shapeBound([sBay]);
                box lb = toSnapper.shapeBound([sBay]);

                if (adjustWidth(owner, toSnapper, b, lb, env)) adjusted = true;
            }
        ...
    }

MhShuttleRailShape changes

Shuttle rail's shape will now only add front beam if the classification is not the rootParent row is not front row and inner.

Old:
    extend public bool shoudAddFrontBeam() { return true; }
New:
    extend public bool shoudAddFrontBeam() {
        if (?MhSnapper root = owner.?rootParent) {
            if (root.classification.isFrontRow and root.classification.isInner)
            return false;
        }
        return true;
    }

MhAnimRowConstructionalFunction changes

In createRowEntry(MhEngineEntryBlock block, MhEngineConstructionEntry e) method, if entry is in visited, it will also copy the visited entry's classification when we copy the visited entry's children. This is due to the visited entry's classification might get updated during runEntryFunctions, so the entry should get the same classification as well as we assume visited entry and entry would be exactly the same.

    extend public MhEngineConstructionEntry createRowEntry(MhEngineEntryBlock block, MhEngineConstructionEntry e) {
        ...
                for (MhEngineConstructionEntry ce in children) {
                str k = entryCacheKey(ce);
                if (k in visited) {
                    ?MhEngineConstructionEntry ee = visited.get(k);
                    for (MhEngineConstructionEntry c in ee.children(null)) ce << c.toConstructionEntry();
                    ce.classification = ee.classification; //copy the classification too
                }
        ...
    }

Bay/Frame editor undo changes

Introduced some new interfaces in MhStorageEditorConfiguration to use non-serious undo when changing property values in a configuration item. This can be used in conjunction with a new UndoOp MhStorageEditorConfigPropModifyUndoOp that can restore a configuration property value, used when a configuration value is not pushed to the snappers.

public class MhStorageEditorConfiguration extends MhSystemConfiguration {

    /**
     * Property uses serious undo?
     */
    extend public bool propertyUsesSeriousUndo(MhStorageEditorItem item, CoreProperty property) {
        return true;
    }


    /**
     * Before property changed.
     */
    extend public void beforePropertyChange(MhStorageEditorItem item, CoreProperty property) {
        ...
                    if (propertyUsesSeriousUndo(item, property)) {
                        space.beginSeriousUndoStep(undoSnappers, space);
                    } else {
                        space.beginUndoStep();
                        space.beginUndoRecording();
                        for (s in undoSnappers) space.recordForUndo(s);
                    }
        ...
    }


    /**
     * After property changed.
     */
    extend public void afterPropertyChanged(MhStorageEditorItem item, CoreProperty property) {
        ...
            if (propertyChangeLevel == 0) {
                if (propertyUsesSeriousUndo(item, property)) {
                    if (space.seriousUndoMode) {
                        space.?endSeriousUndoStep(undoSnappers, description=$editorItemChanged);
                    }
                } else {
                    space.endUndoRecording();
                    space.endUndoStep();
                }
        ...
    }
}

To support non-serious undo, MhFrameEditConfiguration.pushPropToPreview() no longer disables undo. This is so that non-serious undo also records changes made to MhFrameEditConfiguration.refSpace snappers by the engine within pushPropToPreview(). This change was made earlier for MhBayEditConfiguration.pushPropToPreview() but we are now making them work similarly. This should not affect you unless you are calling pushPropToPreview in your code while recording for non-serious undo.

Bay spawner changes

The behavior mhBaySelectionBehavior has been added to MhBaySpawner default behaviors. If your class that extends from MhBaySpawner is adding the same behavior, you can now remove it. If your class already adds a different selection behavior and you want to retain that instead, you should override customOtherBehaviors() and exclude mhBaySelectionBehavior after super(), e.g. behaviors.exclude(mhBaySelectionBehavior);.

Additionally, the behaviors mhBaySpreadPatternBehavior and mhBayEditorMeasurementsBehavior were previously added in gatherBehaviors(MhBehavior[] behaviors). They have now been moved to customOtherBehaviors() instead.

public class MhBaySpawner extends MhStorageSpawner {

     /**
     * CustomOtherBehaviors.
     */
    public MhBehavior[] customOtherBehaviors() {
        ...
        behaviors << mhBaySelectionBehavior;
        behaviors << mhBaySpreadPatternBehavior;
        behaviors << mhBayEditorMeasurementsBehavior;
    }
}

MhUnitLoadShape changes

Instead of putting unit load as a MemoryStream into the propData, we now directly put the unit load object itself.

Old:
    extend public void streamUnitLoad(ObjectFormatter formatter) {
        str key = unitLoadKey.?v;
        Object o = null;
        for (Str t, v in formatter.tempData) if (t and t.v == key) { o = v; break; }

        if (!o) {
            o = objectToMemoryStream(unitLoad);
            ...

New:
    extend public void streamUnitLoad(ObjectFormatter formatter) {
        str key = unitLoadKey.?v;
        Object o = null;
        for (Str t, v in formatter.tempData) if (t and t.v == key) { o = v; break; }

        if (!o) {
            o = unitLoad;
            ...

Double Deep check changes

As we are moving towards the multi layout concept, we change double deep checking to check for the child depth now instead of the classification. For example, these few places are

at MhLevelConstructionalPopulateFunction :

Old:
    extend public double addStaticLevels(double z) {   
            MhEngineEntry rowEntry = parent.rootParent(engine.MhEngine);
            if (rowEntry.?isDoubleDeep) return z;
        ...

New:
    extend public double addStaticLevels(double z) {  
        if (parent.childDepth(engine.MhEngine) > 1) return z;
        ...

at MhFrameConfigBehavior :

Old:
    public bool shouldPutConfigToManager(MhSnapper z) {
            Snapper root = z.rootParent;
            if (root.isDoubleDeep) return !root.isBackRow;
        ...
New:
    public bool shouldPutConfigToManager(MhSnapper z) {
        if (z.childDepth > 1) return false; //TODO revisit this, handle multi deep config properly
        ...

class MhRowChildCopyPasteBehavior

MhRowChildCopyPasteBehavior has been updated to also with with cut-paste actions. This class is meant to work together with the MhRowChildFavoriteAnimationG2 animation that will generate new rows for the pasted row-child snappers. It has now been updated to also work with cut-paste, you can now cut row-child snappers and pasting should generate new row snappers for them.

Below are the updates done to support this:

public class MhRowChildCopyPasteBehavior extends MhBehavior {

    /**
     * Selected.
     * Put mhParentGid on selected so we can use it with userCut.
     */
    public void selected(MhSnapper snapper) {
        if (Snapper parent = snapper.parent) snapper.fastPut("mhParentGid", parent.gid.hex, mhParentGidDef);
    }


    /**
     * Deselected.
     */
    public void deselected(MhSnapper snapper) {
        snapper.fastRemove("mhParentGid");
    }


    /**
     * User cut.
     */
    public void userCut(MhSnapper snapper, SpaceSelection selection) {
        snapper.fastRemove("mhParentGid");
    }
}

class MhShuttleBaySpawner

Previously the behavior mhShuttleBaySpreadPatternBehavior was added in gatherBehaviors(MhBehavior[] behaviors). It has now been moved to customOtherBehaviors() instead.

public class MhShuttleBaySpawner extends MhRackBaySpawner {
    /**
     * CustomOtherBehaviors.
     */
    public MhBehavior[] customOtherBehaviors() {
	...
	behaviors.exclude(mhBaySpreadPatternBehavior);
	behaviors << mhShuttleBaySpreadPatternBehavior;
	return behaviors;
    }
}

class AODataPanelJunctionSnapper

Modified createInitialData() to set a main data via the mainDataKey() method.

Before:     extend public void createInitialData() {
                putData(createData(partNumber()));
            }


New:    extend public void createInitialData() {
            putData(createData(partNumber()), dataKey=mainDataKey());
        }

Updated areas referencing cAOMainData to reference mainDataKey() method.

Preserve Ind. Tag customizations

Relavent Merge Request:

• MR: Improve Ind. Tag restoration
• MR: Regression fixes #1
• MR: Regression fixes #2

• Added all the methods below related to Item Tag from DsPart have been moved to ProdPart in cm.abstract.part.

	/***********************************************************************
	 * Item Tags
	 ***********************************************************************/

	/**
	 * Create a new item tag
	 */
	extend public str itemTagInfoKey=(str k)


	/**
	 * Item Tag info Key
	 */
	public str itemTagInfoKey()


	/**
	 * Item tag key.
	 */
	public str itemTagKey()


	/**
	 * Item tag info.
	 */
	public ItemTagInfo itemTagInfo()


	/**
	 * Finalize after merge.
	 * Done after dividing parts into groups and merging them, but before the post merge hooks.
	 */
	public void finalizeAfterMerge()


	/**
	 * Re-link any saved ItemTagInfo on the owner that should be shown with this part.
	 */
	extend public void reLinkItemTagInfo()


	/**
	 * Set the item tag info key.
	 */
	extend public void setItemTagInfoKey(str key)


	/**
	 * Reset the ItemTagInfoKey.
	 */
	extend public void resetItemTagInfoKey() { _itemTagInfoKey = null; }


	/**
	 * Set new info to item tag.
	 */
	public ItemTagInfo setItemTagInfo(str text)


	/**
	 * Reset ItemTagInfo.
	 */
	public ItemTagInfo resetItemTagInfo()

Added functions for detecting if setting is on

New:

	public bool ownerHasStickyTag(Snapper owner)

	public bool stickyIndTags()

AbsPart now overrides customListPrice to include upcharge().

/**
 * Custom (overidable) list price.
 */
public double customListPrice(bool includeChildren=false, str currency=null, Space space=null) {
	return super(..) + upcharge().?v;
}

class AbsTagPartColumn

ItemTag adjustments are now will be set through setItemTagInfo on cm.core.Part .

Removed completeSpecified()

Equivalent functionality moved to Part in cm.core.part . See completedSpec and completeSpecifiedValue().

Preserve Ind. Tag customizations

MR: Preserve Ind. Tag customizations

• While this new setting in CET is activated, any user modifications to Ind. Tag will make those parts unique to that Ind. Tag.

• Added all the methods below related to Item Tag from DsPart have been moved to ProdPart in cm.abstract.part.

    /***********************************************************************
     * Item Tags
     ***********************************************************************/

    /**
     * Create a new item tag
     */
    extend public str itemTagInfoKey=(str k)     


    /**
     * Item Tag info Key
     */
    public str itemTagInfoKey()     


    /**
     * Item tag key.
     */
    public str itemTagKey() 


    /**
     * Item tag info.
     */
    public ItemTagInfo itemTagInfo()


    /**
     * Finalize after merge.
     * Done after dividing parts into groups and merging them, but before the post merge hooks.
     */
    public void finalizeAfterMerge() 


    /**
     * Re-link any saved ItemTagInfo on the owner that should be shown with this part. 
     */
    extend public void reLinkItemTagInfo() 


    /**
     * Set the item tag info key. 
     */
    extend public void setItemTagInfoKey(str key) 


    /**
     * Reset the ItemTagInfoKey.
     */
    extend public void resetItemTagInfoKey() { _itemTagInfoKey = null; }


    /**
     * Set new info to item tag.
     */
    public ItemTagInfo setItemTagInfo(str text) 


    /**
     * Reset ItemTagInfo.
     */
    public ItemTagInfo resetItemTagInfo() 

Added field for price

New:     public double price;

Extended SpecOption from PartOptionItem

SpecOption now extends PartOptionItem to allow for a singular class hierarchy for PartOption . This is needed to establish consistent order output via multiple formats.

Add new constructor for setting price

New:        public constructor(str code, str description, str groupDescription=null,
                               int level=1, double price=0.0, bool exportable=true)

Implemented PartOptionItem methods for option output

MR: PartOption Refactor MR

    /**
     * Code
     */
    public str code() { return code; }


    /**
     * Group description. (OPTIONAL)
     */
    public str groupDescription() 


    /**
     * Description string. (OPTIONAL)
     */
    public str description() 


    /**
     * Level Attribute. (OPTIONAL)
     */
    public int level() 


    /**
     * Price string. (OPTIONAL)
     */
    public Double optionPrice() 

class ProdPart

Added _itemTagInfoKey to ProdPart.

New:     /**
         * Cached ItemTagInfo key.
         */
        private str _itemTagInfoKey : public readable;

Added _partSourceID to ProdPart

Added new constructor with optional parameter partSourceId added. This new field is intended for use to identify more generically the part source on the owning Snapper. It should not be set to the Part Number as it will use that by default when not supplied, but something more generic like "leftTableLeg".

 New:     public constructor(PartData data, str partSourceId=null) 

 New:     public constructor(Snapper snapper, str articleCode, str description, double listPrice,
                             double quantity=1, double inPrice=0,
                             bool flattenable=true, bool group=false, partStyle style=psNone,
                             str flattenableKey=null, bool allowOtherParent=true, str partSourceId=null)

Added field _partOptions to ProdPart for holding PartOption items in abstract

Implemented methods on ProdPart as a baseline for PartOption management, as well as options() here for overriding as needed.

    /***********************************************************************
     * Part Option API
     ***********************************************************************/

    /**
     * Options
     */
    public PartOption[] options() 


    /**
     * Spec options
     */
    final public SpecOption[] specOptions()


    /**
     * Append spec option.
     * 
     * Note: Ensure if you are building these that level on the
     * SpecOption is set properly.
     * 
     */
    final public SpecOption[] specOptions=(SpecOption[] newOptions)

Ind. Tag ata included in flattenableKey

User modifications to Ind. Tag are part of the flattenable key.

UnitLoadContainer Changes

Instead of saving UnitLoadContainer in world's auxillary, now we save it in world's cache instead. This is because we dont want to stream UnitLoadContainer together with the world.

Old:
    public UserUnitLoadContainer userUnitLoadContainer(World w=null) {
        if (!w or w.nonDrawing) w = mainWorld(selectWorldIfNull=false);
        if (!w) return null;
        UserUnitLoadContainer res = w.getAuxillaryObject(cUnitLoadContainer).UserUnitLoadContainer;

        if (!res) {
            res = UserUnitLoadContainer();
            w.putAuxillaryObject(cUnitLoadContainer, res);
        ...

New:
    public UserUnitLoadContainer userUnitLoadContainer(World w=null) {
        if (!w or w.nonDrawing) w = mainWorld(selectWorldIfNull=false);
        if (!w) return null;

        // handle old drawing - old way of keeping contianer
        if (?UserUnitLoadContainer cont = w.getAuxillaryObject(cUnitLoadContainer)) {
            w.putCached(cUnitLoadContainer, cont);
            w.removeAuxillaryObject(cUnitLoadContainer);
        }

        UserUnitLoadContainer res = w.getCached(cUnitLoadContainer).UserUnitLoadContainer;

        if (!res) {
            res = UserUnitLoadContainer();
            w.putCached(cUnitLoadContainer, res);
        ...

Hooks added - new way of streaming unit loads

Since now we dont stream UnitLoadContainer anymore, we need to stream the unit loads inside the container individually in the world. We put the unit loads into auxillary during saveWorldHooks. Then we remove them in postSaveWorldHooks so that we dont have double instances of the unit loads in auxillary and container.

New: 
    /**
    * Append individual uls to aux.
    */
    package void putUlOnAuxHook(World world, userSaveAction action) {
        for (ul in userUnitLoadContainer(world).unitLoads) {
        world.putAuxillaryObject(cUnitLoadGrpsKey#";"#ul.gid.hex, ul);
        }
    }


    /**
    * Remove uls from aux.
    */
    package void removeUlFromAuxHook(World world, userSaveAction action) {
        for (ul in userUnitLoadContainer(world).unitLoads) {
        world.removeAuxillaryObject(cUnitLoadGrpsKey#";"#ul.gid.hex);
        }
    }

The unit loads will then get appended back to the container during earlyLoadWorldHooks.

New:
    /**
    * Unload individual ul from aux hook.
    */
    package void unloadUlFromAuxHook(World world) {
        UserUnitLoadContainer cont = userUnitLoadContainer(world);
        for (k, o in world.allAuxillary) {
        if (o as MemoryStream) {
            if (k.beginsWith(cUnitLoadGrpsKey)) {
            if (?UnitLoad ul = memoryStreamToObject(o)) {
                str name = userFriendlyUnitLoadName(ul.?name);
                UnitLoad load = findEqualUnitLoad(ul, world);
                if (load) {
                load.gid = ul.gid;
                } else if (!unitLoadFromName(name, world)) {
                cont << ul;
                }
            }
            world.removeAuxillaryObject(k);
            }
        }
        }
    }

Modifying LineType's in the LineType cache now causes an assertion failure

We had a few bug reports caused by extensions modifying the colors of LineType's after they had been placed in a cache.

To prevent this from happening again we added an assert in private LineType getCachedLineType(str key) running in developMode that will produce an assertion failure (crash) if you do this in your extension and then attempt to retrieve the LineType from the cache.

You should never be modifying the members of an already cached LineType. If you run into this error, please copy the LineType before attempting to modify it, so that you don't update the cached instance.

Minor fix to shrunken

This function used to take in a reference and altered the object in place. The original rect is no longer altered, only the returned rect will have the shrunken (correct) size.

Old: public rectI shrunken(rectI& this, int x, int y) : inline {
New: public rectI shrunken(rectI this, int x, int y) : inline {

Removal of logging drawing and usage statistics

Usage and drawing statistics are no longer logged.

class ClickConnectorInstruction

The click functionality now more closely mimics what happens when a user clicks a connector in CET, in other words it reads the snapClickAnimation(..) from the snapper and calls animate(..) on it.

if (Animation a = c.snapper.snapClickAnimation(c)) {
    animate(a);
    simulateAnimationClick(line());
}

Previously, it was written specifically to handle SnapClickAnimation's and would call executeToggleConnection(..) directly on them instead of going through the proper animation chain.

if (?SnapClickAnimation clickAnimation = c.clickAnimation()) {
    Connector attach = c.connection();
    if (!attach) {
	for (a in c.connections()) { attach = a; break; }
    }
    if (attach) {
	clickAnimation.currentSpace.beginUndoStep();
	clickAnimation.executeToggleConnection(attach, true);
	clickAnimation.currentSpace.endUndoStep();
    }
 }

As a result of this change, more of the click animation's code, such as begin() and end(), will be executed which can lead to behaviour changes. However, it is not likely to require any code adjustments.

cm/win/control.cm
= setLabel(str label, bool update=true) now calls setFont to ensure the correct font is propagated to the winPainter.

cm/win/display.cm
+ Added: final public void setLabelAndTruncate(str label, int maxW, int maxWrap, bool update=true) {

Alternate email creation interface

Existing email interfaces uses MAPI which is not currently supported by the new Outlook app. We have added new interfaces that uses .eml files instead:

public bool createEmail(str subject, str text, str[] to, str[] cc=null, Url[] attachments=null, Url path=null, bool open=true)

public bool createEmail(str subject, str text, str to, str[] cc=null, Url[] attachments=null, Url path=null, bool open=true)

public bool createEmail(str subject, str text, str->Object args, Url path=null, bool open=true)

public bool createEmail(str subject, str text, str->Object args, bool open=true)

Automatic saving of size and position of FrameWindow

Improvements have been made to how we store and restore window position and sizes.

• Some preliminary multi monitor support
• Restoring of maximized state
• Ignore position / bound for snapped / arranged windows

To opt-in to this, your dialog has to override these methods:

    /**
     * Auto save position or size?
     */
    public bool autoSavePos() { return true; }
    public bool autoSaveSize() { return true; }

Resizing improvements

Previously, most FrameDialogs required to override resizing1 in order for childWindows that are not inside a SubWindow to reposition and resize correctly. This is no longer required, as we have moved some resizing logic from SubWindow to Window.

# SubWindow
    public void ancestorResizing() {
        Removed: redoLastPosition();
        Removed: redoLastSize();    
        super();    
        refreshFrame();
    }

# Window
    extend public void ancestorResizing() {
        Added: redoLastPosition();
        Added: redoLastSize();    
        for (c in _childWindows) {
            if (!c.visible) continue;
            if (c in PaneContainer) continue;    
            c.ancestorResizing();
        }
        
        // Second pass to process PaneContainer.
        for (c in _childWindows) {
            if (!c.visible) continue;
            if (c !in PaneContainer) continue;    
            c.ancestorResizing();
        }
    }