//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
//  THIS FILE IS GENERATED BY EASY BINDINGS, DO NOT MODIFY IT
//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

import Cocoa

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mComponentPadName : AnyObject {
  var mComponentPadName : String { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mPadIndex : AnyObject {
  var mPadIndex : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mX : AnyObject {
  var mX : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mY : AnyObject {
  var mY : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mDefaultHoleDiameterUnit : AnyObject {
  var mDefaultHoleDiameterUnit : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mCustomHoleDiameter : AnyObject {
  var mCustomHoleDiameter : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mCustomHoleDiameterUnit : AnyObject {
  var mCustomHoleDiameterUnit : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mUsesCustomHoleDiameter : AnyObject {
  var mUsesCustomHoleDiameter : Bool { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mDefaultPadDiameterUnit : AnyObject {
  var mDefaultPadDiameterUnit : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mCustomPadDiameter : AnyObject {
  var mCustomPadDiameter : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mCustomPadDiameterUnit : AnyObject {
  var mCustomPadDiameterUnit : Int { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_mUsesCustomPadDiameter : AnyObject {
  var mUsesCustomPadDiameter : Bool { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_isConnectedToSomePad : AnyObject {
  var isConnectedToSomePad : Bool? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_location : AnyObject {
  var location : CanariPoint? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_netNameFromComponentPad : AnyObject {
  var netNameFromComponentPad : String? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_netNameAndPadLocation : AnyObject {
  var netNameAndPadLocation : RastnetInfoArray? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_side : AnyObject {
  var side : ConnectorSide? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_isVia : AnyObject {
  var isVia : Bool? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_issues : AnyObject {
  var issues : CanariIssueArray? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_viaDefaultHoleDiameter : AnyObject {
  var viaDefaultHoleDiameter : Int? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_viaDefaultPadDiameter : AnyObject {
  var viaDefaultPadDiameter : Int? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_netNameFromTracks : AnyObject {
  var netNameFromTracks : String? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_netClassName : AnyObject {
  var netClassName : String? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_connectedToComponent : AnyObject {
  var connectedToComponent : Bool? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_actualHoleDiameter : AnyObject {
  var actualHoleDiameter : Int? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_actualPadDiameter : AnyObject {
  var actualPadDiameter : Int? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_objectDisplay : AnyObject {
  var objectDisplay : EBShape? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_selectionDisplay : AnyObject {
  var selectionDisplay : EBShape? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

protocol BoardConnector_signatureForERCChecking : AnyObject {
  var signatureForERCChecking : UInt32? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
//    Entity: BoardConnector
//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

final class BoardConnector : BoardObject,
         BoardConnector_mComponentPadName,
         BoardConnector_mPadIndex,
         BoardConnector_mX,
         BoardConnector_mY,
         BoardConnector_mDefaultHoleDiameterUnit,
         BoardConnector_mCustomHoleDiameter,
         BoardConnector_mCustomHoleDiameterUnit,
         BoardConnector_mUsesCustomHoleDiameter,
         BoardConnector_mDefaultPadDiameterUnit,
         BoardConnector_mCustomPadDiameter,
         BoardConnector_mCustomPadDiameterUnit,
         BoardConnector_mUsesCustomPadDiameter,
         BoardConnector_isConnectedToSomePad,
         BoardConnector_location,
         BoardConnector_netNameFromComponentPad,
         BoardConnector_netNameAndPadLocation,
         BoardConnector_side,
         BoardConnector_isVia,
         BoardConnector_issues,
         BoardConnector_viaDefaultHoleDiameter,
         BoardConnector_viaDefaultPadDiameter,
         BoardConnector_netNameFromTracks,
         BoardConnector_netClassName,
         BoardConnector_connectedToComponent,
         BoardConnector_actualHoleDiameter,
         BoardConnector_actualPadDiameter,
         BoardConnector_objectDisplay,
         BoardConnector_selectionDisplay,
         BoardConnector_signatureForERCChecking {

  //····················································································································
  //   Atomic property: mComponentPadName
  //····················································································································

  final let mComponentPadName_property : EBStoredProperty_String

  //····················································································································

  final func reset_mComponentPadName_toDefaultValue () {
    self.mComponentPadName = ""
  }

  //····················································································································

  final var mComponentPadName : String {
    get { return self.mComponentPadName_property.propval }
    set { self.mComponentPadName_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mPadIndex
  //····················································································································

  final let mPadIndex_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mPadIndex_toDefaultValue () {
    self.mPadIndex = 0
  }

  //····················································································································

  final var mPadIndex : Int {
    get { return self.mPadIndex_property.propval }
    set { self.mPadIndex_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mX
  //····················································································································

  final let mX_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mX_toDefaultValue () {
    self.mX = 0
  }

  //····················································································································

  final var mX : Int {
    get { return self.mX_property.propval }
    set { self.mX_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mY
  //····················································································································

  final let mY_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mY_toDefaultValue () {
    self.mY = 0
  }

  //····················································································································

  final var mY : Int {
    get { return self.mY_property.propval }
    set { self.mY_property.setProp (newValue) }
  }

  //····················································································································
  //   To many property: mTracksP2
  //····················································································································

  final let mTracksP2_property = StoredArrayOf_BoardTrack (usedForSignature: false)

  //····················································································································

  //····················································································································

  final var mTracksP2 : EBReferenceArray <BoardTrack> {
    get { return self.mTracksP2_property.propval }
    set { self.mTracksP2_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mDefaultHoleDiameterUnit
  //····················································································································

  final let mDefaultHoleDiameterUnit_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mDefaultHoleDiameterUnit_toDefaultValue () {
    self.mDefaultHoleDiameterUnit = 2286
  }

  //····················································································································

  final var mDefaultHoleDiameterUnit : Int {
    get { return self.mDefaultHoleDiameterUnit_property.propval }
    set { self.mDefaultHoleDiameterUnit_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mCustomHoleDiameter
  //····················································································································

  final let mCustomHoleDiameter_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mCustomHoleDiameter_toDefaultValue () {
    self.mCustomHoleDiameter = 45720
  }

  //····················································································································

  final var mCustomHoleDiameter : Int {
    get { return self.mCustomHoleDiameter_property.propval }
    set { self.mCustomHoleDiameter_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mCustomHoleDiameterUnit
  //····················································································································

  final let mCustomHoleDiameterUnit_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mCustomHoleDiameterUnit_toDefaultValue () {
    self.mCustomHoleDiameterUnit = 2286
  }

  //····················································································································

  final var mCustomHoleDiameterUnit : Int {
    get { return self.mCustomHoleDiameterUnit_property.propval }
    set { self.mCustomHoleDiameterUnit_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mUsesCustomHoleDiameter
  //····················································································································

  final let mUsesCustomHoleDiameter_property : EBStoredProperty_Bool

  //····················································································································

  final func reset_mUsesCustomHoleDiameter_toDefaultValue () {
    self.mUsesCustomHoleDiameter = false
  }

  //····················································································································

  final var mUsesCustomHoleDiameter : Bool {
    get { return self.mUsesCustomHoleDiameter_property.propval }
    set { self.mUsesCustomHoleDiameter_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mDefaultPadDiameterUnit
  //····················································································································

  final let mDefaultPadDiameterUnit_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mDefaultPadDiameterUnit_toDefaultValue () {
    self.mDefaultPadDiameterUnit = 2286
  }

  //····················································································································

  final var mDefaultPadDiameterUnit : Int {
    get { return self.mDefaultPadDiameterUnit_property.propval }
    set { self.mDefaultPadDiameterUnit_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mCustomPadDiameter
  //····················································································································

  final let mCustomPadDiameter_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mCustomPadDiameter_toDefaultValue () {
    self.mCustomPadDiameter = 91440
  }

  //····················································································································

  final var mCustomPadDiameter : Int {
    get { return self.mCustomPadDiameter_property.propval }
    set { self.mCustomPadDiameter_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mCustomPadDiameterUnit
  //····················································································································

  final let mCustomPadDiameterUnit_property : EBStoredProperty_Int

  //····················································································································

  final func reset_mCustomPadDiameterUnit_toDefaultValue () {
    self.mCustomPadDiameterUnit = 2286
  }

  //····················································································································

  final var mCustomPadDiameterUnit : Int {
    get { return self.mCustomPadDiameterUnit_property.propval }
    set { self.mCustomPadDiameterUnit_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mUsesCustomPadDiameter
  //····················································································································

  final let mUsesCustomPadDiameter_property : EBStoredProperty_Bool

  //····················································································································

  final func reset_mUsesCustomPadDiameter_toDefaultValue () {
    self.mUsesCustomPadDiameter = false
  }

  //····················································································································

  final var mUsesCustomPadDiameter : Bool {
    get { return self.mUsesCustomPadDiameter_property.propval }
    set { self.mUsesCustomPadDiameter_property.setProp (newValue) }
  }

  //····················································································································
  //   To many property: mTracksP1
  //····················································································································

  final let mTracksP1_property = StoredArrayOf_BoardTrack (usedForSignature: false)

  //····················································································································

  //····················································································································

  final var mTracksP1 : EBReferenceArray <BoardTrack> {
    get { return self.mTracksP1_property.propval }
    set { self.mTracksP1_property.setProp (newValue) }
  }

  //····················································································································
  //   Transient property: isConnectedToSomePad
  //····················································································································

  final let isConnectedToSomePad_property = EBTransientProperty_Bool ()

  //····················································································································

  final var isConnectedToSomePad : Bool? {
    switch self.isConnectedToSomePad_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   To one property: mComponent
  //····················································································································

  final let mComponent_property = StoredObject_ComponentInProject (usedForSignature: false)

  //····················································································································

  final var mComponent : ComponentInProject? {
    get {
      return self.mComponent_property.propval
    }
    set {
      if self.mComponent_property.propval != nil {
        self.mComponent_property.setProp (nil)
      }
      if newValue != nil {
        self.mComponent_property.setProp (newValue)
      }
    }
  }

  //····················································································································

  final let mComponent_none = EBGenericTransientProperty <Bool> ()

  //····················································································································
  //   Transient property: location
  //····················································································································

  final let location_property = EBTransientProperty_CanariPoint ()

  //····················································································································

  final var location : CanariPoint? {
    switch self.location_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: netNameFromComponentPad
  //····················································································································

  final let netNameFromComponentPad_property = EBTransientProperty_String ()

  //····················································································································

  final var netNameFromComponentPad : String? {
    switch self.netNameFromComponentPad_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: side
  //····················································································································

  final let side_property = EBTransientProperty_ConnectorSide ()

  //····················································································································

  final var side : ConnectorSide? {
    switch self.side_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: viaDefaultHoleDiameter
  //····················································································································

  final let viaDefaultHoleDiameter_property = EBTransientProperty_Int ()

  //····················································································································

  final var viaDefaultHoleDiameter : Int? {
    switch self.viaDefaultHoleDiameter_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: viaDefaultPadDiameter
  //····················································································································

  final let viaDefaultPadDiameter_property = EBTransientProperty_Int ()

  //····················································································································

  final var viaDefaultPadDiameter : Int? {
    switch self.viaDefaultPadDiameter_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: netNameFromTracks
  //····················································································································

  final let netNameFromTracks_property = EBTransientProperty_String ()

  //····················································································································

  final var netNameFromTracks : String? {
    switch self.netNameFromTracks_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: netClassName
  //····················································································································

  final let netClassName_property = EBTransientProperty_String ()

  //····················································································································

  final var netClassName : String? {
    switch self.netClassName_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: connectedToComponent
  //····················································································································

  final let connectedToComponent_property = EBTransientProperty_Bool ()

  //····················································································································

  final var connectedToComponent : Bool? {
    switch self.connectedToComponent_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: actualHoleDiameter
  //····················································································································

  final let actualHoleDiameter_property = EBTransientProperty_Int ()

  //····················································································································

  final var actualHoleDiameter : Int? {
    switch self.actualHoleDiameter_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: actualPadDiameter
  //····················································································································

  final let actualPadDiameter_property = EBTransientProperty_Int ()

  //····················································································································

  final var actualPadDiameter : Int? {
    switch self.actualPadDiameter_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //    init
  //····················································································································

  required init (_ ebUndoManager : EBUndoManager?) {
    self.mComponentPadName_property = EBStoredProperty_String (defaultValue: "", undoManager: ebUndoManager)
    self.mPadIndex_property = EBStoredProperty_Int (defaultValue: 0, undoManager: ebUndoManager)
    self.mX_property = EBStoredProperty_Int (defaultValue: 0, undoManager: ebUndoManager)
    self.mY_property = EBStoredProperty_Int (defaultValue: 0, undoManager: ebUndoManager)
    self.mDefaultHoleDiameterUnit_property = EBStoredProperty_Int (defaultValue: 2286, undoManager: ebUndoManager)
    self.mCustomHoleDiameter_property = EBStoredProperty_Int (defaultValue: 45720, undoManager: ebUndoManager)
    self.mCustomHoleDiameterUnit_property = EBStoredProperty_Int (defaultValue: 2286, undoManager: ebUndoManager)
    self.mUsesCustomHoleDiameter_property = EBStoredProperty_Bool (defaultValue: false, undoManager: ebUndoManager)
    self.mDefaultPadDiameterUnit_property = EBStoredProperty_Int (defaultValue: 2286, undoManager: ebUndoManager)
    self.mCustomPadDiameter_property = EBStoredProperty_Int (defaultValue: 91440, undoManager: ebUndoManager)
    self.mCustomPadDiameterUnit_property = EBStoredProperty_Int (defaultValue: 2286, undoManager: ebUndoManager)
    self.mUsesCustomPadDiameter_property = EBStoredProperty_Bool (defaultValue: false, undoManager: ebUndoManager)
    super.init (ebUndoManager)
    self.mComponent_none.mReadModelFunction = { [weak self] in // §
      if let uwSelf = self {
        return .single (uwSelf.mComponent_property.propval == nil)
      }else{
        return .empty
      }
    }
    self.mComponent_property.addEBObserver (self.mComponent_none)
  //--- To many property: mTracksP2 (has opposite relationship)
    self.mTracksP2_property.ebUndoManager = self.ebUndoManager
    self.mTracksP2_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.mConnectorP2_property.setProp (me) } },
      resetter: { inObject in inObject.mConnectorP2_property.setProp (nil) }
    )
  //--- To many property: mTracksP1 (has opposite relationship)
    self.mTracksP1_property.ebUndoManager = self.ebUndoManager
    self.mTracksP1_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.mConnectorP1_property.setProp (me) } },
      resetter: { inObject in inObject.mConnectorP1_property.setProp (nil) }
    )
  //--- Atomic property: isConnectedToSomePad
    self.isConnectedToSomePad_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponentPadName_property.selection) {
        case (.single (let v0)) :
          return .single (transient_BoardConnector_isConnectedToSomePad (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponentPadName_property.addEBObserver (self.isConnectedToSomePad_property)
  //--- To one property: mComponent (has opposite to many relationship: mConnectors)
    self.mComponent_property.ebUndoManager = self.ebUndoManager
    self.mComponent_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.mConnectors_property.add (me) } },
      resetter: { [weak self] inObject in if let me = self { inObject.mConnectors_property.remove (me) } }
    )
  //--- Atomic property: location
    self.location_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponent_property.componentPadDictionary_property.selection, unwSelf.mComponentPadName_property.selection, unwSelf.mPadIndex_property.selection, unwSelf.mX_property.selection, unwSelf.mY_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3), .single (let v4)) :
          return .single (transient_BoardConnector_location (v0, v1, v2, v3, v4))
        case (.multiple, .multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponent_property.componentPadDictionary_property.addEBObserver (self.location_property)
    self.mComponentPadName_property.addEBObserver (self.location_property)
    self.mPadIndex_property.addEBObserver (self.location_property)
    self.mX_property.addEBObserver (self.location_property)
    self.mY_property.addEBObserver (self.location_property)
  //--- Atomic property: netNameFromComponentPad
    self.netNameFromComponentPad_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponent_property.padNetDictionary_property.selection, unwSelf.mComponentPadName_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_netNameFromComponentPad (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponent_property.padNetDictionary_property.addEBObserver (self.netNameFromComponentPad_property)
    self.mComponentPadName_property.addEBObserver (self.netNameFromComponentPad_property)
  //--- Atomic property: netNameAndPadLocation
    self.netNameAndPadLocation_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponent_property.padNetDictionary_property.selection, unwSelf.mComponentPadName_property.selection, unwSelf.location_property.selection, unwSelf.mComponent_property.componentName_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3)) :
          return .single (transient_BoardConnector_netNameAndPadLocation (v0, v1, v2, v3))
        case (.multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponent_property.padNetDictionary_property.addEBObserver (self.netNameAndPadLocation_property)
    self.mComponentPadName_property.addEBObserver (self.netNameAndPadLocation_property)
    self.location_property.addEBObserver (self.netNameAndPadLocation_property)
    self.mComponent_property.componentName_property.addEBObserver (self.netNameAndPadLocation_property)
  //--- Atomic property: side
    self.side_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponent_property.componentPadDictionary_property.selection, unwSelf.mComponentPadName_property.selection, unwSelf.mPadIndex_property.selection, unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3), .single (let v4)) :
          return .single (transient_BoardConnector_side (v0, v1, v2, v3, v4))
        case (.multiple, .multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponent_property.componentPadDictionary_property.addEBObserver (self.side_property)
    self.mComponentPadName_property.addEBObserver (self.side_property)
    self.mPadIndex_property.addEBObserver (self.side_property)
    self.mTracksP1_property.addEBObserverOf_mSide (self.side_property)
    self.mTracksP2_property.addEBObserverOf_mSide (self.side_property)
  //--- Atomic property: isVia
    self.isVia_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection, unwSelf.mComponent_none.selection) {
        case (.single (let v0), .single (let v1), .single (let v2)) :
          return .single (transient_BoardConnector_isVia (v0, v1, v2))
        case (.multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mTracksP1_property.addEBObserverOf_mSide (self.isVia_property)
    self.mTracksP2_property.addEBObserverOf_mSide (self.isVia_property)
    self.mComponent_property.addEBObserver (self.isVia_property)
  //--- Atomic property: issues
    self.issues_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.location_property.selection, unwSelf.mComponent_none.selection, unwSelf.mComponentPadName_property.selection, unwSelf.mTracksP1_property.count_property.selection, unwSelf.mTracksP2_property.count_property.selection, unwSelf.errorOrWarningIssueSize_property.selection, unwSelf.mPadIndex_property.selection, unwSelf.mComponent_property.mSlavePadsShouldBeRouted_property.selection, unwSelf.mComponent_property.padNetDictionary_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3), .single (let v4), .single (let v5), .single (let v6), .single (let v7), .single (let v8)) :
          return .single (transient_BoardConnector_issues (v0, v1, v2, v3, v4, v5, v6, v7, v8))
        case (.multiple, .multiple, .multiple, .multiple, .multiple, .multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.location_property.addEBObserver (self.issues_property)
    self.mComponent_property.addEBObserver (self.issues_property)
    self.mComponentPadName_property.addEBObserver (self.issues_property)
    self.mTracksP1_property.addEBObserver (self.issues_property)
    self.mTracksP2_property.addEBObserver (self.issues_property)
    self.errorOrWarningIssueSize_property.addEBObserver (self.issues_property)
    self.mPadIndex_property.addEBObserver (self.issues_property)
    self.mComponent_property.mSlavePadsShouldBeRouted_property.addEBObserver (self.issues_property)
    self.mComponent_property.padNetDictionary_property.addEBObserver (self.issues_property)
  //--- Atomic property: viaDefaultHoleDiameter
    self.viaDefaultHoleDiameter_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_viaDefaultHoleDiameter (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mTracksP1_property.addEBObserverOf_netClassViaHoleDiameter (self.viaDefaultHoleDiameter_property)
    self.mTracksP2_property.addEBObserverOf_netClassViaHoleDiameter (self.viaDefaultHoleDiameter_property)
  //--- Atomic property: viaDefaultPadDiameter
    self.viaDefaultPadDiameter_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_viaDefaultPadDiameter (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mTracksP1_property.addEBObserverOf_netClassViaPadDiameter (self.viaDefaultPadDiameter_property)
    self.mTracksP2_property.addEBObserverOf_netClassViaPadDiameter (self.viaDefaultPadDiameter_property)
  //--- Atomic property: netNameFromTracks
    self.netNameFromTracks_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_netNameFromTracks (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mTracksP1_property.addEBObserverOf_netName (self.netNameFromTracks_property)
    self.mTracksP2_property.addEBObserverOf_netName (self.netNameFromTracks_property)
  //--- Atomic property: netClassName
    self.netClassName_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mTracksP1_property.selection, unwSelf.mTracksP2_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_netClassName (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mTracksP1_property.addEBObserverOf_netClassName (self.netClassName_property)
    self.mTracksP2_property.addEBObserverOf_netClassName (self.netClassName_property)
  //--- Atomic property: connectedToComponent
    self.connectedToComponent_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mComponent_none.selection) {
        case (.single (let v0)) :
          return .single (transient_BoardConnector_connectedToComponent (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mComponent_property.addEBObserver (self.connectedToComponent_property)
  //--- Atomic property: actualHoleDiameter
    self.actualHoleDiameter_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.viaDefaultHoleDiameter_property.selection, unwSelf.mUsesCustomHoleDiameter_property.selection, unwSelf.mCustomHoleDiameter_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2)) :
          return .single (transient_BoardConnector_actualHoleDiameter (v0, v1, v2))
        case (.multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.viaDefaultHoleDiameter_property.addEBObserver (self.actualHoleDiameter_property)
    self.mUsesCustomHoleDiameter_property.addEBObserver (self.actualHoleDiameter_property)
    self.mCustomHoleDiameter_property.addEBObserver (self.actualHoleDiameter_property)
  //--- Atomic property: actualPadDiameter
    self.actualPadDiameter_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.viaDefaultPadDiameter_property.selection, unwSelf.mUsesCustomPadDiameter_property.selection, unwSelf.mCustomPadDiameter_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2)) :
          return .single (transient_BoardConnector_actualPadDiameter (v0, v1, v2))
        case (.multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.viaDefaultPadDiameter_property.addEBObserver (self.actualPadDiameter_property)
    self.mUsesCustomPadDiameter_property.addEBObserver (self.actualPadDiameter_property)
    self.mCustomPadDiameter_property.addEBObserver (self.actualPadDiameter_property)
  //--- Atomic property: objectDisplay
    self.objectDisplay_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.isVia_property.selection, unwSelf.location_property.selection, unwSelf.actualHoleDiameter_property.selection, unwSelf.actualPadDiameter_property.selection, preferences_frontSidePadColorForBoard_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3), .single (let v4)) :
          return .single (transient_BoardConnector_objectDisplay (v0, v1, v2, v3, v4))
        case (.multiple, .multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.isVia_property.addEBObserver (self.objectDisplay_property)
    self.location_property.addEBObserver (self.objectDisplay_property)
    self.actualHoleDiameter_property.addEBObserver (self.objectDisplay_property)
    self.actualPadDiameter_property.addEBObserver (self.objectDisplay_property)
    preferences_frontSidePadColorForBoard_property.addEBObserver (self.objectDisplay_property)
  //--- Atomic property: selectionDisplay
    self.selectionDisplay_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.isVia_property.selection, unwSelf.location_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_BoardConnector_selectionDisplay (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.isVia_property.addEBObserver (self.selectionDisplay_property)
    self.location_property.addEBObserver (self.selectionDisplay_property)
  //--- Atomic property: signatureForERCChecking
    self.signatureForERCChecking_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.location_property.selection, unwSelf.isVia_property.selection, unwSelf.actualPadDiameter_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2)) :
          return .single (transient_BoardConnector_signatureForERCChecking (v0, v1, v2))
        case (.multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.location_property.addEBObserver (self.signatureForERCChecking_property)
    self.isVia_property.addEBObserver (self.signatureForERCChecking_property)
    self.actualPadDiameter_property.addEBObserver (self.signatureForERCChecking_property)
  //--- Install undoers and opposite setter for relationships
    self.mTracksP2_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.mConnectorP2_property.setProp (me) } },
      resetter: { inObject in inObject.mConnectorP2_property.setProp (nil) }
    )
    self.mTracksP1_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.mConnectorP1_property.setProp (me) } },
      resetter: { inObject in inObject.mConnectorP1_property.setProp (nil) }
    )
  //--- Register properties for handling signature
  //--- Extern delegates
  }

  //····················································································································

  override internal func removeAllObservers () {
    super.removeAllObservers ()
    // self.mComponentPadName_property.removeEBObserver (self.isConnectedToSomePad_property)
    // self.mComponent_property.componentPadDictionary_property.removeEBObserver (self.location_property)
    // self.mComponentPadName_property.removeEBObserver (self.location_property)
    // self.mPadIndex_property.removeEBObserver (self.location_property)
    // self.mX_property.removeEBObserver (self.location_property)
    // self.mY_property.removeEBObserver (self.location_property)
    // self.mComponent_property.padNetDictionary_property.removeEBObserver (self.netNameFromComponentPad_property)
    // self.mComponentPadName_property.removeEBObserver (self.netNameFromComponentPad_property)
    // self.mComponent_property.padNetDictionary_property.removeEBObserver (self.netNameAndPadLocation_property)
    // self.mComponentPadName_property.removeEBObserver (self.netNameAndPadLocation_property)
    // self.location_property.removeEBObserver (self.netNameAndPadLocation_property)
    // self.mComponent_property.componentName_property.removeEBObserver (self.netNameAndPadLocation_property)
    // self.mComponent_property.componentPadDictionary_property.removeEBObserver (self.side_property)
    // self.mComponentPadName_property.removeEBObserver (self.side_property)
    // self.mPadIndex_property.removeEBObserver (self.side_property)
    // self.mTracksP1_property.removeEBObserverOf_mSide (self.side_property)
    // self.mTracksP2_property.removeEBObserverOf_mSide (self.side_property)
    // self.mTracksP1_property.removeEBObserverOf_mSide (self.isVia_property)
    // self.mTracksP2_property.removeEBObserverOf_mSide (self.isVia_property)
    // self.mComponent_property.removeEBObserver (self.isVia_property)
    // self.location_property.removeEBObserver (self.issues_property)
    // self.mComponent_property.removeEBObserver (self.issues_property)
    // self.mComponentPadName_property.removeEBObserver (self.issues_property)
    // self.mTracksP1_property.removeEBObserver (self.issues_property)
    // self.mTracksP2_property.removeEBObserver (self.issues_property)
    // self.errorOrWarningIssueSize_property.removeEBObserver (self.issues_property)
    // self.mPadIndex_property.removeEBObserver (self.issues_property)
    // self.mComponent_property.mSlavePadsShouldBeRouted_property.removeEBObserver (self.issues_property)
    // self.mComponent_property.padNetDictionary_property.removeEBObserver (self.issues_property)
    // self.mTracksP1_property.removeEBObserverOf_netClassViaHoleDiameter (self.viaDefaultHoleDiameter_property)
    // self.mTracksP2_property.removeEBObserverOf_netClassViaHoleDiameter (self.viaDefaultHoleDiameter_property)
    // self.mTracksP1_property.removeEBObserverOf_netClassViaPadDiameter (self.viaDefaultPadDiameter_property)
    // self.mTracksP2_property.removeEBObserverOf_netClassViaPadDiameter (self.viaDefaultPadDiameter_property)
    // self.mTracksP1_property.removeEBObserverOf_netName (self.netNameFromTracks_property)
    // self.mTracksP2_property.removeEBObserverOf_netName (self.netNameFromTracks_property)
    // self.mTracksP1_property.removeEBObserverOf_netClassName (self.netClassName_property)
    // self.mTracksP2_property.removeEBObserverOf_netClassName (self.netClassName_property)
    // self.mComponent_property.removeEBObserver (self.connectedToComponent_property)
    // self.viaDefaultHoleDiameter_property.removeEBObserver (self.actualHoleDiameter_property)
    // self.mUsesCustomHoleDiameter_property.removeEBObserver (self.actualHoleDiameter_property)
    // self.mCustomHoleDiameter_property.removeEBObserver (self.actualHoleDiameter_property)
    // self.viaDefaultPadDiameter_property.removeEBObserver (self.actualPadDiameter_property)
    // self.mUsesCustomPadDiameter_property.removeEBObserver (self.actualPadDiameter_property)
    // self.mCustomPadDiameter_property.removeEBObserver (self.actualPadDiameter_property)
    // self.isVia_property.removeEBObserver (self.objectDisplay_property)
    // self.location_property.removeEBObserver (self.objectDisplay_property)
    // self.actualHoleDiameter_property.removeEBObserver (self.objectDisplay_property)
    // self.actualPadDiameter_property.removeEBObserver (self.objectDisplay_property)
    // preferences_frontSidePadColorForBoard_property.removeEBObserver (self.objectDisplay_property)
    // self.isVia_property.removeEBObserver (self.selectionDisplay_property)
    // self.location_property.removeEBObserver (self.selectionDisplay_property)
    // self.location_property.removeEBObserver (self.signatureForERCChecking_property)
    // self.isVia_property.removeEBObserver (self.signatureForERCChecking_property)
    // self.actualPadDiameter_property.removeEBObserver (self.signatureForERCChecking_property)
  //--- Unregister properties for handling signature
  }

  //····················································································································
  //    Extern delegates
  //····················································································································


  //····················································································································
  //    populateExplorerWindow
  //····················································································································

  #if BUILD_OBJECT_EXPLORER
    override func populateExplorerWindow (_ y : inout CGFloat, view : NSView) {
      super.populateExplorerWindow (&y, view:view)
      createEntryForPropertyNamed (
        "mComponentPadName",
        object: self.mComponentPadName_property,
        y: &y,
        view: view,
        observerExplorer: &self.mComponentPadName_property.mObserverExplorer,
        valueExplorer: &self.mComponentPadName_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mPadIndex",
        object: self.mPadIndex_property,
        y: &y,
        view: view,
        observerExplorer: &self.mPadIndex_property.mObserverExplorer,
        valueExplorer: &self.mPadIndex_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mX",
        object: self.mX_property,
        y: &y,
        view: view,
        observerExplorer: &self.mX_property.mObserverExplorer,
        valueExplorer: &self.mX_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mY",
        object: self.mY_property,
        y: &y,
        view: view,
        observerExplorer: &self.mY_property.mObserverExplorer,
        valueExplorer: &self.mY_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mDefaultHoleDiameterUnit",
        object: self.mDefaultHoleDiameterUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.mDefaultHoleDiameterUnit_property.mObserverExplorer,
        valueExplorer: &self.mDefaultHoleDiameterUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mCustomHoleDiameter",
        object: self.mCustomHoleDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.mCustomHoleDiameter_property.mObserverExplorer,
        valueExplorer: &self.mCustomHoleDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mCustomHoleDiameterUnit",
        object: self.mCustomHoleDiameterUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.mCustomHoleDiameterUnit_property.mObserverExplorer,
        valueExplorer: &self.mCustomHoleDiameterUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mUsesCustomHoleDiameter",
        object: self.mUsesCustomHoleDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.mUsesCustomHoleDiameter_property.mObserverExplorer,
        valueExplorer: &self.mUsesCustomHoleDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mDefaultPadDiameterUnit",
        object: self.mDefaultPadDiameterUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.mDefaultPadDiameterUnit_property.mObserverExplorer,
        valueExplorer: &self.mDefaultPadDiameterUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mCustomPadDiameter",
        object: self.mCustomPadDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.mCustomPadDiameter_property.mObserverExplorer,
        valueExplorer: &self.mCustomPadDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mCustomPadDiameterUnit",
        object: self.mCustomPadDiameterUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.mCustomPadDiameterUnit_property.mObserverExplorer,
        valueExplorer: &self.mCustomPadDiameterUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mUsesCustomPadDiameter",
        object: self.mUsesCustomPadDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.mUsesCustomPadDiameter_property.mObserverExplorer,
        valueExplorer: &self.mUsesCustomPadDiameter_property.mValueExplorer
      )
      createEntryForTitle ("Properties", y: &y, view: view)
      createEntryForPropertyNamed (
        "isConnectedToSomePad",
        object: self.isConnectedToSomePad_property,
        y: &y,
        view: view,
        observerExplorer: &self.isConnectedToSomePad_property.mObserverExplorer,
        valueExplorer: &self.isConnectedToSomePad_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "location",
        object: self.location_property,
        y: &y,
        view: view,
        observerExplorer: &self.location_property.mObserverExplorer,
        valueExplorer: &self.location_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "netNameFromComponentPad",
        object: self.netNameFromComponentPad_property,
        y: &y,
        view: view,
        observerExplorer: &self.netNameFromComponentPad_property.mObserverExplorer,
        valueExplorer: &self.netNameFromComponentPad_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "netNameAndPadLocation",
        object: self.netNameAndPadLocation_property,
        y: &y,
        view: view,
        observerExplorer: &self.netNameAndPadLocation_property.mObserverExplorer,
        valueExplorer: &self.netNameAndPadLocation_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "side",
        object: self.side_property,
        y: &y,
        view: view,
        observerExplorer: &self.side_property.mObserverExplorer,
        valueExplorer: &self.side_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "isVia",
        object: self.isVia_property,
        y: &y,
        view: view,
        observerExplorer: &self.isVia_property.mObserverExplorer,
        valueExplorer: &self.isVia_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "issues",
        object: self.issues_property,
        y: &y,
        view: view,
        observerExplorer: &self.issues_property.mObserverExplorer,
        valueExplorer: &self.issues_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "viaDefaultHoleDiameter",
        object: self.viaDefaultHoleDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.viaDefaultHoleDiameter_property.mObserverExplorer,
        valueExplorer: &self.viaDefaultHoleDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "viaDefaultPadDiameter",
        object: self.viaDefaultPadDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.viaDefaultPadDiameter_property.mObserverExplorer,
        valueExplorer: &self.viaDefaultPadDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "netNameFromTracks",
        object: self.netNameFromTracks_property,
        y: &y,
        view: view,
        observerExplorer: &self.netNameFromTracks_property.mObserverExplorer,
        valueExplorer: &self.netNameFromTracks_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "netClassName",
        object: self.netClassName_property,
        y: &y,
        view: view,
        observerExplorer: &self.netClassName_property.mObserverExplorer,
        valueExplorer: &self.netClassName_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "connectedToComponent",
        object: self.connectedToComponent_property,
        y: &y,
        view: view,
        observerExplorer: &self.connectedToComponent_property.mObserverExplorer,
        valueExplorer: &self.connectedToComponent_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "actualHoleDiameter",
        object: self.actualHoleDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.actualHoleDiameter_property.mObserverExplorer,
        valueExplorer: &self.actualHoleDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "actualPadDiameter",
        object: self.actualPadDiameter_property,
        y: &y,
        view: view,
        observerExplorer: &self.actualPadDiameter_property.mObserverExplorer,
        valueExplorer: &self.actualPadDiameter_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "objectDisplay",
        object: self.objectDisplay_property,
        y: &y,
        view: view,
        observerExplorer: &self.objectDisplay_property.mObserverExplorer,
        valueExplorer: &self.objectDisplay_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "selectionDisplay",
        object: self.selectionDisplay_property,
        y: &y,
        view: view,
        observerExplorer: &self.selectionDisplay_property.mObserverExplorer,
        valueExplorer: &self.selectionDisplay_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "signatureForERCChecking",
        object: self.signatureForERCChecking_property,
        y: &y,
        view: view,
        observerExplorer: &self.signatureForERCChecking_property.mObserverExplorer,
        valueExplorer: &self.signatureForERCChecking_property.mValueExplorer
      )
      createEntryForTitle ("Transients", y: &y, view: view)
      createEntryForToManyRelationshipNamed (
        "mTracksP2",
        object: mTracksP2_property,
        y: &y,
        view: view,
        valueExplorer:&mTracksP2_property.mValueExplorer
      )
      createEntryForToManyRelationshipNamed (
        "mTracksP1",
        object: mTracksP1_property,
        y: &y,
        view: view,
        valueExplorer:&mTracksP1_property.mValueExplorer
      )
      createEntryForTitle ("ToMany Relationships", y: &y, view: view)
      createEntryForToOneRelationshipNamed (
        "mComponent",
        object: self.mComponent_property,
        y: &y,
        view: view,
        valueExplorer:&self.mComponent_property.mValueExplorer
      )
      createEntryForTitle ("ToOne Relationships", y: &y, view: view)
    }
  #endif

  //····················································································································
  //    clearObjectExplorer
  //····················································································································

  #if BUILD_OBJECT_EXPLORER
    override func clearObjectExplorer () {
  //--- Atomic property: mComponentPadName
    self.mComponentPadName_property.mObserverExplorer = nil
    self.mComponentPadName_property.mValueExplorer = nil
  //--- Atomic property: mPadIndex
    self.mPadIndex_property.mObserverExplorer = nil
    self.mPadIndex_property.mValueExplorer = nil
  //--- Atomic property: mX
    self.mX_property.mObserverExplorer = nil
    self.mX_property.mValueExplorer = nil
  //--- Atomic property: mY
    self.mY_property.mObserverExplorer = nil
    self.mY_property.mValueExplorer = nil
    //--- To many property: mTracksP2
      self.mTracksP2_property.mValueExplorer = nil
  //--- Atomic property: mDefaultHoleDiameterUnit
    self.mDefaultHoleDiameterUnit_property.mObserverExplorer = nil
    self.mDefaultHoleDiameterUnit_property.mValueExplorer = nil
  //--- Atomic property: mCustomHoleDiameter
    self.mCustomHoleDiameter_property.mObserverExplorer = nil
    self.mCustomHoleDiameter_property.mValueExplorer = nil
  //--- Atomic property: mCustomHoleDiameterUnit
    self.mCustomHoleDiameterUnit_property.mObserverExplorer = nil
    self.mCustomHoleDiameterUnit_property.mValueExplorer = nil
  //--- Atomic property: mUsesCustomHoleDiameter
    self.mUsesCustomHoleDiameter_property.mObserverExplorer = nil
    self.mUsesCustomHoleDiameter_property.mValueExplorer = nil
  //--- Atomic property: mDefaultPadDiameterUnit
    self.mDefaultPadDiameterUnit_property.mObserverExplorer = nil
    self.mDefaultPadDiameterUnit_property.mValueExplorer = nil
  //--- Atomic property: mCustomPadDiameter
    self.mCustomPadDiameter_property.mObserverExplorer = nil
    self.mCustomPadDiameter_property.mValueExplorer = nil
  //--- Atomic property: mCustomPadDiameterUnit
    self.mCustomPadDiameterUnit_property.mObserverExplorer = nil
    self.mCustomPadDiameterUnit_property.mValueExplorer = nil
  //--- Atomic property: mUsesCustomPadDiameter
    self.mUsesCustomPadDiameter_property.mObserverExplorer = nil
    self.mUsesCustomPadDiameter_property.mValueExplorer = nil
    //--- To many property: mTracksP1
      self.mTracksP1_property.mValueExplorer = nil
    //--- To one property: mComponent
      self.mComponent_property.mObserverExplorer = nil
      self.mComponent_property.mValueExplorer = nil
    //---
      super.clearObjectExplorer ()
    }
  #endif

  //····················································································································
  //    cleanUpToManyRelationships
  //····················································································································

  override internal func cleanUpToManyRelationships () {
    self.mTracksP2.removeAll ()
    self.mTracksP1.removeAll ()
  //---
    super.cleanUpToManyRelationships ()
  }

  //····················································································································
  //    cleanUpToOneRelationships
  //····················································································································

  override internal func cleanUpToOneRelationships () {
    self.mComponent = nil
  //---
    super.cleanUpToOneRelationships ()
  }

  //····················································································································
  //    saveIntoDictionary
  //····················································································································

  override func saveIntoDictionary (_ ioDictionary : NSMutableDictionary) {
    super.saveIntoDictionary (ioDictionary)
    //--- Atomic property: mComponentPadName
      self.mComponentPadName_property.storeIn (dictionary: ioDictionary, forKey: "mComponentPadName")
    //--- Atomic property: mPadIndex
      self.mPadIndex_property.storeIn (dictionary: ioDictionary, forKey: "mPadIndex")
    //--- Atomic property: mX
      self.mX_property.storeIn (dictionary: ioDictionary, forKey: "mX")
    //--- Atomic property: mY
      self.mY_property.storeIn (dictionary: ioDictionary, forKey: "mY")
  //--- To many property: mTracksP2
    self.store (
      managedObjectArray: self.mTracksP2_property.propval.values,
      relationshipName: "mTracksP2",
      intoDictionary: ioDictionary
    )
    //--- Atomic property: mDefaultHoleDiameterUnit
      self.mDefaultHoleDiameterUnit_property.storeIn (dictionary: ioDictionary, forKey: "mDefaultHoleDiameterUnit")
    //--- Atomic property: mCustomHoleDiameter
      self.mCustomHoleDiameter_property.storeIn (dictionary: ioDictionary, forKey: "mCustomHoleDiameter")
    //--- Atomic property: mCustomHoleDiameterUnit
      self.mCustomHoleDiameterUnit_property.storeIn (dictionary: ioDictionary, forKey: "mCustomHoleDiameterUnit")
    //--- Atomic property: mUsesCustomHoleDiameter
      self.mUsesCustomHoleDiameter_property.storeIn (dictionary: ioDictionary, forKey: "mUsesCustomHoleDiameter")
    //--- Atomic property: mDefaultPadDiameterUnit
      self.mDefaultPadDiameterUnit_property.storeIn (dictionary: ioDictionary, forKey: "mDefaultPadDiameterUnit")
    //--- Atomic property: mCustomPadDiameter
      self.mCustomPadDiameter_property.storeIn (dictionary: ioDictionary, forKey: "mCustomPadDiameter")
    //--- Atomic property: mCustomPadDiameterUnit
      self.mCustomPadDiameterUnit_property.storeIn (dictionary: ioDictionary, forKey: "mCustomPadDiameterUnit")
    //--- Atomic property: mUsesCustomPadDiameter
      self.mUsesCustomPadDiameter_property.storeIn (dictionary: ioDictionary, forKey: "mUsesCustomPadDiameter")
  //--- To many property: mTracksP1
    self.store (
      managedObjectArray: self.mTracksP1_property.propval.values,
      relationshipName: "mTracksP1",
      intoDictionary: ioDictionary
    )
  }

  //····················································································································
  //    setUpWithDictionary
  //····················································································································

  override func setUpWithDictionary (_ inDictionary : NSDictionary,
                                     managedObjectArray : inout [EBManagedObject]) {
    super.setUpWithDictionary (inDictionary, managedObjectArray: &managedObjectArray)
  //--- To many property: mTracksP2
/*    self.mTracksP2_property.setProp (readEntityArrayFromDictionary (
      inRelationshipName: "mTracksP2",
      inDictionary: inDictionary,
      managedObjectArray: &managedObjectArray
    ) as! [BoardTrack]) */
    do{
      let array = readEntityArrayFromDictionary (
        inRelationshipName: "mTracksP2",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      ) as! [BoardTrack]
      self.mTracksP2_property.setProp (EBReferenceArray (array))
    }
  //--- To many property: mTracksP1
/*    self.mTracksP1_property.setProp (readEntityArrayFromDictionary (
      inRelationshipName: "mTracksP1",
      inDictionary: inDictionary,
      managedObjectArray: &managedObjectArray
    ) as! [BoardTrack]) */
    do{
      let array = readEntityArrayFromDictionary (
        inRelationshipName: "mTracksP1",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      ) as! [BoardTrack]
      self.mTracksP1_property.setProp (EBReferenceArray (array))
    }
  //--- To one property: mComponent
    do{
      let possibleEntity = readEntityFromDictionary (
        inRelationshipName: "mComponent",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      )
      if let entity = possibleEntity as? ComponentInProject {
        self.mComponent_property.setProp (entity)
      }
    }
  }

  //····················································································································
  //    setUpAtomicPropertiesWithDictionary
  //····················································································································

  override func setUpAtomicPropertiesWithDictionary (_ inDictionary : NSDictionary) {
    super.setUpAtomicPropertiesWithDictionary (inDictionary)
  //--- Atomic property: mComponentPadName
    self.mComponentPadName_property.readFrom (dictionary: inDictionary, forKey: "mComponentPadName")
  //--- Atomic property: mPadIndex
    self.mPadIndex_property.readFrom (dictionary: inDictionary, forKey: "mPadIndex")
  //--- Atomic property: mX
    self.mX_property.readFrom (dictionary: inDictionary, forKey: "mX")
  //--- Atomic property: mY
    self.mY_property.readFrom (dictionary: inDictionary, forKey: "mY")
  //--- Atomic property: mDefaultHoleDiameterUnit
    self.mDefaultHoleDiameterUnit_property.readFrom (dictionary: inDictionary, forKey: "mDefaultHoleDiameterUnit")
  //--- Atomic property: mCustomHoleDiameter
    self.mCustomHoleDiameter_property.readFrom (dictionary: inDictionary, forKey: "mCustomHoleDiameter")
  //--- Atomic property: mCustomHoleDiameterUnit
    self.mCustomHoleDiameterUnit_property.readFrom (dictionary: inDictionary, forKey: "mCustomHoleDiameterUnit")
  //--- Atomic property: mUsesCustomHoleDiameter
    self.mUsesCustomHoleDiameter_property.readFrom (dictionary: inDictionary, forKey: "mUsesCustomHoleDiameter")
  //--- Atomic property: mDefaultPadDiameterUnit
    self.mDefaultPadDiameterUnit_property.readFrom (dictionary: inDictionary, forKey: "mDefaultPadDiameterUnit")
  //--- Atomic property: mCustomPadDiameter
    self.mCustomPadDiameter_property.readFrom (dictionary: inDictionary, forKey: "mCustomPadDiameter")
  //--- Atomic property: mCustomPadDiameterUnit
    self.mCustomPadDiameterUnit_property.readFrom (dictionary: inDictionary, forKey: "mCustomPadDiameterUnit")
  //--- Atomic property: mUsesCustomPadDiameter
    self.mUsesCustomPadDiameter_property.readFrom (dictionary: inDictionary, forKey: "mUsesCustomPadDiameter")
  }


  //····················································································································
  //   appendPropertyNamesTo
  //····················································································································

  override func appendPropertyNamesTo (_ ioString : inout String) {
    super.appendPropertyNamesTo (&ioString)
  //--- Atomic properties
    ioString += "mComponentPadName\n"
    ioString += "mPadIndex\n"
    ioString += "mX\n"
    ioString += "mY\n"
    ioString += "mDefaultHoleDiameterUnit\n"
    ioString += "mCustomHoleDiameter\n"
    ioString += "mCustomHoleDiameterUnit\n"
    ioString += "mUsesCustomHoleDiameter\n"
    ioString += "mDefaultPadDiameterUnit\n"
    ioString += "mCustomPadDiameter\n"
    ioString += "mCustomPadDiameterUnit\n"
    ioString += "mUsesCustomPadDiameter\n"
  //--- To one relationships
    ioString += "mComponent\n"
  //--- To many relationships
    ioString += "mTracksP2\n"
    ioString += "mTracksP1\n"
  }

  //····················································································································
  //   appendPropertyValuesTo
  //····················································································································

  override func appendPropertyValuesTo (_ ioData : inout Data) {
    super.appendPropertyValuesTo (&ioData)
  //--- Atomic properties
    self.mComponentPadName.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mPadIndex.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mX.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mY.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mDefaultHoleDiameterUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mCustomHoleDiameter.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mCustomHoleDiameterUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mUsesCustomHoleDiameter.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mDefaultPadDiameterUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mCustomPadDiameter.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mCustomPadDiameterUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mUsesCustomPadDiameter.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
  //--- To one relationships
    if let object = self.mComponent {
      ioData.append (base62Encoded: object.savingIndex)
    }
    ioData.append (ascii: .lineFeed)
  //--- To many relationships
    do{
      var optionalFirstIndex : Int? = nil
      var rangeCount = 0
      for object in self.mTracksP2.values {
        if let firstIndex = optionalFirstIndex {
          if object.savingIndex == (firstIndex + 1) {
            rangeCount += 1
            optionalFirstIndex = object.savingIndex
          }else if rangeCount > 0 {
            ioData.append (ascii: .colon)
            ioData.append (base62Encoded: rangeCount)
            ioData.append (ascii: .space)
            ioData.append (base62Encoded: object.savingIndex)
            rangeCount = 0
            optionalFirstIndex = object.savingIndex
          }else{
            ioData.append (ascii: .space)
            ioData.append (base62Encoded: object.savingIndex)
            optionalFirstIndex = object.savingIndex
          }
        }else{
          ioData.append (base62Encoded: object.savingIndex)
          optionalFirstIndex = object.savingIndex
        }
      }
      if optionalFirstIndex != nil, rangeCount > 0 {
        ioData.append (ascii: .colon)
        ioData.append (base62Encoded: rangeCount)
      }
      ioData.append (ascii: .lineFeed)
    }
    do{
      var optionalFirstIndex : Int? = nil
      var rangeCount = 0
      for object in self.mTracksP1.values {
        if let firstIndex = optionalFirstIndex {
          if object.savingIndex == (firstIndex + 1) {
            rangeCount += 1
            optionalFirstIndex = object.savingIndex
          }else if rangeCount > 0 {
            ioData.append (ascii: .colon)
            ioData.append (base62Encoded: rangeCount)
            ioData.append (ascii: .space)
            ioData.append (base62Encoded: object.savingIndex)
            rangeCount = 0
            optionalFirstIndex = object.savingIndex
          }else{
            ioData.append (ascii: .space)
            ioData.append (base62Encoded: object.savingIndex)
            optionalFirstIndex = object.savingIndex
          }
        }else{
          ioData.append (base62Encoded: object.savingIndex)
          optionalFirstIndex = object.savingIndex
        }
      }
      if optionalFirstIndex != nil, rangeCount > 0 {
        ioData.append (ascii: .colon)
        ioData.append (base62Encoded: rangeCount)
      }
      ioData.append (ascii: .lineFeed)
    }
  }

  //····················································································································
  //    setUpWithTextDictionary
  //····················································································································

  override func setUpWithTextDictionary (_ inDictionary : [String : NSRange],
                                         _ inObjectArray : [EBManagedObject],
                                         _ inData : Data,
                                         _ inParallelObjectSetupContext : ParallelObjectSetupContext) {
    super.setUpWithTextDictionary (inDictionary, inObjectArray, inData, inParallelObjectSetupContext)
    inParallelObjectSetupContext.addOperation {
    //--- Atomic properties
      if let range = inDictionary ["mComponentPadName"], let value = String.unarchiveFromDataRange (inData, range) {
        self.mComponentPadName = value
      }
      if let range = inDictionary ["mPadIndex"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mPadIndex = value
      }
      if let range = inDictionary ["mX"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mX = value
      }
      if let range = inDictionary ["mY"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mY = value
      }
      if let range = inDictionary ["mDefaultHoleDiameterUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mDefaultHoleDiameterUnit = value
      }
      if let range = inDictionary ["mCustomHoleDiameter"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mCustomHoleDiameter = value
      }
      if let range = inDictionary ["mCustomHoleDiameterUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mCustomHoleDiameterUnit = value
      }
      if let range = inDictionary ["mUsesCustomHoleDiameter"], let value = Bool.unarchiveFromDataRange (inData, range) {
        self.mUsesCustomHoleDiameter = value
      }
      if let range = inDictionary ["mDefaultPadDiameterUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mDefaultPadDiameterUnit = value
      }
      if let range = inDictionary ["mCustomPadDiameter"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mCustomPadDiameter = value
      }
      if let range = inDictionary ["mCustomPadDiameterUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mCustomPadDiameterUnit = value
      }
      if let range = inDictionary ["mUsesCustomPadDiameter"], let value = Bool.unarchiveFromDataRange (inData, range) {
        self.mUsesCustomPadDiameter = value
      }
    //--- To one relationships
      if let range = inDictionary ["mComponent"], let objectIndex = inData.base62EncodedInt (range: range) {
        let object = inObjectArray [objectIndex] as! ComponentInProject
        inParallelObjectSetupContext.addToOneSetupDeferredOperation { self.mComponent = object }
      }
    //--- To many relationships
      if let range = inDictionary ["mTracksP2"], range.length > 0 {
        var relationshipArray = EBReferenceArray <BoardTrack> ()
        let indexArray = inData.base62EncodedIntArray (fromRange: range)
        for idx in indexArray {
          relationshipArray.append (inObjectArray [idx] as! BoardTrack)
        }
        inParallelObjectSetupContext.addToManySetupDeferredOperation { self.mTracksP2 = relationshipArray }
      }
      if let range = inDictionary ["mTracksP1"], range.length > 0 {
        var relationshipArray = EBReferenceArray <BoardTrack> ()
        let indexArray = inData.base62EncodedIntArray (fromRange: range)
        for idx in indexArray {
          relationshipArray.append (inObjectArray [idx] as! BoardTrack)
        }
        inParallelObjectSetupContext.addToManySetupDeferredOperation { self.mTracksP1 = relationshipArray }
      }
    }
  //--- End of addOperation
  }

  //····················································································································
  //   accessibleObjects
  //····················································································································

  override func accessibleObjects (objects : inout [EBManagedObject]) {
    super.accessibleObjects (objects: &objects)
  //--- To many property: mTracksP2
    for managedObject in self.mTracksP2.values {
      objects.append (managedObject)
    }
  //--- To many property: mTracksP1
    for managedObject in self.mTracksP1.values {
      objects.append (managedObject)
    }
  //--- To one property: mComponent
    if let object = self.mComponent {
      objects.append (object)
    }
  }

  //····················································································································
  //   accessibleObjectsForSaveOperation
  //····················································································································

  override func accessibleObjectsForSaveOperation (objects : inout [EBManagedObject]) {
    super.accessibleObjectsForSaveOperation (objects: &objects)
  //--- To many property: mTracksP2
    for managedObject in self.mTracksP2.values {
      objects.append (managedObject)
    }
  //--- To many property: mTracksP1
    for managedObject in self.mTracksP1.values {
      objects.append (managedObject)
    }
  //--- To one property: mComponent
    if let object = self.mComponent {
      objects.append (object)
    }
  }

  //····················································································································

  override func cursorForKnob (knob inKnobIndex: Int) -> NSCursor? {
    return cursorForKnob_BoardConnector (knob: inKnobIndex)
  }

  //····················································································································
  //  Translate
  //····················································································································

  override func acceptedTranslation (xBy inDx: Int, yBy inDy: Int) -> CanariPoint {
    return acceptedTranslation_BoardConnector (xBy: inDx, yBy: inDy)
  }

  //····················································································································

  override func acceptToTranslate (xBy inDx: Int, yBy inDy: Int) -> Bool {
    return acceptToTranslate_BoardConnector (xBy: inDx, yBy: inDy)
  }

  //····················································································································

  override func translate (xBy inDx: Int, yBy inDy: Int, userSet ioSet : inout EBReferenceSet <AnyObject>) {
    translate_BoardConnector (xBy: inDx, yBy: inDy, userSet: &ioSet)
  }

  //····················································································································
  //   Move
  //····················································································································

  override func canMove (knob inKnobIndex : Int,
                         proposedUnalignedAlignedTranslation inProposedUnalignedTranslation : CanariPoint,
                         proposedAlignedTranslation inProposedAlignedTranslation : CanariPoint,
                         unalignedMouseDraggedLocation inUnalignedMouseDraggedLocation : CanariPoint,
                         shift inShift : Bool) -> CanariPoint {
    return canMove_BoardConnector (
      knob: inKnobIndex,
      proposedUnalignedAlignedTranslation: inProposedUnalignedTranslation,
      proposedAlignedTranslation: inProposedAlignedTranslation,
      unalignedMouseDraggedLocation: inUnalignedMouseDraggedLocation,
      shift: inShift
    )
  }

  //····················································································································

  override func move (knob inKnobIndex: Int,
                      proposedDx inDx: Int,
                      proposedDy inDy: Int,
                      unalignedMouseLocationX inUnlignedMouseLocationX : Int,
                      unalignedMouseLocationY inUnlignedMouseLocationY : Int,
                      alignedMouseLocationX inAlignedMouseLocationX : Int,
                      alignedMouseLocationY inAlignedMouseLocationY : Int,
                      shift inShift : Bool) {
    move_BoardConnector (
      knob: inKnobIndex,
      proposedDx: inDx,
      proposedDy: inDy,
      unalignedMouseLocationX: inUnlignedMouseLocationX,
      unalignedMouseLocationY: inUnlignedMouseLocationY,
      alignedMouseLocationX: inAlignedMouseLocationX,
      alignedMouseLocationY: inAlignedMouseLocationY,
      shift: inShift
    )
  }

  //····················································································································
  //  Snap to grid
  //····················································································································

  override func snapToGrid (_ inGrid : Int) {
    snapToGrid_BoardConnector (inGrid)
  }

  //····················································································································

  override func canSnapToGrid (_ inGrid : Int) -> Bool {
    return canSnapToGrid_BoardConnector (inGrid)
  }

  //····················································································································
  //  HORIZONTAL FLIP
  //····················································································································

  override func flipHorizontally () {
    flipHorizontally_BoardConnector ()
  }

  //····················································································································

  override func canFlipHorizontally () -> Bool {
    return canFlipHorizontally_BoardConnector ()
  }

  //····················································································································
  //  VERTICAL FLIP
  //····················································································································

  override func flipVertically () {
    flipVertically_BoardConnector ()
  }

  //····················································································································

  override func canFlipVertically () -> Bool {
    return canFlipVertically_BoardConnector ()
  }

  //····················································································································
  //  ROTATE 90
  //····················································································································

  override func canRotate90 (accumulatedPoints : inout Set <CanariPoint>) -> Bool {
    return canRotate90_BoardConnector (accumulatedPoints: &accumulatedPoints)
  }

  //····················································································································

  override func rotate90Clockwise (from inRotationCenter : CanariPoint, userSet ioSet : inout EBReferenceSet <AnyObject>) {
    rotate90Clockwise_BoardConnector (from: inRotationCenter, userSet: &ioSet)
  }

  //····················································································································

  override func rotate90CounterClockwise (from inRotationCenter : CanariPoint, userSet ioSet : inout EBReferenceSet <AnyObject>) {
    rotate90CounterClockwise_BoardConnector (from: inRotationCenter, userSet: &ioSet)
  }

  //····················································································································
  //  Save into additional dictionary
  //····················································································································

  override func saveIntoAdditionalDictionary (_ ioDictionary : NSMutableDictionary) {
    saveIntoAdditionalDictionary_BoardConnector (ioDictionary)
  }

  //····················································································································
  //  operationAfterPasting
  //····················································································································

  override func operationAfterPasting (additionalDictionary inDictionary : NSDictionary,
                                       objectArray inObjectArray : [EBGraphicManagedObject]) -> String {
    return operationAfterPasting_BoardConnector (additionalDictionary: inDictionary, objectArray: inObjectArray)
  }

  //····················································································································
  //  Alignment Points
  //····················································································································

  override func alignmentPoints () -> Set <CanariPoint> {
    return alignmentPoints_BoardConnector ()
  }

  //····················································································································
  //  operationBeforeRemoving
  //····················································································································

  override func operationBeforeRemoving () {
    operationBeforeRemoving_BoardConnector ()
  }

  //····················································································································
  //  Can be deleted
  //····················································································································

  override func canBeDeleted () -> Bool {
    return false
  }

  //····················································································································

}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

