class InfoTipSnapperRef

The method str infoStr(str->bool filter=null, bool markup=false) has had its logic moved out into several different new methods for easier overrides.

public class InfoTipSnapperRef extends InfoTipObjectRef {
    New: extend public void partTagsInfoStr(StrBuf buf, str->bool filter=null, bool markup=false) {
    New: extend public void categoriesInfoStr(StrBuf buf, str->bool filter=null, bool markup=false) {
    New: extend public void volumeLayerInfoStr(StrBuf buf, str->bool filter=null, bool markup=false) {
    New: extend public void partsInfoStr(StrBuf buf, str->bool filter=null, bool markup=false) {
    New: extend public void collabInfoStr(StrBuf buf, str->bool filter=null, bool markup=false) {
}

DWG Dialog Multiselect

DWGs in the DWG Dialog can now be multiselected and edited at once.

class LeadTimeColumn

As of 16.5, a new interface for lead time has been added to core Part. As a result, a new lead time column has been created in cm/core/init/leadTimeColumn.cm. Extensions who have their own Lead Time column should migrate to the core version to avoid duplication.

Developers can migrate by:

• Preferred option:
  • If applicable, remove registry of a custom Lead Time Column
  • Implement leadTime() in Part to get accurate value for core Lead Time column
• Secondary option:
  • If custom lead time column exists...
    • Remove registry of a custom Lead Time Column
    • Utilize overridePartColumns() on Part to return custom lead time column in place of core column

/**
 * Lead Time Column for Parts
 */
public class LeadTimeColumn extends BasicPartColumn {

    /**
     * Constructor.
     */
    public constructor() {
		super("coreLeadTime");
    }
    

    /**
     * Initial Visibility.
     */
    public symbol[] initialVisibility() {
		return [#none];
    }


    /**
     * Return property value for part.
     */
    public Object value(Part part, Space space) {
        return part.leadTime();
    }
}

class Part

New Part-to-Owner Keys

New interfaces, partToOwnerKey and partToOwnerKeys, have been added to Part. These keys are str values that are unique for a Part within it's owner. Their purpose is to distinguish a single Part from multiple Parts on the same Snapper owner that may share the same flattenableKey but originate from different creators.

See documentation for FlattenedPartData for more information on how this value is used.

In cm/core/part/part.cm

/**
 * A unique key for a Part on it's owner.
 *
 * Ex. table legs flattened from 4 parts to 1
 * can have keys like {tableLeg0, tableLeg1, tableLeg2, tableLeg3};
 *
 * Utilize @partSourceId in @ProdPart to ensure uniqueness.
 */
extend public str partToOwnerKey() {
	return data.?articleCode();
}


/**
 * Unique keys for flattened Parts on owner.
 * 
 * Important if this part is flattened. Each key
 * should correspond to a distinct part included
 * in this flattened part.
 * 
 * Ex. table legs flattened from 4 parts to 1 
 * can have keys like {tableLeg0, tableLeg1, tableLeg2, tableLeg3};
 */
extend public str{} partToOwnerKeys() {
	str{} keys = {partToOwnerKey()};
	if (data as FlattenedPartData) keys += data.partToOwnerKeys();
	return keys;
}

New Part Attributes Interface

With the addition of the Part Attributes system and columns in Calculations, functions for easy access and modification to these values have been added to Part. The system for storing a Parts attributes is as follows:

• a PropObj holds a PartAnnotationHolder in its propData under a constant str key (cAnnotationHolderKey)
  • the PropObj is typically a Part owner/creator (Snapper, Component, etc.)
• a PartAnnotationHolder holds a map of str->(PartAnnotation[]) objects
  • the str keys are unique identifiers for a Part associated with the PropObj
  • the PartAnnotation[] values are the PartAnnotations associated with the Part
  • See documentation for PartAnnotationHolder
• a PartAnnotation holds a str note and a str description value
  • These are displayed under the "Attribute Note" and "Attribute Description" columns for a line item in Calculations
  • See documentation for PartAnnotation

To support the new system, the following interface has been added in Part:

/***********************************************************************
 * PartAnnotation Interface
 ***********************************************************************/
 
/**
 * Keys for this parts annotations.
 */
extend public str annotationKey() { ... }


/**
 * Keys for this parts Annotation notes/descs.
 * Important if this part has been flattened.
 * Should contain unique keys for each individual flattened part.
 */
extend public str{} annotationKeys() { ... }


/**
 * Check if this Part contains any annotations.
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 * @returns true if Part has PartAnnotations; false if not
 */
extend public bool containsAnnotations(PropObj s=null) { ... }


/**
 * Get PartAnnotations for Part.
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 * @returns seq of PartAnnotation(s) associated with this Part
 */
extend public PartAnnotation[] getAnnotations(PropObj s=null) { ... }


/**
 * Append PartAnnotation to this Part.
 * @annotation PartAnnotation instance to append for Part
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void appendAnnotation(PartAnnotation annotation, PropObj s=null) { ... }


/**
 * Append PartAnnotation(s) to this Part.
 * @newAnnotations seq of PartAnnotation(s) to append
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void appendAnnotations(PartAnnotation[] newAnnotations, PropObj s=null) { ... }


/**
 * Set PartAnnotation(s) for this Part.
 * @newAnnotations seq of PartAnnotation(s) to set
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void setAnnotations(PartAnnotation[] newAnnotations, PropObj s=null) { ... }


/**
 * Remove PartAnnotation from this Part.
 * @annotation PartAnnotation instance to remove from Part
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void removeAnnotation(PartAnnotation annotation, PropObj s=null) { ... }


/**
 * Remove PartAnnotation(s) from this Part.
 * @annotations PartAnnotation seq to remove from Part
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void removeAnnotations(PartAnnotation[] annotations, PropObj s=null) { ... }


/**
 * Remove all PartAnnotations from this Part.
 * @s PropObj owner of PartAnnotationHolder (defaults to @owner())
 */
extend public void clearAnnotations(PropObj s=null) { ... }
    

class PartAnnotationHolder

To manage the new PartAnnotations for a PropObjs parts, the PartAnnotationHolder has been created. It holds a str->(PartAnnotation[]) map and has functions for accessing and manipulating this map.

The system for storing a Parts attributes is as follows:

• a PropObj holds a PartAnnotationHolder in its propData under a constant str key (cAnnotationHolderKey)
  • the PropObj is typically a Part owner/creator (Snapper, Component, etc.)
• a PartAnnotationHolder holds a map of str->(PartAnnotation[]) objects
  • the str keys are unique identifiers for a Part associated with the PropObj
  • the PartAnnotation[] values are the PartAnnotations associated with the Part
  • See documentation for PartAnnotationHolder
• a PartAnnotation holds a str note and a str description value
  • These are displayed under the "Attribute Note" and "Attribute Description" columns for a line item in Calculations
  • See documentation for PartAnnotation

The str->(PartAnnotation[]) map contains:

• str keys
  • uniquely identifiable keys for a Part on the PropObj storing the holder
  • these keys are typically generated from the Parts annotationKey()
• PartAnnotation[] values
  • a sequence of PartAnnotation objects for the Part corresponding to the key

Simplified Interface

/**
 * Holder for multiple Parts PartAnnotation(s).
 * Typically stored on Part owner props.
 */
public class PartAnnotationHolder {

    /**
     * Map of unique Part key to PartAnnotation sequence,
     * Keys should be unique for Part on it's PropObj.
     */
    public str->(PartAnnotation[]) annotations;


    /**
     * Constructor.
     */
    public constructor() {}


    /**
     * Get PartAnnotation sequence for key.
     * @key key associated with PartAnnotation sequence
     * @returns seq of PartAnnotation(s) if found; null if not
     */
    extend public PartAnnotation[] getAnnotations(str key) { ... }


    /**
     * Append PartAnnotation for key.
     * @key key associated with PartAnnotation sequence
     * @annotation PartAnnotation instance to append
     */
    extend public void appendAnnotation(str key, PartAnnotation annotation) { ... }


    /**
     * Append PartAnnotation sequence for key.
     * @key key associated with PartAnnotation sequence
     * @newAnnotations seq of PartAnnotation(s) to to append
     */
    extend public void appendAnnotations(str key, PartAnnotation[] newAnnotations) { ... }


    /**
     * Set PartAnnotation sequence for key.
     * @key key associated with PartAnnotation sequence
     * @newAnnotations seq of PartAnnotation(s) to set
     */
    extend public void setAnnotations(str key, PartAnnotation[] newAnnotations) { ... }

    
    /**
     * Remove PartAnnotation for key.
     * @key key associated with PartAnnotation sequence
     * @annotation PartAnnotation instance to remove from Part
     */
    extend public void removeAnnotation(str key, PartAnnotation annotation) { ... }
    
    
    /**
     * Remove PartAnnotation sequence for key.
     * @key key associated with PartAnnotation sequence
     * @annotations PartAnnotation instances to remove from Part
     */
    extend public void removeAnnotations(str key, PartAnnotation[] annotations) { ... }


    /**
     * Remove all PartAnnotation sequence for key.
     * @key key associated with PartAnnotation sequence
     */
    extend public void clearAnnotations(str key) { ... }


    /**
     * Does holder contain any annotations?
     * @key optional key to specify seq to look for (default null)
     * @returns true if there are any annotations; false if not
     */
    extend public bool any(str key=null) { ... }


    /**
     * Is holder empty of annotations?
     * @key optional key to specify seq to look for (default null)
     * @returns true if there are no annotations; false if there are
     */
    extend public bool empty(str key=null) { ... }
}

class PartAnnotation

To align with the Spec application columns, new Attribute Note and Attribute Description columns have been introduced in Calculations. A single Part line may include multiple "attributes", each with a note and description. To encapsulate these values in a consistent and reusable way, a new type called PartAnnotation has been created.

Naming Note

The class is named PartAnnotation rather than PartAttribute. While the Spec and Calculations columns use the term attribute, that term was found to be misleading for these objects. After discussion, annotation was chosen as the clearer term to reflect their purpose.

Interface

/**
 * Representation of an annotation for a Part.
 * Utilized in Attribute Note/Description columns
 * in Calculations dialog and exported with SIF/PMX/OFDA exports.
 */
public class PartAnnotation {

    /**
     * Note for the annotation.
     */
    public str note;

    /**
     * Description for the annotation.
     */
    public str description;

    /**
     * Constructor.
     */
    public constructor auto();

    /**
     * Empty constructor.
     */
    public constructor() {}


    /**
     * Key for the annotation.
     */
    extend public str key() {
        return note # ':' # description;
    }


    /**
     * Return string representation of object.
     */
    public str toS() {
        return key();
    }
}

Part Attributes functions (cm/core/part/functions.cm)

With the addition of the Part Attributes system and columns in Calculations, functions for easy access and modification to these values have been added. The system for storing a Parts attributes is as follows:

• a PropObj holds a PartAnnotationHolder in its propData under a constant str key (cAnnotationHolderKey)
  • the PropObj is typically a Part owner/creator (Snapper, Component, etc.)
• a PartAnnotationHolder holds a map of str->(PartAnnotation[]) objects
  • the str keys are unique identifiers for a Part associated with the PropObj
  • the PartAnnotation[] values are the PartAnnotations associated with the Part
  • See documentation for PartAnnotationHolder
• a PartAnnotation holds a str note and a str description value
  • These are displayed under the "Attribute Note" and "Attribute Description" columns for a line item in Calculations
  • See documentation for PartAnnotation

Each function below will get the PartAnnotationHolder from the passed in PropObj and perform the function operation on the holder. Each function requires a PropObj parameter and some additionally require a str key and/or PartAnnotation(s) depending on the operation being performed (get, append, remove, etc.)

Simplified Interface

/***************************************************************************
 * PartAnnotation interface
 ***************************************************************************/

/**
 * Initialize PartAnnotationHolder for PropObj.
 * @s PropObj holding PartAnnotationHolder
 * @return PartAnnotationHolder instance containing PartAnnotations
 */
public PartAnnotationHolder initAnnotationHolder(PropObj s) { ... }


/**
 * Get PartAnnotationHolder from PropObj.
 * @s PropObj holding PartAnnotationHolder
 * @return PartAnnotationHolder instance containing PartAnnotations
 */
public PartAnnotationHolder getAnnotationHolder(PropObj s) { ... }

/**
 * Remove PartAnnotationHolder from PropObj.
 * Removes all PartAnnotations associated with PropObj @s
 * @s PropObj holding PartAnnotationHolder
 */
public void removeAnnotationHolder(PropObj s) { ... }


/**
 * Get Annotations for key from PropObj.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @return seq of PartAnnotation(s) associated with @s And @key
 */
public PartAnnotation[] getAnnotations(PropObj s, str key) { ... }


/**
 * Append annotation to PropObj @s for @key.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @annotation PartAnnotation instance to append to sequence
 */
public void appendAnnotation(PropObj s, str key, PartAnnotation annotation) { ... }


/**
 * Append annotations to PropObj @s for @key.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @annotations seq of PartAnnotation(s) to append to sequence
 */
public void appendAnnotations(PropObj s, str key, PartAnnotation[] annotations) { ... }


/**
 * Set annotations for @key on PropObj @s.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @annotations PartAnnotation instance to set for @key
 */
public void setAnnotations(PropObj s, str key, PartAnnotation[] annotations) { ... }

/**
 * Remove annotation for @key on PropObj @s.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @annotations PartAnnotation instance to remove for @key
 */
public void removeAnnotation(PropObj s, str key, PartAnnotation annotation) { ... }


/**
 * Remove annotations for @key on PropObj @s.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 * @annotations PartAnnotation instances to remove for @key
 */
public void removeAnnotations(PropObj s, str key, PartAnnotation[] annotations) { ... }


/**
 * Remove all annotations for @key on PropObj @s.
 * @s PropObj holding PartAnnotationHolder
 * @key str key of owner of annotations (usually a part key)
 */
public void clearAnnotations(PropObj s, str key) { ... }

class PartAttributeDescriptionColumn

With the new Attribute Description column in Calculations, the class PartAttributeDescriptionColumn has been made. It extends the new PartAttributeColumn base class and only overrides the public Object value(..) function to provide a Parts attribute description values.

Interface

/**
 * Part Attribute Description column.
 */
public class PartAttributeDescriptionColumn extends PartAttributeColumn {

    /**
     * Constructor.
     */
    public constructor() {
		super("attributeDescription");
    }
    

    /**
     * Return property value for part.
     */
    public Object value(Part part, Space space) {
        PartAnnotation[] attributes = annotations(part);
        if (attributes.empty()) return null;

        str[] descs();
        for (att in attributes) {
            descs << att.description;
        }
        return descs;
    }
}

class PartAttributesDataWindow

With the new Part Attributes Dialog (PartAttributesDialog), the subwindow for the data (middle) portion of the dialog has been made (PartAttributesDataWindow). It extends the new PartAttributesSubWindow base class overiding the initControls and alignControls functions.

This data subwindow contains the dialogs controls for:

• The grid of part attributes (ScrollableGridWindow attributesGrid)
• A subwindow with controls for editing the grids rows (SubWindow gridControlsSW)

Interface

/**
 * Data window for Part Attributes Dialog.
 * Holds grid and grid controls window.
 */
public class PartAttributesDataWindow extends PartAttributesSubWindow {

    /**
     * Part attributes grid.
     */
    public ScrollableGridWindow attributesGrid;

    /**
     * Grid controls subwindow.
     */
    public SubWindow gridControlsSW;


    /***********************************************************************
     * Initialization
     ***********************************************************************/
    
    /**
     * Initialize controls.
     */
    public void initControls() { ... }


    /**
     * Initialize grid.
     */
    extend public ScrollableGridWindow initGrid() { ... }


    /**
     * Intialize grid controls.
     */
    extend public SubWindow initGridControls() { ... }


    /**
     * Align controls.
     */
    public void alignControls() { ... }


    /**
     * Update grid column sizes and scrollbars.
     */
    extend public void updateGrid() { ... }


    /**
     * Update grid column widths.
     * Stretches columns to fit grid inner width.
     */
    extend public void updateColumnSizes() { ... }


    /**
     * Get grid size.
     */
    extend public sizeI gridSize() { ... }


    /**
     * Get grid width within first select column
     * and vertical scroll bar.
     */
    extend public int innerGridWidth() { ... }

    
    /***********************************************************************
     * Grid interface
     ***********************************************************************/

    /**
     * Get currently selected row.
     */
    extend public int selectedRow() { ... }


    /**
     * Get current row count.
     */
    extend public int rowCount() { ... }


    /**
     * Append row to end of grid.
     */
    extend public void appendRow() { ... }
    

    /**
     * Insert row into selected row of grid.
     */
    extend public void insertRow() { ... }


    /**
     * Remove selected row from grid.
     */
    extend public void removeRow() { ... }
    

    /**
     * Remove selected row from grid.
     */
    extend public void removeAllRows() { ... }


    /**
     * Check if row can be removed.
     */
    extend public bool canRemove(int row) { ... }


    /***********************************************************************
     * Collect data
     ***********************************************************************/

    /**
     * Collect PartAnnotation sequence from grid.
     * @returns PartAnnotation[] sequence from grid, skipping empty rows
     */
    extend public PartAnnotation[] collectAttributes() { ... }


    /**
     * Create a PartAnnotation for the row index.
     * @returns PartAnnotation for row; null if failed or row is empty
     */
    extend public PartAnnotation createRowAttribute(int row) { ... }
    

    /***********************************************************************
     * Events
     ***********************************************************************/

    /**
     * Dialog is stale. Update this window.
     */
    extend public void markStale() { ... }


    /**
     * Grid selected event.
     * Updates enablement of grid controls.
     */
    extend public void gridSelected() { ... }


    /**
     * Toggle enablement for grid controls.
     */
    extend public void toggleControlsEnablement() { ... }


    /**
     * Control callback.
     * @c Control instance prompting callback
     */
    extend public void controlCb(Control c) { ... }
}

class PartAttributesTopWindow

With the new Part Attributes Dialog (PartAttributesDialog), the subwindow for the top portion of the dialog has been made (PartAttributesTopWindow ). It extends the new PartAttributesSubWindow base class overiding the initControls and alignControls functions.

This subwindow contains the dialogs controls for:

• A label indicating which Part the dialog is opened for (Display partInfoLabel)

Interface

/**
 * Part Attributes Dialog top GroupBox.
 * Holds part information display.
 */
public class PartAttributesTopWindow extends GroupBox {

    /**
     * Part Information display.
     */
    public Display partInfoLabel;


    /***********************************************************************
     * Initialization
     ***********************************************************************/

    /**
     * Initialize controls.
     */
    extend public void initControls() {
        partInfoLabel = Display(parent=this, key="partInfoLabel", label=getPartInfoText());
        partInfoLabel.autoSize();
        autoSize();
    }


    /**
     * Align controls.
     */
    extend public void alignControls() {
        partInfoLabel.alignCenter();
    }


    /**
     * Get text for part information display.
     * Default: part number : part description
     */
    extend public str getPartInfoText() {
        Part part = partAttributesDialog.?part;
        if (!part) return null;
        return concat(part.articleCode(), " : ", part.description());
    }
}

class PartAttributesGridCell

With the creation of the new PartAttributesDialog and its grid, the grid cell type PartAttributesGridCell has been created. The only purpose of this cell is for cosmetic reasons: to use a default whiteBrush for the cell background during draw(..), to shorten cell text that extends the cell width, and for adding tooltip text.

Simplified Interface

/**
 * Grid cell for grid in PartAttributesDialog.
 * 
 * Overidden to shorten cell text, use whiteBrush in @draw,
 * and for tooltip text.
 */
public class PartAttributesGridCell extends TextInputGridCell {

   /**
     * Draw.
     */
    public bool draw(PixelDevice dc, GridWindow gw, rectI r, int x, int y) { ... }


    /**
     * Clipped text for cell.
     * Only clipped if text exceeds cell width.
     */
    extend public str clipText(rectI r) { ... }


    /**
     * Return desired tool tip text.
     */
    public str toolTipText() { ... }
}

hooks.cm File

Part Attributes Dialog Interface

With the addition of the new PartAttributesDialog, the following hooks have been added in cm/core/part/attributes/hooks.cm to handle the life cycle of PartAttributesDialogs.

/**
 * Initialize global hooks for PartAttributesDialog
 */
public void initGlobalPartAttributesHooks() {
	setMainSpaceHooks << function attributeDialogSetMainSpaceHook;
    putSelectWorldHook(function attributeDialogSelectWorldHook);
    appendPostFinalizeAfterMergeHook(function checkForStalePartAttributesDialogs);
}


/**
 * Remove global hooks for PartAttributesDialog
 */
public void removeGlobalPartAttributesHooks() { ... }

            
/**            
 * Set main space hook.
 * 
 * This hook runs when a new main space is selected (alternatives).
 * It will close all active PartAttributesDialogs.
 */
package void attributeDialogSetMainSpaceHook(World world) { ... }

                               
/**
 * Select world hook.
 * 
 * This hook runs when a new World is selected.
 * It will close all active PartAttributesDialogs.
 */
package void attributeDialogSelectWorldHook(World world) { ... }


/**
 * Post Finalize Post Merge hook.
 * Updates dialogs with stale data.
 */
package Part[] checkForStalePartAttributesDialogs(Part[] list) { ... }

class PartAttributesGridControlsWindow

With the new Part Attributes Dialog (PartAttributesDialog), a subwindow to hold controls for the grid in the dialog has been made (PartAttributesGridControlsWindow). It extends the new PartAttributesSubWindow base class overiding the initControls and alignControls functions.

This subwindow contains controls for:

• Appending rows to the dialogs grid (Button addButton),
• inserting rows into the dialogs grid (Button insertButton), and
• removing rows from the dialogs grid (Button removeButton).

Simplified Interface

/**
 * Controls window for Part Attributes Dialog grid.
 * Holds controls for manipulating grid.
 */
public class PartAttributesGridControlsWindow extends PartAttributesSubWindow {
    
    /**
     * Add button.
     */
    public Button addButton;

    /**
     * Insert button.
     */
    public Button insertButton;

    /**
     * Remove button.
     */
    public Button removeButton;
    

    /***********************************************************************
     * Initialization
     ***********************************************************************/

    /**
     * Initialize controls
     */
    public void initControls() { ... }


    /**
     * Align controls
     */
    public void alignControls() { ... }


    /***********************************************************************
     * Data Window Interface
     ***********************************************************************/
    
    /**
     * Parent PartAttributesDataWindow.
     */
    final public PartAttributesDataWindow dataWindow() { ... }


    /**
     * Append row to grid.
     */
    extend public void appendRow() { ... }


    /**
     * Insert row in grid.
     */
    extend public void insertRow() { ... }


    /**
     * Remove row from grid.
     */
    extend public void removeRow() { ... }


    /***********************************************************************
     * Events
     ***********************************************************************/

    /**
     * Control callback.
     * @c Control instance prompting callback
     */
    extend public void controlClicked(str controlKey) { ... }


    /**
     * Toggle controls enablement.
     */
    extend public void toggleEnablement(bool toggleOn) { ... }
}

class PartAttributesBottomWindow

With the new Part Attributes Dialog (PartAttributesDialog), the subwindow for the bottom portion of the dialog has been made (PartAttributesBottomWindow). It extends the new PartAttributesSubWindow base class overiding the initControls and alignControls functions.

This subwindow contains the dialogs controls for:

• Applying changes in the dialog (Button okButton),
• Canceling the interaction with the dialog (Button closeButton),
• Indicating to the user that the dialogs data has gone stale (Display dialogStaleLbl)

Interface

/**
 * Part Attributes Dialog bottom SubWindow.
 * Holds OK and Close buttons
 */
public class PartAttributesBottomWindow extends PartAttributesSubWindow {

    /**
     * OK button
     */
    public Button okButton;

    /**
     * Close button
     */
    public Button closeButton;

    /**
     * Stale data label.
     */
    public Display dialogStaleLbl;


    /***********************************************************************
     * Initialization
     ***********************************************************************/

    /**
     * Initialize controls.
     */
    public void initControls() { ... }


    /**
     * Align controls.
     */
    public void alignControls() { ... }


    /**
     * Dialog is stale. Update this window.
     */
    extend public void markStale() { ... }


    /***********************************************************************
     * Events
     ***********************************************************************/

    /**
     * Control callback.
     * @c Control instance prompting callback
     */
    extend public void controlCb(Control c) { ... }
}

class PartAttributeColumn

With the new Attribute Note and Attribute Description columns in Calculations, the base class PartAttributeColumn has been made. It provides the new PartAttributeGridCell and common functionality for the new PartAttributeNoteColumn and PartAttributeDescriptionColumn subclasses.

Interface

/**
 * Part Attribute Column
 */
public class PartAttributeColumn extends BasicPartColumn {

    /**
     * Initial Visibility.
     */
    public symbol[] initialVisibility() { ... }


    /**
     * Get part annotations.
     */
    final public PartAnnotation[] annotations(Part part) { ... }


    /**
     * Return property value for part..
     */
    public Object value(Part part, Space space) { ... }


    /**
     * Return output.
     */
    public str output(Part part, PartCache cache, Space space) { ... }

    
    /**
     * Get GridCell for column
     */
    public GridCell gridCell(Part part, Space space, PartCache cache, symbol view=null) { ... }
    
    
    /**
     * Get tooltip text for grid cell.
     */
    extend public str tooltipText(Part part, Space space) { ... }
}

class PartAttributesDialog

With the new Attribute Note and Attribute Description columns in Calculations, a new dialog (PartAttributesDialog) has been made to allow for viewing and modifying the attribute note and description values on a Part.

This dialog window contains:

• a private Part _part field owning the attribute Data
• a swappable private PartAttributesDialogBehavior _behavior defining the dialogs user interface and experience
  • All subwindows are initialized with the behavior
  • All events from subwindows and their controls are handled by the behavior
  • See documentation for PartAttributesDialogBehavior for more
• 3 private : public readable subwindows for the dialogs sections:
  • SubWindow topWindow
  • SubWindow dataWindow
  • SubWindow bottomWindow
• Two events for open/close:
  • event shownEvent
  • event closedEvent

Simplified Interface

/**
 * Part Attributes Dialog.
 * Displays and allows manipulation of PartAnnotation(s) for a Part.
 */
public class PartAttributesDialog extends DialogWindow {

    /***********************************************************************
     * Fields
     ***********************************************************************/

    private Part _part;
    private PartAttributesDialogBehavior _behavior;
    private SubWindow topWindow : public readable;
    private SubWindow dataWindow : public readable;
    private SubWindow bottomWindow : public readable;
    public event shownEvent;
    public event closedEvent;

    /***********************************************************************
     * Construction
     ***********************************************************************/

    public constructor(Part part, Window parent) { ... }
    public constructor(Part part, PartAttributesDialogBehavior behavior, Window parent) { ... }

    /***********************************************************************
     * Field Access
     ***********************************************************************/

    final public Part part() { ... }
    final public PartAttributesDialogBehavior setBehavior(PartAttributesDialogBehavior value, bool rebuild=false) { ... }
    final public PartAttributesDialogBehavior behavior() { ... }
    final public PartAnnotation[] attributes() { ... }
    
    /***********************************************************************
     * Build/Rebuild/Init
     ***********************************************************************/
    
    final public void initialize() { ... }
    extend public void build() { ... }
    extend public void initControls() { ... }
    extend public void alignControls() { ... }
    public void rebuild() { ... }
    extend public void checkStaleStatus() { ... }

    /***********************************************************************
     * Data interface
     ***********************************************************************/

    extend public void applyChanges() { ... }
    extend public PartAnnotation[] collectAttributes() { ... }

    /***********************************************************************
     * Events
     ***********************************************************************/
    
	public void shown(bool v) { ... }
    public void removeWindow()  {... }
}

class PartAttributesDialogBehavior

With the new PartAttributesDialog, a new behavior (PartAttributesDialogBehavior) has been to handle the creation and event callbacks of it's UI elements. All of its interface is extendable and take in a PartAttributesDialog as a parameter. This makes the behavior fully customizable and static (a single behavior can host multiple dialogs).

The behavior contains:

• Interface for initalizing PartAttributesDialogs SubWindows
  • initDialogEvents(PartAttributesDialog dialog)
  • initTopWindow(PartAttributesDialog dialog)
  • initDataWindow(PartAttributesDialog dialog)
  • initBottomWindow(PartAttributesDialog dialog)
  • alignControls(PartAttributesDialog dialog)
• Interface for handling different hooks:
  • checkStaleStatus(PartAttributesDialog dialog)
    • checked during postFinalizeAfterMerge hooks
    • See checkForStalePartAttributesDialogs in cm/core/part/attributes/hooks.cm
• Interface for handling dialog events:
  • onDialogShown(Object sender, Object args)
  • onDialogClosed(Object sender, Object args)
  • In these cases, Object sender should always be a PartAttributesDialog

NOTE: The standard and default behavior for a PartAttributesDialog is defined in cm/core/part/attributes/partAttributesDialogBehavior.cm as corePartAttributesBehavior. Unless customization is needed, this one should be used.

Simplified Interface

/**
 * Part Attributes Dialog Behavior.
 * Defines UI elements and their behavior in a PartAttributesDialog.
 * Designed to be static (aka one behavior can power multiple dialogs)
 */
public class PartAttributesDialogBehavior {

    /**
     * Empty Constructor.
     */
    public constructor() {}


    /**
     * Pre-Initialize of the PartAttributesDialog.
     * Called at start of @initialize in PartAttributesDialog
     * @dialog PartAttributesDialog about to initialize.
     */
    extend public void preInit(PartAttributesDialog dialog) { ... }


    /**
     * Post-Initialize of the PartAttributesDialog.
     * Called at end of @initialize in PartAttributesDialog
     * @dialog PartAttributesDialog that just initialized.
     */
    extend public void postInit(PartAttributesDialog dialog) {}


    /**
     * Before behavior change in dialog.
     * @dialog PartAttributesDialog changing behavior
     */
    extend public void beforeBehaviorChange(PartAttributesDialog dialog) { ... }


    /**
     * Unregister events events from PartAttributesDialog
     * @dialog PartAttributesDialog to remove events from
     */
    extend public void removeDialogEvents(PartAttributesDialog dialog) { ... }


    /***********************************************************************
     * Initialization/Alignment
     ***********************************************************************/

    /**
     * Initialize events for PartAttributesDialog.
     * @dialog PartAttributesDialog to init events for
     */
    extend public void initDialogEvents(PartAttributesDialog dialog) { ... }


    /**
     * Initialize top window.
     * @dialog PartAttributesDialog to initialize top window for
     * @returns SubWindow representing the top window in the dialog
     */
    extend public SubWindow initTopWindow(PartAttributesDialog dialog) { ... }


    /**
     * Initialize data window.
     * @dialog PartAttributesDialog to initialize data window for
     * @returns SubWindow representing the data (middle) window in the dialog
     */
    extend public SubWindow initDataWindow(PartAttributesDialog dialog) { ... }


    /**
     * Initialize bottom window.
     * @dialog PartAttributesDialog to initialize bottom window for
     * @returns SubWindow representing the bottom window in the dialog
     */
    extend public SubWindow initBottomWindow(PartAttributesDialog dialog) { ... }


    /**
     * Align controls within the dialogs SubWindows.
     * Called from @alignControls in @PartAttributesDialog.
     *
     * NOTE: This function is to handle alignment/sizing WITHIN the SubWindows.
     * Dialog will align the SubWindows itself.
     */
    extend public void alignControls(PartAttributesDialog dialog) { ... }


    /**
     * Check if data is stale and update UI accordingly.
     * @dialog Dialog with potentially stale data.
     */
    extend public void checkStaleStatus(PartAttributesDialog dialog) { ... }


    /**
     * Check if dialog data is stale.
     * @dialog Dialog with potentially stale data.
     * @returns true if data in dialog is stale; false if not.
     */
    extend public bool isStale(PartAttributesDialog dialog) { ... }


    /***********************************************************************
     * Hooks
     ***********************************************************************/

    /**
     * Initialize hooks for a PartAttributesDialog instance.
     * @dialog PartAttributesDialog to initialize hooks for
     */
    extend public void initHooks(PartAttributesDialog dialog) {}


    /**
     * Remove hooks for a PartAttributesDialog instance.
     * @dialog PartAttributesDialog to remove hooks from.
     */
    extend public void removeHooks(PartAttributesDialog dialog) {}


    /************************************************************
     * Dialog Event observers (responses to invoked events)
     ************************************************************/

    /**
     * Handles dialog shown event from a PartAttributesDialog.
     * @sender Source of the event
     * @args Event arguments
     */
    extend public void onDialogShown(Object sender, Object args) { ... }


    /**
     * Handles dialog closed event from a PartAttributesDialog.
     * @sender Source of the event
     * @args Event arguments
     */
    extend public void onDialogClosed(Object sender, Object args) { ... }
}

class PartAttributeNoteColumn

With the new Attribute Note column in Calculations, the class PartAttributeNoteColumn has been made. It extends the new PartAttributeColumn base class and only overrides the public Object value(..) function to provide a Parts attribute note values.

Interface

/**
 * Part Attribute Note column.
 */
public class PartAttributeNoteColumn extends PartAttributeColumn {

    /**
     * Constructor.
     */
    public constructor() {
	super("attributeNote");
    }


    /**
     * Return property value for part.
     */
    public Object value(Part part, Space space) {
        PartAnnotation[] attributes = annotations(part);
        if (attributes.empty()) return null;

        str[] notes();
        for (att in attributes) {
            notes << att.note;
        }
        return notes;
    }
}

class PartAttributeCalcGridCell

With the creation of the new PartAttributesDialog and PartAttributeColumns in Calculations, this grid cell type has been created. The only purpose of this cell is to open a PartAttributesDialog on double-click of the cell. It is used for the new PartAttributeColumns.

Interface

/**
 * Grid cell for a Part Attribute Note/Description Columns.
 */
public class PartAttributeCalcGridCell extends CalcGridCell {

    /**
     * Open cell.
     * Opens PartAttributesDialog for Part line.
     */
    public bool open(GridWindow gw) { ... }
}

class PartAttributesGridBuilderEnv

With the new PartAttributesDialog, a PartAttributesGridBuilderEnv has been made to aid in the building of the dialog's grid. The dialog uses a GridBuilder that is supplied the new PartAttributesGridBuilderEnv to provide the specific columns and GridCells appropriate for the part attribute data.

Use Case

In cm/core/part/attributes/partAttributesDataWindow.cm

/**
 * Initialize grid.
 */
extend public ScrollableGridWindow initGrid() {
	ScrollableGridWindow grid(parent=this, key=cPartAttributeGridKey, callback=function dataWindowControlCb);

	GridBuilder builder(env=PartAttributesGridBuilderEnv());
	?Object[] attributes = partAttributesDialog.?attributes();
	builder.populateGridWindow(attributes, grid);

	return grid;
}

The builder environment provides:

• The Attribute Note and Attribute Description for the grid columns
• A sequence of PartAttributesGridCells for the grid rows

Interface

/**
 * Env for building PartAnnotation(s) grid in
 * PartAttributesDialog.
 */
public class PartAttributesGridBuilderEnv extends GridBuilderEnv {

    /**
     * Columns labels to display in the grid.
     * @return A seq of column names.
     */
    public str[] columns() {
        return [$attributeNotePartColumnLabel, $attributeDescriptionPartColumnLabel];
    }
    

    /**
     * Generates the cells for a single row.
     * @data The object representing the row data.
     * @return A seq of GridCells for the row.
     */
    public GridCell[] getRowCells(Object data) {
        if (data as PartAnnotation) {
            PartAttributesGridCell noteCell(data.note, align=alignment.left);
            PartAttributesGridCell descCell(data.description, align=alignment.left);
            return [GridCell: noteCell, descCell];
        }
        return null;
    }
}

functions.cm

Part Attributes Dialog Interface

With the addition of the new PartAttributesDialog, simple interface for opening a Parts attributes dialog as well as some helper functions have been added in cm/core/part/attributes/functions.cm.

Notable interfaces

/**
 * Get PartAttributesDialog instance for a Part
 * (if none are already active).
 * @part Part for dialog
 * @parent parent window of PartAttributesDialog
 */
public PartAttributesDialog partAttributesDialog(Part part, Window parent=session.mainWindow()) { ... }


/**
 * Get PartAttributesDialog instance for a PropObj
 * (if none are already active).
 * @env PartAttributesDialogDataEnv containing PropObj owner
 * @behavior PartAttributesDialogBehavior for PartAttributesDialog
 * @parent parent window of PartAttributesDialog
 * @dialogLabel label for PartAttributesDialog
 */
public PartAttributesDialog partAttributesDialog(Part part, PartAttributesDialogBehavior behavior, Window parent=session.mainWindow()) { ... }


/**
 * Currently active PartAttributesDialogs.
 */
public PartAttributesDialog{} activePartAttributesDialogs() { ... }


/**
 * Get active PartAttributesDialog for Part.
 * Compares flattenableKeys for matching.
 * @part Part instance to get active dialog for
 */
public PartAttributesDialog getActivePartAttributesDialog(Part part) { ... }

# PartTagDialog
Added: extend public void rebuildLabel(PartTagTree tree, bool isInCollWorldG2=false) 

# PTCategoryItem 
Added: extend public void rebuildLabel(PartTagTree tree, bool isInCollWorldG2=false) 

# PTTagItem 
Added: extend public void rebuildLabel(PartTagTree tree, bool isInCollWorldG2=false) 

Undo history dialog

Added a new developer tool called "Undo history" intended to aid in debugging the undo chain. It is a dialog window that lists all active undo/redo steps in the current world, as well as the undo op's they consist of.

It includes functionality to undo multiple steps at once, clear all steps, delete individual steps and the possibility to dump the undo chain to the log. The tool can be found at "CET main menu > Debug > Undo history ...".