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

import Cocoa

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

protocol MergerRoot_selectedPageIndex : AnyObject {
  var selectedPageIndex : Int { get }
}

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

protocol MergerRoot_zoom : AnyObject {
  var zoom : Int { get }
}

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

protocol MergerRoot_showDisplaySettingView : AnyObject {
  var showDisplaySettingView : Bool { get }
}

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

protocol MergerRoot_modelInsertionRotation : AnyObject {
  var modelInsertionRotation : QuadrantRotation { get }
}

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

protocol MergerRoot_automaticBoardSize : AnyObject {
  var automaticBoardSize : Bool { get }
}

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

protocol MergerRoot_boardManualWidth : AnyObject {
  var boardManualWidth : Int { get }
}

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

protocol MergerRoot_boardManualHeight : AnyObject {
  var boardManualHeight : Int { get }
}

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

protocol MergerRoot_boardWidthUnit : AnyObject {
  var boardWidthUnit : Int { get }
}

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

protocol MergerRoot_boardHeightUnit : AnyObject {
  var boardHeightUnit : Int { get }
}

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

protocol MergerRoot_overlapingArrangment : AnyObject {
  var overlapingArrangment : Bool { get }
}

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

protocol MergerRoot_selectedBoardXUnit : AnyObject {
  var selectedBoardXUnit : Int { get }
}

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

protocol MergerRoot_selectedBoardYUnit : AnyObject {
  var selectedBoardYUnit : Int { get }
}

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

protocol MergerRoot_boardLimitWidth : AnyObject {
  var boardLimitWidth : Int { get }
}

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

protocol MergerRoot_boardLimitWidthUnit : AnyObject {
  var boardLimitWidthUnit : Int { get }
}

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

protocol MergerRoot_arrowMagnitude : AnyObject {
  var arrowMagnitude : Int { get }
}

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

protocol MergerRoot_arrowMagnitudeUnit : AnyObject {
  var arrowMagnitudeUnit : Int { get }
}

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

protocol MergerRoot_shiftArrowMagnitude : AnyObject {
  var shiftArrowMagnitude : Int { get }
}

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

protocol MergerRoot_shiftArrowMagnitudeUnit : AnyObject {
  var shiftArrowMagnitudeUnit : Int { get }
}

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

protocol MergerRoot_mPDFBoardBackgroundColor : AnyObject {
  var mPDFBoardBackgroundColor : NSColor { get }
}

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

protocol MergerRoot_mArtworkName : AnyObject {
  var mArtworkName : String { get }
}

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

protocol MergerRoot_mArtworkVersion : AnyObject {
  var mArtworkVersion : Int { get }
}

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

protocol MergerRoot_minPPTPTTTWdisplayUnit : AnyObject {
  var minPPTPTTTWdisplayUnit : Int? { get }
}

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

protocol MergerRoot_minPPTPTTTW : AnyObject {
  var minPPTPTTTW : Int? { get }
}

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

protocol MergerRoot_minValueForOARdisplayUnit : AnyObject {
  var minValueForOARdisplayUnit : Int? { get }
}

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

protocol MergerRoot_minValueForOARinEBUnit : AnyObject {
  var minValueForOARinEBUnit : Int? { get }
}

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

protocol MergerRoot_minValueForPHDdisplayUnit : AnyObject {
  var minValueForPHDdisplayUnit : Int? { get }
}

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

protocol MergerRoot_minValueForPHDinEBUnit : AnyObject {
  var minValueForPHDinEBUnit : Int? { get }
}

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

protocol MergerRoot_minValueForBoardLimitWidth : AnyObject {
  var minValueForBoardLimitWidth : Int? { get }
}

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

protocol MergerRoot_minValueForBoardLimitWidthDisplayUnit : AnyObject {
  var minValueForBoardLimitWidthDisplayUnit : Int? { get }
}

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

protocol MergerRoot_drillDataFileExtension : AnyObject {
  var drillDataFileExtension : String? { get }
}

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

protocol MergerRoot_modelNames : AnyObject {
  var modelNames : StringTagArray? { get }
}

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

protocol MergerRoot_boardRect : AnyObject {
  var boardRect : CanariRect? { get }
}

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

protocol MergerRoot_boardDisplayRect : AnyObject {
  var boardDisplayRect : CanariRect? { get }
}

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

protocol MergerRoot_boardWidth : AnyObject {
  var boardWidth : Int? { get }
}

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

protocol MergerRoot_boardHeight : AnyObject {
  var boardHeight : Int? { get }
}

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

protocol MergerRoot_comments : AnyObject {
  var comments : String? { get }
}

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

protocol MergerRoot_layoutLayerWarningMessage : AnyObject {
  var layoutLayerWarningMessage : String? { get }
}

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

protocol MergerRoot_layerConfigurationString : AnyObject {
  var layerConfigurationString : String? { get }
}

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

protocol MergerRoot_emptyDrillFileExtension : AnyObject {
  var emptyDrillFileExtension : Bool? { get }
}

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

protocol MergerRoot_hasInnerElements : AnyObject {
  var hasInnerElements : Bool? { get }
}

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

protocol MergerRoot_hasSixLayers : AnyObject {
  var hasSixLayers : Bool? { get }
}

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

protocol MergerRoot_boardOutlineRectDisplay : AnyObject {
  var boardOutlineRectDisplay : EBShape? { get }
}

//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
//    Entity: MergerRoot
//——————————————————————————————————————————————————————————————————————————————————————————————————————————————————————

final class MergerRoot : EBManagedObject,
         MergerRoot_selectedPageIndex,
         MergerRoot_zoom,
         MergerRoot_showDisplaySettingView,
         MergerRoot_modelInsertionRotation,
         MergerRoot_automaticBoardSize,
         MergerRoot_boardManualWidth,
         MergerRoot_boardManualHeight,
         MergerRoot_boardWidthUnit,
         MergerRoot_boardHeightUnit,
         MergerRoot_overlapingArrangment,
         MergerRoot_selectedBoardXUnit,
         MergerRoot_selectedBoardYUnit,
         MergerRoot_boardLimitWidth,
         MergerRoot_boardLimitWidthUnit,
         MergerRoot_arrowMagnitude,
         MergerRoot_arrowMagnitudeUnit,
         MergerRoot_shiftArrowMagnitude,
         MergerRoot_shiftArrowMagnitudeUnit,
         MergerRoot_mPDFBoardBackgroundColor,
         MergerRoot_mArtworkName,
         MergerRoot_mArtworkVersion,
         MergerRoot_minPPTPTTTWdisplayUnit,
         MergerRoot_minPPTPTTTW,
         MergerRoot_minValueForOARdisplayUnit,
         MergerRoot_minValueForOARinEBUnit,
         MergerRoot_minValueForPHDdisplayUnit,
         MergerRoot_minValueForPHDinEBUnit,
         MergerRoot_minValueForBoardLimitWidth,
         MergerRoot_minValueForBoardLimitWidthDisplayUnit,
         MergerRoot_drillDataFileExtension,
         MergerRoot_modelNames,
         MergerRoot_boardRect,
         MergerRoot_boardDisplayRect,
         MergerRoot_boardWidth,
         MergerRoot_boardHeight,
         MergerRoot_comments,
         MergerRoot_layoutLayerWarningMessage,
         MergerRoot_layerConfigurationString,
         MergerRoot_emptyDrillFileExtension,
         MergerRoot_hasInnerElements,
         MergerRoot_hasSixLayers,
         MergerRoot_boardOutlineRectDisplay {

  //····················································································································
  //   To many property: boardModels
  //····················································································································

  final let boardModels_property = StoredArrayOf_BoardModel (usedForSignature: false)

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

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

  final var boardModels : EBReferenceArray <BoardModel> {
    get { return self.boardModels_property.propval }
    set { self.boardModels_property.setProp (newValue) }
  }

  //····················································································································
  //   To many property: boardInstances
  //····················································································································

  final let boardInstances_property = StoredArrayOf_MergerBoardInstance (usedForSignature: false)

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

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

  final var boardInstances : EBReferenceArray <MergerBoardInstance> {
    get { return self.boardInstances_property.propval }
    set { self.boardInstances_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: selectedPageIndex
  //····················································································································

  final let selectedPageIndex_property : EBStoredProperty_Int

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

  final func reset_selectedPageIndex_toDefaultValue () {
    self.selectedPageIndex = 0
  }

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

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

  //····················································································································
  //   Atomic property: zoom
  //····················································································································

  final let zoom_property : EBStoredProperty_Int

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

  final func reset_zoom_toDefaultValue () {
    self.zoom = 100
  }

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

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

  //····················································································································
  //   Atomic property: showDisplaySettingView
  //····················································································································

  final let showDisplaySettingView_property : EBStoredProperty_Bool

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

  final func reset_showDisplaySettingView_toDefaultValue () {
    self.showDisplaySettingView = false
  }

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

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

  //····················································································································
  //   Atomic property: modelInsertionRotation
  //····················································································································

  final let modelInsertionRotation_property : EBStoredProperty_QuadrantRotation

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

  final func reset_modelInsertionRotation_toDefaultValue () {
    self.modelInsertionRotation = QuadrantRotation.rotation0
  }

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

  final var modelInsertionRotation : QuadrantRotation {
    get { return self.modelInsertionRotation_property.propval }
    set { self.modelInsertionRotation_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: automaticBoardSize
  //····················································································································

  final let automaticBoardSize_property : EBStoredProperty_Bool

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

  final func reset_automaticBoardSize_toDefaultValue () {
    self.automaticBoardSize = true
  }

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

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

  //····················································································································
  //   Atomic property: boardManualWidth
  //····················································································································

  final let boardManualWidth_property : EBStoredProperty_Int

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

  final func reset_boardManualWidth_toDefaultValue () {
    self.boardManualWidth = 9000000
  }

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

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

  //····················································································································
  //   Atomic property: boardManualHeight
  //····················································································································

  final let boardManualHeight_property : EBStoredProperty_Int

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

  final func reset_boardManualHeight_toDefaultValue () {
    self.boardManualHeight = 9000000
  }

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

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

  //····················································································································
  //   Atomic property: boardWidthUnit
  //····················································································································

  final let boardWidthUnit_property : EBStoredProperty_Int

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

  final func reset_boardWidthUnit_toDefaultValue () {
    self.boardWidthUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: boardHeightUnit
  //····················································································································

  final let boardHeightUnit_property : EBStoredProperty_Int

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

  final func reset_boardHeightUnit_toDefaultValue () {
    self.boardHeightUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: overlapingArrangment
  //····················································································································

  final let overlapingArrangment_property : EBStoredProperty_Bool

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

  final func reset_overlapingArrangment_toDefaultValue () {
    self.overlapingArrangment = false
  }

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

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

  //····················································································································
  //   Atomic property: selectedBoardXUnit
  //····················································································································

  final let selectedBoardXUnit_property : EBStoredProperty_Int

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

  final func reset_selectedBoardXUnit_toDefaultValue () {
    self.selectedBoardXUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: selectedBoardYUnit
  //····················································································································

  final let selectedBoardYUnit_property : EBStoredProperty_Int

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

  final func reset_selectedBoardYUnit_toDefaultValue () {
    self.selectedBoardYUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: boardLimitWidth
  //····················································································································

  final let boardLimitWidth_property : EBStoredProperty_Int

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

  final func reset_boardLimitWidth_toDefaultValue () {
    self.boardLimitWidth = 90000
  }

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

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

  //····················································································································
  //   Atomic property: boardLimitWidthUnit
  //····················································································································

  final let boardLimitWidthUnit_property : EBStoredProperty_Int

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

  final func reset_boardLimitWidthUnit_toDefaultValue () {
    self.boardLimitWidthUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: arrowMagnitude
  //····················································································································

  final let arrowMagnitude_property : EBStoredProperty_Int

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

  final func reset_arrowMagnitude_toDefaultValue () {
    self.arrowMagnitude = 900000
  }

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

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

  //····················································································································
  //   Atomic property: arrowMagnitudeUnit
  //····················································································································

  final let arrowMagnitudeUnit_property : EBStoredProperty_Int

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

  final func reset_arrowMagnitudeUnit_toDefaultValue () {
    self.arrowMagnitudeUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: shiftArrowMagnitude
  //····················································································································

  final let shiftArrowMagnitude_property : EBStoredProperty_Int

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

  final func reset_shiftArrowMagnitude_toDefaultValue () {
    self.shiftArrowMagnitude = 3600000
  }

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

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

  //····················································································································
  //   Atomic property: shiftArrowMagnitudeUnit
  //····················································································································

  final let shiftArrowMagnitudeUnit_property : EBStoredProperty_Int

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

  final func reset_shiftArrowMagnitudeUnit_toDefaultValue () {
    self.shiftArrowMagnitudeUnit = 90000
  }

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

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

  //····················································································································
  //   Atomic property: mPDFBoardBackgroundColor
  //····················································································································

  final let mPDFBoardBackgroundColor_property : EBStoredProperty_NSColor

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

  final func reset_mPDFBoardBackgroundColor_toDefaultValue () {
    self.mPDFBoardBackgroundColor = NSColor.lightGray
  }

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

  final var mPDFBoardBackgroundColor : NSColor {
    get { return self.mPDFBoardBackgroundColor_property.propval }
    set { self.mPDFBoardBackgroundColor_property.setProp (newValue) }
  }

  //····················································································································
  //   Atomic property: mArtworkName
  //····················································································································

  final let mArtworkName_property : EBStoredProperty_String

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

  final func reset_mArtworkName_toDefaultValue () {
    self.mArtworkName = ""
  }

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

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

  //····················································································································
  //   Atomic property: mArtworkVersion
  //····················································································································

  final let mArtworkVersion_property : EBStoredProperty_Int

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

  final func reset_mArtworkVersion_toDefaultValue () {
    self.mArtworkVersion = 0
  }

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

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

  //····················································································································
  //   Atomic proxy property: minPPTPTTTWdisplayUnit
  //····················································································································

  let minPPTPTTTWdisplayUnit_property = EBPropertyProxy_Int ()

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

  var minPPTPTTTWdisplayUnit : Int? {
    get {
      switch self.minPPTPTTTWdisplayUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minPPTPTTTWdisplayUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minPPTPTTTW
  //····················································································································

  let minPPTPTTTW_property = EBPropertyProxy_Int ()

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

  var minPPTPTTTW : Int? {
    get {
      switch self.minPPTPTTTW_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minPPTPTTTW_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForOARdisplayUnit
  //····················································································································

  let minValueForOARdisplayUnit_property = EBPropertyProxy_Int ()

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

  var minValueForOARdisplayUnit : Int? {
    get {
      switch self.minValueForOARdisplayUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForOARdisplayUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForOARinEBUnit
  //····················································································································

  let minValueForOARinEBUnit_property = EBPropertyProxy_Int ()

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

  var minValueForOARinEBUnit : Int? {
    get {
      switch self.minValueForOARinEBUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForOARinEBUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForPHDdisplayUnit
  //····················································································································

  let minValueForPHDdisplayUnit_property = EBPropertyProxy_Int ()

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

  var minValueForPHDdisplayUnit : Int? {
    get {
      switch self.minValueForPHDdisplayUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForPHDdisplayUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForPHDinEBUnit
  //····················································································································

  let minValueForPHDinEBUnit_property = EBPropertyProxy_Int ()

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

  var minValueForPHDinEBUnit : Int? {
    get {
      switch self.minValueForPHDinEBUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForPHDinEBUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForBoardLimitWidth
  //····················································································································

  let minValueForBoardLimitWidth_property = EBPropertyProxy_Int ()

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

  var minValueForBoardLimitWidth : Int? {
    get {
      switch self.minValueForBoardLimitWidth_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForBoardLimitWidth_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: minValueForBoardLimitWidthDisplayUnit
  //····················································································································

  let minValueForBoardLimitWidthDisplayUnit_property = EBPropertyProxy_Int ()

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

  var minValueForBoardLimitWidthDisplayUnit : Int? {
    get {
      switch self.minValueForBoardLimitWidthDisplayUnit_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.minValueForBoardLimitWidthDisplayUnit_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   Atomic proxy property: drillDataFileExtension
  //····················································································································

  let drillDataFileExtension_property = EBPropertyProxy_String ()

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

  var drillDataFileExtension : String? {
    get {
      switch self.drillDataFileExtension_property.selection {
      case .empty, .multiple :
        return nil
      case .single (let v) :
        return v
      }
    }
    set {
      if let unwrappedNewValue = newValue {
        self.drillDataFileExtension_property.setProp (unwrappedNewValue)
      }
    }
  }

  //····················································································································
  //   ToMany proxy: fileGenerationParameterArray
  //····················································································································

  var fileGenerationParameterArray_modelDidChangeController : EBObservablePropertyController? = nil
  // var fileGenerationParameterArray_boundObjectDidChangeController : EBObservablePropertyController? = nil
  let fileGenerationParameterArray_property = ProxyArrayOf_ArtworkFileGenerationParameters ()

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

  var fileGenerationParameterArray : EBReferenceArray <ArtworkFileGenerationParameters> {
    get {
      switch self.fileGenerationParameterArray_property.selection {
      case .empty, .multiple :
        return EBReferenceArray ()
      case .single (let v) :
        return EBReferenceArray (v)
      }
    }
    set {
      self.fileGenerationParameterArray_property.setProp (newValue)
    }
  }

  //····················································································································
  //   Transient property: modelNames
  //····················································································································

  final let modelNames_property = EBTransientProperty_StringTagArray ()

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

  final var modelNames : StringTagArray? {
    switch self.modelNames_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: boardRect
  //····················································································································

  final let boardRect_property = EBTransientProperty_CanariRect ()

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

  final var boardRect : CanariRect? {
    switch self.boardRect_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: boardDisplayRect
  //····················································································································

  final let boardDisplayRect_property = EBTransientProperty_CanariRect ()

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

  final var boardDisplayRect : CanariRect? {
    switch self.boardDisplayRect_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

  //····················································································································
  //   Transient property: boardWidth
  //····················································································································

  final let boardWidth_property = EBTransientProperty_Int ()

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

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

  //····················································································································
  //   Transient property: boardHeight
  //····················································································································

  final let boardHeight_property = EBTransientProperty_Int ()

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

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

  //····················································································································
  //   To one property: mArtwork
  //····················································································································

  final let mArtwork_property = StoredObject_ArtworkRoot (usedForSignature: false)

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

  final var mArtwork : ArtworkRoot? {
    get {
      return self.mArtwork_property.propval
    }
    set {
      if self.mArtwork_property.propval != nil {
        self.mArtwork_property.setProp (nil)
      }
      if newValue != nil {
        self.mArtwork_property.setProp (newValue)
      }
    }
  }

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

  final let mArtwork_none = EBGenericTransientProperty <Bool> ()

  //····················································································································
  //   Transient property: comments
  //····················································································································

  final let comments_property = EBTransientProperty_String ()

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

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

  //····················································································································
  //   Transient property: layoutLayerWarningMessage
  //····················································································································

  final let layoutLayerWarningMessage_property = EBTransientProperty_String ()

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

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

  //····················································································································
  //   Transient property: layerConfigurationString
  //····················································································································

  final let layerConfigurationString_property = EBTransientProperty_String ()

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

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

  //····················································································································
  //   Transient property: emptyDrillFileExtension
  //····················································································································

  final let emptyDrillFileExtension_property = EBTransientProperty_Bool ()

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

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

  //····················································································································
  //   Transient property: hasInnerElements
  //····················································································································

  final let hasInnerElements_property = EBTransientProperty_Bool ()

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

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

  //····················································································································
  //   Transient property: hasSixLayers
  //····················································································································

  final let hasSixLayers_property = EBTransientProperty_Bool ()

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

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

  //····················································································································
  //   Transient property: boardOutlineRectDisplay
  //····················································································································

  final let boardOutlineRectDisplay_property = EBTransientProperty_EBShape ()

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

  final var boardOutlineRectDisplay : EBShape? {
    switch self.boardOutlineRectDisplay_property.selection {
    case .empty, .multiple :
      return nil
    case .single (let v) :
      return v
    }
  }

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

  required init (_ ebUndoManager : EBUndoManager?) {
    self.selectedPageIndex_property = EBStoredProperty_Int (defaultValue: 0, undoManager: ebUndoManager)
    self.zoom_property = EBStoredProperty_Int (defaultValue: 100, undoManager: ebUndoManager)
    self.showDisplaySettingView_property = EBStoredProperty_Bool (defaultValue: false, undoManager: ebUndoManager)
    self.modelInsertionRotation_property = EBStoredProperty_QuadrantRotation (defaultValue: QuadrantRotation.rotation0, undoManager: ebUndoManager)
    self.automaticBoardSize_property = EBStoredProperty_Bool (defaultValue: true, undoManager: ebUndoManager)
    self.boardManualWidth_property = EBStoredProperty_Int (defaultValue: 9000000, undoManager: ebUndoManager)
    self.boardManualHeight_property = EBStoredProperty_Int (defaultValue: 9000000, undoManager: ebUndoManager)
    self.boardWidthUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.boardHeightUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.overlapingArrangment_property = EBStoredProperty_Bool (defaultValue: false, undoManager: ebUndoManager)
    self.selectedBoardXUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.selectedBoardYUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.boardLimitWidth_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.boardLimitWidthUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.arrowMagnitude_property = EBStoredProperty_Int (defaultValue: 900000, undoManager: ebUndoManager)
    self.arrowMagnitudeUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.shiftArrowMagnitude_property = EBStoredProperty_Int (defaultValue: 3600000, undoManager: ebUndoManager)
    self.shiftArrowMagnitudeUnit_property = EBStoredProperty_Int (defaultValue: 90000, undoManager: ebUndoManager)
    self.mPDFBoardBackgroundColor_property = EBStoredProperty_NSColor (defaultValue: NSColor.lightGray, undoManager: ebUndoManager)
    self.mArtworkName_property = EBStoredProperty_String (defaultValue: "", undoManager: ebUndoManager)
    self.mArtworkVersion_property = EBStoredProperty_Int (defaultValue: 0, undoManager: ebUndoManager)
    super.init (ebUndoManager)
    self.mArtwork_none.mReadModelFunction = { [weak self] in // §
      if let uwSelf = self {
        return .single (uwSelf.mArtwork_property.propval == nil)
      }else{
        return .empty
      }
    }
    self.mArtwork_property.addEBObserver (self.mArtwork_none)
  //--- To many property: boardModels (no option)
    self.boardModels_property.ebUndoManager = self.ebUndoManager
  //--- To many property: boardInstances (has opposite relationship)
    self.boardInstances_property.ebUndoManager = self.ebUndoManager
    self.boardInstances_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.myRoot_property.setProp (me) } },
      resetter: { inObject in inObject.myRoot_property.setProp (nil) }
    )
  //--- Atomic proxy property: minPPTPTTTWdisplayUnit
    self.minPPTPTTTWdisplayUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minPPTPTTTWdisplayUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minPPTPTTTWdisplayUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minPPTPTTTWdisplayUnit = inValue
    }
    self.minPPTPTTTWdisplayUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minPPTPTTTWdisplayUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minPPTPTTTWdisplayUnit_property.addEBObserver (self.minPPTPTTTWdisplayUnit_property)
  //--- Atomic proxy property: minPPTPTTTW
    self.minPPTPTTTW_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minPPTPTTTW_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minPPTPTTTW_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minPPTPTTTW = inValue
    }
    self.minPPTPTTTW_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minPPTPTTTW_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minPPTPTTTW_property.addEBObserver (self.minPPTPTTTW_property)
  //--- Atomic proxy property: minValueForOARdisplayUnit
    self.minValueForOARdisplayUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForOARdisplayUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForOARdisplayUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForOARdisplayUnit = inValue
    }
    self.minValueForOARdisplayUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForOARdisplayUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForOARdisplayUnit_property.addEBObserver (self.minValueForOARdisplayUnit_property)
  //--- Atomic proxy property: minValueForOARinEBUnit
    self.minValueForOARinEBUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForOARinEBUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForOARinEBUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForOARinEBUnit = inValue
    }
    self.minValueForOARinEBUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForOARinEBUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForOARinEBUnit_property.addEBObserver (self.minValueForOARinEBUnit_property)
  //--- Atomic proxy property: minValueForPHDdisplayUnit
    self.minValueForPHDdisplayUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForPHDdisplayUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForPHDdisplayUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForPHDdisplayUnit = inValue
    }
    self.minValueForPHDdisplayUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForPHDdisplayUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForPHDdisplayUnit_property.addEBObserver (self.minValueForPHDdisplayUnit_property)
  //--- Atomic proxy property: minValueForPHDinEBUnit
    self.minValueForPHDinEBUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForPHDinEBUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForPHDinEBUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForPHDinEBUnit = inValue
    }
    self.minValueForPHDinEBUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForPHDinEBUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForPHDinEBUnit_property.addEBObserver (self.minValueForPHDinEBUnit_property)
  //--- Atomic proxy property: minValueForBoardLimitWidth
    self.minValueForBoardLimitWidth_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForBoardLimitWidth_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForBoardLimitWidth_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForBoardLimitWidth = inValue
    }
    self.minValueForBoardLimitWidth_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForBoardLimitWidth_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForBoardLimitWidth_property.addEBObserver (self.minValueForBoardLimitWidth_property)
  //--- Atomic proxy property: minValueForBoardLimitWidthDisplayUnit
    self.minValueForBoardLimitWidthDisplayUnit_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.minValueForBoardLimitWidthDisplayUnit_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.minValueForBoardLimitWidthDisplayUnit_property.mWriteModelFunction = { [weak self] (_ inValue : Int) in
      self?.mArtwork?.minValueForBoardLimitWidthDisplayUnit = inValue
    }
    self.minValueForBoardLimitWidthDisplayUnit_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : Int, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.minValueForBoardLimitWidthDisplayUnit_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.minValueForBoardLimitWidthDisplayUnit_property.addEBObserver (self.minValueForBoardLimitWidthDisplayUnit_property)
  //--- Atomic proxy property: drillDataFileExtension
    self.drillDataFileExtension_property.mReadModelFunction = { [weak self] in
      if let object = self?.mArtwork_property {
        switch object.drillDataFileExtension_property.selection {
        case .empty :
          return .empty
        case .multiple :
          return .multiple
        case .single (let optionalV) :
          if let v = optionalV {
            return .single (v)
          }else{
            return .empty
          }
        }
      }else{
        return .empty
      }
    }
    self.drillDataFileExtension_property.mWriteModelFunction = { [weak self] (_ inValue : String) in
      self?.mArtwork?.drillDataFileExtension = inValue
    }
    self.drillDataFileExtension_property.mValidateAndWriteModelFunction = { [weak self] (_ inValue : String, _ inWindow : NSWindow?) -> Bool in
      return self?.mArtwork?.drillDataFileExtension_property.validateAndSetProp (inValue, windowForSheet: inWindow) ?? false
    }
    self.mArtwork_property.drillDataFileExtension_property.addEBObserver (self.drillDataFileExtension_property)
  //--- ToMany proxy: fileGenerationParameterArray
    do{
      let controller = EBObservablePropertyController (
        observedObjects: [self.mArtwork_property],
        callBack: { [weak self] in
          if let me = self, let model = me.mArtwork {
            me.fileGenerationParameterArray_property.setModel (model.fileGenerationParameterArray_property)
          }
        }
      )
      self.mArtwork_property.addEBObserverOf_fileGenerationParameterArray (controller)
      self.fileGenerationParameterArray_modelDidChangeController = controller
    }
  //--- Atomic property: modelNames
    self.modelNames_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.boardModels_property.selection, unwSelf.boardModels_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_MergerRoot_modelNames (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.boardModels_property.addEBObserverOf_name (self.modelNames_property)
    self.boardModels_property.addEBObserver (self.modelNames_property)
  //--- Atomic property: boardRect
    self.boardRect_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.automaticBoardSize_property.selection, unwSelf.boardManualWidth_property.selection, unwSelf.boardManualHeight_property.selection, unwSelf.boardInstances_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3)) :
          return .single (transient_MergerRoot_boardRect (v0, v1, v2, v3))
        case (.multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.automaticBoardSize_property.addEBObserver (self.boardRect_property)
    self.boardManualWidth_property.addEBObserver (self.boardRect_property)
    self.boardManualHeight_property.addEBObserver (self.boardRect_property)
    self.boardInstances_property.addEBObserverOf_instanceRect (self.boardRect_property)
  //--- Atomic property: boardDisplayRect
    self.boardDisplayRect_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.boardManualWidth_property.selection, unwSelf.boardManualHeight_property.selection, unwSelf.boardInstances_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2)) :
          return .single (transient_MergerRoot_boardDisplayRect (v0, v1, v2))
        case (.multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.boardManualWidth_property.addEBObserver (self.boardDisplayRect_property)
    self.boardManualHeight_property.addEBObserver (self.boardDisplayRect_property)
    self.boardInstances_property.addEBObserverOf_instanceRect (self.boardDisplayRect_property)
  //--- Atomic property: boardWidth
    self.boardWidth_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.boardRect_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_boardWidth (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.boardRect_property.addEBObserver (self.boardWidth_property)
  //--- Atomic property: boardHeight
    self.boardHeight_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.boardRect_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_boardHeight (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.boardRect_property.addEBObserver (self.boardHeight_property)
  //--- To one property: mArtwork
    self.mArtwork_property.ebUndoManager = self.ebUndoManager
  //--- Atomic property: comments
    self.comments_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.comments_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_comments (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.comments_property.addEBObserver (self.comments_property)
  //--- Atomic property: layoutLayerWarningMessage
    self.layoutLayerWarningMessage_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.layerConfiguration_property.selection, unwSelf.boardModels_property.selection) {
        case (.single (let v0), .single (let v1)) :
          return .single (transient_MergerRoot_layoutLayerWarningMessage (v0, v1))
        case (.multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.layerConfiguration_property.addEBObserver (self.layoutLayerWarningMessage_property)
    self.boardModels_property.addEBObserverOf_layerConfiguration (self.layoutLayerWarningMessage_property)
  //--- Atomic property: layerConfigurationString
    self.layerConfigurationString_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.layerConfiguration_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_layerConfigurationString (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.layerConfiguration_property.addEBObserver (self.layerConfigurationString_property)
  //--- Atomic property: emptyDrillFileExtension
    self.emptyDrillFileExtension_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.drillDataFileExtension_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_emptyDrillFileExtension (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.drillDataFileExtension_property.addEBObserver (self.emptyDrillFileExtension_property)
  //--- Atomic property: hasInnerElements
    self.hasInnerElements_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.hasInnerElements_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_hasInnerElements (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.hasInnerElements_property.addEBObserver (self.hasInnerElements_property)
  //--- Atomic property: hasSixLayers
    self.hasSixLayers_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.mArtwork_property.hasSixLayers_property.selection) {
        case (.single (let v0)) :
          return .single (transient_MergerRoot_hasSixLayers (v0))
        case (.multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.mArtwork_property.hasSixLayers_property.addEBObserver (self.hasSixLayers_property)
  //--- Atomic property: boardOutlineRectDisplay
    self.boardOutlineRectDisplay_property.mReadModelFunction = { [weak self] in
      if let unwSelf = self {
        switch (unwSelf.boardRect_property.selection, unwSelf.boardLimitWidth_property.selection, preferences_mergerBoardViewDisplayBoardLimits_property.selection, preferences_mergerColorBoardLimits_property.selection) {
        case (.single (let v0), .single (let v1), .single (let v2), .single (let v3)) :
          return .single (transient_MergerRoot_boardOutlineRectDisplay (v0, v1, v2, v3))
        case (.multiple, .multiple, .multiple, .multiple) :
          return .multiple
        default :
          return .empty
        }
      }else{
        return .empty
      }
    }
    self.boardRect_property.addEBObserver (self.boardOutlineRectDisplay_property)
    self.boardLimitWidth_property.addEBObserver (self.boardOutlineRectDisplay_property)
    preferences_mergerBoardViewDisplayBoardLimits_property.addEBObserver (self.boardOutlineRectDisplay_property)
    preferences_mergerColorBoardLimits_property.addEBObserver (self.boardOutlineRectDisplay_property)
  //--- Install undoers and opposite setter for relationships
    self.boardInstances_property.setOppositeRelationShipFunctions (
      setter: { [weak self] inObject in if let me = self { inObject.myRoot_property.setProp (me) } },
      resetter: { inObject in inObject.myRoot_property.setProp (nil) }
    )
  //--- Register properties for handling signature
  //--- Extern delegates
  }

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

  override func removeAllObservers () {
    super.removeAllObservers ()
  //--- Atomic proxy property: minPPTPTTTWdisplayUnit
    self.minPPTPTTTWdisplayUnit_property.mReadModelFunction = nil
    self.minPPTPTTTWdisplayUnit_property.mWriteModelFunction = nil
    self.minPPTPTTTWdisplayUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minPPTPTTTWdisplayUnit_property.removeEBObserver (self.minPPTPTTTWdisplayUnit_property)
  //--- Atomic proxy property: minPPTPTTTW
    self.minPPTPTTTW_property.mReadModelFunction = nil
    self.minPPTPTTTW_property.mWriteModelFunction = nil
    self.minPPTPTTTW_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minPPTPTTTW_property.removeEBObserver (self.minPPTPTTTW_property)
  //--- Atomic proxy property: minValueForOARdisplayUnit
    self.minValueForOARdisplayUnit_property.mReadModelFunction = nil
    self.minValueForOARdisplayUnit_property.mWriteModelFunction = nil
    self.minValueForOARdisplayUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForOARdisplayUnit_property.removeEBObserver (self.minValueForOARdisplayUnit_property)
  //--- Atomic proxy property: minValueForOARinEBUnit
    self.minValueForOARinEBUnit_property.mReadModelFunction = nil
    self.minValueForOARinEBUnit_property.mWriteModelFunction = nil
    self.minValueForOARinEBUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForOARinEBUnit_property.removeEBObserver (self.minValueForOARinEBUnit_property)
  //--- Atomic proxy property: minValueForPHDdisplayUnit
    self.minValueForPHDdisplayUnit_property.mReadModelFunction = nil
    self.minValueForPHDdisplayUnit_property.mWriteModelFunction = nil
    self.minValueForPHDdisplayUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForPHDdisplayUnit_property.removeEBObserver (self.minValueForPHDdisplayUnit_property)
  //--- Atomic proxy property: minValueForPHDinEBUnit
    self.minValueForPHDinEBUnit_property.mReadModelFunction = nil
    self.minValueForPHDinEBUnit_property.mWriteModelFunction = nil
    self.minValueForPHDinEBUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForPHDinEBUnit_property.removeEBObserver (self.minValueForPHDinEBUnit_property)
  //--- Atomic proxy property: minValueForBoardLimitWidth
    self.minValueForBoardLimitWidth_property.mReadModelFunction = nil
    self.minValueForBoardLimitWidth_property.mWriteModelFunction = nil
    self.minValueForBoardLimitWidth_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForBoardLimitWidth_property.removeEBObserver (self.minValueForBoardLimitWidth_property)
  //--- Atomic proxy property: minValueForBoardLimitWidthDisplayUnit
    self.minValueForBoardLimitWidthDisplayUnit_property.mReadModelFunction = nil
    self.minValueForBoardLimitWidthDisplayUnit_property.mWriteModelFunction = nil
    self.minValueForBoardLimitWidthDisplayUnit_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.minValueForBoardLimitWidthDisplayUnit_property.removeEBObserver (self.minValueForBoardLimitWidthDisplayUnit_property)
  //--- Atomic proxy property: drillDataFileExtension
    self.drillDataFileExtension_property.mReadModelFunction = nil
    self.drillDataFileExtension_property.mWriteModelFunction = nil
    self.drillDataFileExtension_property.mValidateAndWriteModelFunction = nil
    self.mArtwork_property.drillDataFileExtension_property.removeEBObserver (self.drillDataFileExtension_property)
  //--- ToMany proxy: fileGenerationParameterArray
    self.fileGenerationParameterArray_property.setModel (nil)
    self.fileGenerationParameterArray_modelDidChangeController?.unregister ()
    self.fileGenerationParameterArray_modelDidChangeController = nil
    // self.boardModels_property.removeEBObserverOf_name (self.modelNames_property)
    // self.boardModels_property.removeEBObserver (self.modelNames_property)
    // self.automaticBoardSize_property.removeEBObserver (self.boardRect_property)
    // self.boardManualWidth_property.removeEBObserver (self.boardRect_property)
    // self.boardManualHeight_property.removeEBObserver (self.boardRect_property)
    // self.boardInstances_property.removeEBObserverOf_instanceRect (self.boardRect_property)
    // self.boardManualWidth_property.removeEBObserver (self.boardDisplayRect_property)
    // self.boardManualHeight_property.removeEBObserver (self.boardDisplayRect_property)
    // self.boardInstances_property.removeEBObserverOf_instanceRect (self.boardDisplayRect_property)
    // self.boardRect_property.removeEBObserver (self.boardWidth_property)
    // self.boardRect_property.removeEBObserver (self.boardHeight_property)
    // self.mArtwork_property.comments_property.removeEBObserver (self.comments_property)
    // self.mArtwork_property.layerConfiguration_property.removeEBObserver (self.layoutLayerWarningMessage_property)
    // self.boardModels_property.removeEBObserverOf_layerConfiguration (self.layoutLayerWarningMessage_property)
    // self.mArtwork_property.layerConfiguration_property.removeEBObserver (self.layerConfigurationString_property)
    // self.mArtwork_property.drillDataFileExtension_property.removeEBObserver (self.emptyDrillFileExtension_property)
    // self.mArtwork_property.hasInnerElements_property.removeEBObserver (self.hasInnerElements_property)
    // self.mArtwork_property.hasSixLayers_property.removeEBObserver (self.hasSixLayers_property)
    // self.boardRect_property.removeEBObserver (self.boardOutlineRectDisplay_property)
    // self.boardLimitWidth_property.removeEBObserver (self.boardOutlineRectDisplay_property)
    // preferences_mergerBoardViewDisplayBoardLimits_property.removeEBObserver (self.boardOutlineRectDisplay_property)
    // preferences_mergerColorBoardLimits_property.removeEBObserver (self.boardOutlineRectDisplay_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 (
        "selectedPageIndex",
        object: self.selectedPageIndex_property,
        y: &y,
        view: view,
        observerExplorer: &self.selectedPageIndex_property.mObserverExplorer,
        valueExplorer: &self.selectedPageIndex_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "zoom",
        object: self.zoom_property,
        y: &y,
        view: view,
        observerExplorer: &self.zoom_property.mObserverExplorer,
        valueExplorer: &self.zoom_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "showDisplaySettingView",
        object: self.showDisplaySettingView_property,
        y: &y,
        view: view,
        observerExplorer: &self.showDisplaySettingView_property.mObserverExplorer,
        valueExplorer: &self.showDisplaySettingView_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "modelInsertionRotation",
        object: self.modelInsertionRotation_property,
        y: &y,
        view: view,
        observerExplorer: &self.modelInsertionRotation_property.mObserverExplorer,
        valueExplorer: &self.modelInsertionRotation_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "automaticBoardSize",
        object: self.automaticBoardSize_property,
        y: &y,
        view: view,
        observerExplorer: &self.automaticBoardSize_property.mObserverExplorer,
        valueExplorer: &self.automaticBoardSize_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardManualWidth",
        object: self.boardManualWidth_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardManualWidth_property.mObserverExplorer,
        valueExplorer: &self.boardManualWidth_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardManualHeight",
        object: self.boardManualHeight_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardManualHeight_property.mObserverExplorer,
        valueExplorer: &self.boardManualHeight_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardWidthUnit",
        object: self.boardWidthUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardWidthUnit_property.mObserverExplorer,
        valueExplorer: &self.boardWidthUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardHeightUnit",
        object: self.boardHeightUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardHeightUnit_property.mObserverExplorer,
        valueExplorer: &self.boardHeightUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "overlapingArrangment",
        object: self.overlapingArrangment_property,
        y: &y,
        view: view,
        observerExplorer: &self.overlapingArrangment_property.mObserverExplorer,
        valueExplorer: &self.overlapingArrangment_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "selectedBoardXUnit",
        object: self.selectedBoardXUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.selectedBoardXUnit_property.mObserverExplorer,
        valueExplorer: &self.selectedBoardXUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "selectedBoardYUnit",
        object: self.selectedBoardYUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.selectedBoardYUnit_property.mObserverExplorer,
        valueExplorer: &self.selectedBoardYUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardLimitWidth",
        object: self.boardLimitWidth_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardLimitWidth_property.mObserverExplorer,
        valueExplorer: &self.boardLimitWidth_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardLimitWidthUnit",
        object: self.boardLimitWidthUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardLimitWidthUnit_property.mObserverExplorer,
        valueExplorer: &self.boardLimitWidthUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "arrowMagnitude",
        object: self.arrowMagnitude_property,
        y: &y,
        view: view,
        observerExplorer: &self.arrowMagnitude_property.mObserverExplorer,
        valueExplorer: &self.arrowMagnitude_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "arrowMagnitudeUnit",
        object: self.arrowMagnitudeUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.arrowMagnitudeUnit_property.mObserverExplorer,
        valueExplorer: &self.arrowMagnitudeUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "shiftArrowMagnitude",
        object: self.shiftArrowMagnitude_property,
        y: &y,
        view: view,
        observerExplorer: &self.shiftArrowMagnitude_property.mObserverExplorer,
        valueExplorer: &self.shiftArrowMagnitude_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "shiftArrowMagnitudeUnit",
        object: self.shiftArrowMagnitudeUnit_property,
        y: &y,
        view: view,
        observerExplorer: &self.shiftArrowMagnitudeUnit_property.mObserverExplorer,
        valueExplorer: &self.shiftArrowMagnitudeUnit_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mPDFBoardBackgroundColor",
        object: self.mPDFBoardBackgroundColor_property,
        y: &y,
        view: view,
        observerExplorer: &self.mPDFBoardBackgroundColor_property.mObserverExplorer,
        valueExplorer: &self.mPDFBoardBackgroundColor_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mArtworkName",
        object: self.mArtworkName_property,
        y: &y,
        view: view,
        observerExplorer: &self.mArtworkName_property.mObserverExplorer,
        valueExplorer: &self.mArtworkName_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "mArtworkVersion",
        object: self.mArtworkVersion_property,
        y: &y,
        view: view,
        observerExplorer: &self.mArtworkVersion_property.mObserverExplorer,
        valueExplorer: &self.mArtworkVersion_property.mValueExplorer
      )
      createEntryForTitle ("Properties", y: &y, view: view)
      createEntryForPropertyNamed (
        "modelNames",
        object: self.modelNames_property,
        y: &y,
        view: view,
        observerExplorer: &self.modelNames_property.mObserverExplorer,
        valueExplorer: &self.modelNames_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardRect",
        object: self.boardRect_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardRect_property.mObserverExplorer,
        valueExplorer: &self.boardRect_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardDisplayRect",
        object: self.boardDisplayRect_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardDisplayRect_property.mObserverExplorer,
        valueExplorer: &self.boardDisplayRect_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardWidth",
        object: self.boardWidth_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardWidth_property.mObserverExplorer,
        valueExplorer: &self.boardWidth_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardHeight",
        object: self.boardHeight_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardHeight_property.mObserverExplorer,
        valueExplorer: &self.boardHeight_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "comments",
        object: self.comments_property,
        y: &y,
        view: view,
        observerExplorer: &self.comments_property.mObserverExplorer,
        valueExplorer: &self.comments_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "layoutLayerWarningMessage",
        object: self.layoutLayerWarningMessage_property,
        y: &y,
        view: view,
        observerExplorer: &self.layoutLayerWarningMessage_property.mObserverExplorer,
        valueExplorer: &self.layoutLayerWarningMessage_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "layerConfigurationString",
        object: self.layerConfigurationString_property,
        y: &y,
        view: view,
        observerExplorer: &self.layerConfigurationString_property.mObserverExplorer,
        valueExplorer: &self.layerConfigurationString_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "emptyDrillFileExtension",
        object: self.emptyDrillFileExtension_property,
        y: &y,
        view: view,
        observerExplorer: &self.emptyDrillFileExtension_property.mObserverExplorer,
        valueExplorer: &self.emptyDrillFileExtension_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "hasInnerElements",
        object: self.hasInnerElements_property,
        y: &y,
        view: view,
        observerExplorer: &self.hasInnerElements_property.mObserverExplorer,
        valueExplorer: &self.hasInnerElements_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "hasSixLayers",
        object: self.hasSixLayers_property,
        y: &y,
        view: view,
        observerExplorer: &self.hasSixLayers_property.mObserverExplorer,
        valueExplorer: &self.hasSixLayers_property.mValueExplorer
      )
      createEntryForPropertyNamed (
        "boardOutlineRectDisplay",
        object: self.boardOutlineRectDisplay_property,
        y: &y,
        view: view,
        observerExplorer: &self.boardOutlineRectDisplay_property.mObserverExplorer,
        valueExplorer: &self.boardOutlineRectDisplay_property.mValueExplorer
      )
      createEntryForTitle ("Transients", y: &y, view: view)
      createEntryForToManyRelationshipNamed (
        "boardModels",
        object: boardModels_property,
        y: &y,
        view: view,
        valueExplorer:&boardModels_property.mValueExplorer
      )
      createEntryForToManyRelationshipNamed (
        "boardInstances",
        object: boardInstances_property,
        y: &y,
        view: view,
        valueExplorer:&boardInstances_property.mValueExplorer
      )
      createEntryForTitle ("ToMany Relationships", y: &y, view: view)
      createEntryForToOneRelationshipNamed (
        "mArtwork",
        object: self.mArtwork_property,
        y: &y,
        view: view,
        valueExplorer:&self.mArtwork_property.mValueExplorer
      )
      createEntryForTitle ("ToOne Relationships", y: &y, view: view)
    }
  #endif

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

  #if BUILD_OBJECT_EXPLORER
    override func clearObjectExplorer () {
    //--- To many property: boardModels
      self.boardModels_property.mValueExplorer = nil
    //--- To many property: boardInstances
      self.boardInstances_property.mValueExplorer = nil
  //--- Atomic property: selectedPageIndex
    self.selectedPageIndex_property.mObserverExplorer = nil
    self.selectedPageIndex_property.mValueExplorer = nil
  //--- Atomic property: zoom
    self.zoom_property.mObserverExplorer = nil
    self.zoom_property.mValueExplorer = nil
  //--- Atomic property: showDisplaySettingView
    self.showDisplaySettingView_property.mObserverExplorer = nil
    self.showDisplaySettingView_property.mValueExplorer = nil
  //--- Atomic property: modelInsertionRotation
    self.modelInsertionRotation_property.mObserverExplorer = nil
    self.modelInsertionRotation_property.mValueExplorer = nil
  //--- Atomic property: automaticBoardSize
    self.automaticBoardSize_property.mObserverExplorer = nil
    self.automaticBoardSize_property.mValueExplorer = nil
  //--- Atomic property: boardManualWidth
    self.boardManualWidth_property.mObserverExplorer = nil
    self.boardManualWidth_property.mValueExplorer = nil
  //--- Atomic property: boardManualHeight
    self.boardManualHeight_property.mObserverExplorer = nil
    self.boardManualHeight_property.mValueExplorer = nil
  //--- Atomic property: boardWidthUnit
    self.boardWidthUnit_property.mObserverExplorer = nil
    self.boardWidthUnit_property.mValueExplorer = nil
  //--- Atomic property: boardHeightUnit
    self.boardHeightUnit_property.mObserverExplorer = nil
    self.boardHeightUnit_property.mValueExplorer = nil
  //--- Atomic property: overlapingArrangment
    self.overlapingArrangment_property.mObserverExplorer = nil
    self.overlapingArrangment_property.mValueExplorer = nil
  //--- Atomic property: selectedBoardXUnit
    self.selectedBoardXUnit_property.mObserverExplorer = nil
    self.selectedBoardXUnit_property.mValueExplorer = nil
  //--- Atomic property: selectedBoardYUnit
    self.selectedBoardYUnit_property.mObserverExplorer = nil
    self.selectedBoardYUnit_property.mValueExplorer = nil
  //--- Atomic property: boardLimitWidth
    self.boardLimitWidth_property.mObserverExplorer = nil
    self.boardLimitWidth_property.mValueExplorer = nil
  //--- Atomic property: boardLimitWidthUnit
    self.boardLimitWidthUnit_property.mObserverExplorer = nil
    self.boardLimitWidthUnit_property.mValueExplorer = nil
  //--- Atomic property: arrowMagnitude
    self.arrowMagnitude_property.mObserverExplorer = nil
    self.arrowMagnitude_property.mValueExplorer = nil
  //--- Atomic property: arrowMagnitudeUnit
    self.arrowMagnitudeUnit_property.mObserverExplorer = nil
    self.arrowMagnitudeUnit_property.mValueExplorer = nil
  //--- Atomic property: shiftArrowMagnitude
    self.shiftArrowMagnitude_property.mObserverExplorer = nil
    self.shiftArrowMagnitude_property.mValueExplorer = nil
  //--- Atomic property: shiftArrowMagnitudeUnit
    self.shiftArrowMagnitudeUnit_property.mObserverExplorer = nil
    self.shiftArrowMagnitudeUnit_property.mValueExplorer = nil
  //--- Atomic property: mPDFBoardBackgroundColor
    self.mPDFBoardBackgroundColor_property.mObserverExplorer = nil
    self.mPDFBoardBackgroundColor_property.mValueExplorer = nil
  //--- Atomic property: mArtworkName
    self.mArtworkName_property.mObserverExplorer = nil
    self.mArtworkName_property.mValueExplorer = nil
  //--- Atomic property: mArtworkVersion
    self.mArtworkVersion_property.mObserverExplorer = nil
    self.mArtworkVersion_property.mValueExplorer = nil
    //--- Atomic proxy property: minPPTPTTTWdisplayUnit
      self.minPPTPTTTWdisplayUnit_property.mObserverExplorer = nil
      self.minPPTPTTTWdisplayUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: minPPTPTTTW
      self.minPPTPTTTW_property.mObserverExplorer = nil
      self.minPPTPTTTW_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForOARdisplayUnit
      self.minValueForOARdisplayUnit_property.mObserverExplorer = nil
      self.minValueForOARdisplayUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForOARinEBUnit
      self.minValueForOARinEBUnit_property.mObserverExplorer = nil
      self.minValueForOARinEBUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForPHDdisplayUnit
      self.minValueForPHDdisplayUnit_property.mObserverExplorer = nil
      self.minValueForPHDdisplayUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForPHDinEBUnit
      self.minValueForPHDinEBUnit_property.mObserverExplorer = nil
      self.minValueForPHDinEBUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForBoardLimitWidth
      self.minValueForBoardLimitWidth_property.mObserverExplorer = nil
      self.minValueForBoardLimitWidth_property.mValueExplorer = nil
    //--- Atomic proxy property: minValueForBoardLimitWidthDisplayUnit
      self.minValueForBoardLimitWidthDisplayUnit_property.mObserverExplorer = nil
      self.minValueForBoardLimitWidthDisplayUnit_property.mValueExplorer = nil
    //--- Atomic proxy property: drillDataFileExtension
      self.drillDataFileExtension_property.mObserverExplorer = nil
      self.drillDataFileExtension_property.mValueExplorer = nil
    //--- ToMany proxy: fileGenerationParameterArray
      self.fileGenerationParameterArray_property.mObserverExplorer = nil
    //--- To one property: mArtwork
      self.mArtwork_property.mObserverExplorer = nil
      self.mArtwork_property.mValueExplorer = nil
    //---
      super.clearObjectExplorer ()
    }
  #endif

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

  override func cleanUpToManyRelationships () {
    self.boardModels.removeAll ()
    self.boardInstances.removeAll ()
  //---
    super.cleanUpToManyRelationships ()
  }

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

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

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

  override func saveIntoDictionary (_ ioDictionary : NSMutableDictionary) {
    super.saveIntoDictionary (ioDictionary)
  //--- To many property: boardModels
    self.store (
      managedObjectArray: self.boardModels_property.propval.values,
      relationshipName: "boardModels",
      intoDictionary: ioDictionary
    )
  //--- To many property: boardInstances
    self.store (
      managedObjectArray: self.boardInstances_property.propval.values,
      relationshipName: "boardInstances",
      intoDictionary: ioDictionary
    )
    //--- Atomic property: selectedPageIndex
      self.selectedPageIndex_property.storeIn (dictionary: ioDictionary, forKey: "selectedPageIndex")
    //--- Atomic property: zoom
      self.zoom_property.storeIn (dictionary: ioDictionary, forKey: "zoom")
    //--- Atomic property: showDisplaySettingView
      self.showDisplaySettingView_property.storeIn (dictionary: ioDictionary, forKey: "showDisplaySettingView")
    //--- Atomic property: modelInsertionRotation
      self.modelInsertionRotation_property.storeIn (dictionary: ioDictionary, forKey: "modelInsertionRotation")
    //--- Atomic property: automaticBoardSize
      self.automaticBoardSize_property.storeIn (dictionary: ioDictionary, forKey: "automaticBoardSize")
    //--- Atomic property: boardManualWidth
      self.boardManualWidth_property.storeIn (dictionary: ioDictionary, forKey: "boardManualWidth")
    //--- Atomic property: boardManualHeight
      self.boardManualHeight_property.storeIn (dictionary: ioDictionary, forKey: "boardManualHeight")
    //--- Atomic property: boardWidthUnit
      self.boardWidthUnit_property.storeIn (dictionary: ioDictionary, forKey: "boardWidthUnit")
    //--- Atomic property: boardHeightUnit
      self.boardHeightUnit_property.storeIn (dictionary: ioDictionary, forKey: "boardHeightUnit")
    //--- Atomic property: overlapingArrangment
      self.overlapingArrangment_property.storeIn (dictionary: ioDictionary, forKey: "overlapingArrangment")
    //--- Atomic property: selectedBoardXUnit
      self.selectedBoardXUnit_property.storeIn (dictionary: ioDictionary, forKey: "selectedBoardXUnit")
    //--- Atomic property: selectedBoardYUnit
      self.selectedBoardYUnit_property.storeIn (dictionary: ioDictionary, forKey: "selectedBoardYUnit")
    //--- Atomic property: boardLimitWidth
      self.boardLimitWidth_property.storeIn (dictionary: ioDictionary, forKey: "boardLimitWidth")
    //--- Atomic property: boardLimitWidthUnit
      self.boardLimitWidthUnit_property.storeIn (dictionary: ioDictionary, forKey: "boardLimitWidthUnit")
    //--- Atomic property: arrowMagnitude
      self.arrowMagnitude_property.storeIn (dictionary: ioDictionary, forKey: "arrowMagnitude")
    //--- Atomic property: arrowMagnitudeUnit
      self.arrowMagnitudeUnit_property.storeIn (dictionary: ioDictionary, forKey: "arrowMagnitudeUnit")
    //--- Atomic property: shiftArrowMagnitude
      self.shiftArrowMagnitude_property.storeIn (dictionary: ioDictionary, forKey: "shiftArrowMagnitude")
    //--- Atomic property: shiftArrowMagnitudeUnit
      self.shiftArrowMagnitudeUnit_property.storeIn (dictionary: ioDictionary, forKey: "shiftArrowMagnitudeUnit")
    //--- Atomic property: mPDFBoardBackgroundColor
      self.mPDFBoardBackgroundColor_property.storeIn (dictionary: ioDictionary, forKey: "mPDFBoardBackgroundColor")
    //--- Atomic property: mArtworkName
      self.mArtworkName_property.storeIn (dictionary: ioDictionary, forKey: "mArtworkName")
    //--- Atomic property: mArtworkVersion
      self.mArtworkVersion_property.storeIn (dictionary: ioDictionary, forKey: "mArtworkVersion")
  //--- To one property: mArtwork
    self.store (managedObject:self.mArtwork_property.propval,
      relationshipName: "mArtwork",
      intoDictionary: ioDictionary)
  }

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

  override func setUpWithDictionary (_ inDictionary : NSDictionary,
                                     managedObjectArray : inout [EBManagedObject]) {
    super.setUpWithDictionary (inDictionary, managedObjectArray: &managedObjectArray)
  //--- To many property: boardModels
/*    self.boardModels_property.setProp (readEntityArrayFromDictionary (
      inRelationshipName: "boardModels",
      inDictionary: inDictionary,
      managedObjectArray: &managedObjectArray
    ) as! [BoardModel]) */
    do{
      let array = readEntityArrayFromDictionary (
        inRelationshipName: "boardModels",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      ) as! [BoardModel]
      self.boardModels_property.setProp (EBReferenceArray (array))
    }
  //--- To many property: boardInstances
/*    self.boardInstances_property.setProp (readEntityArrayFromDictionary (
      inRelationshipName: "boardInstances",
      inDictionary: inDictionary,
      managedObjectArray: &managedObjectArray
    ) as! [MergerBoardInstance]) */
    do{
      let array = readEntityArrayFromDictionary (
        inRelationshipName: "boardInstances",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      ) as! [MergerBoardInstance]
      self.boardInstances_property.setProp (EBReferenceArray (array))
    }
  //--- To one property: mArtwork
    do{
      let possibleEntity = readEntityFromDictionary (
        inRelationshipName: "mArtwork",
        inDictionary: inDictionary,
        managedObjectArray: &managedObjectArray
      )
      if let entity = possibleEntity as? ArtworkRoot {
        self.mArtwork_property.setProp (entity)
      }
    }
  }

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

  override func setUpAtomicPropertiesWithDictionary (_ inDictionary : NSDictionary) {
    super.setUpAtomicPropertiesWithDictionary (inDictionary)
  //--- Atomic property: selectedPageIndex
    self.selectedPageIndex_property.readFrom (dictionary: inDictionary, forKey: "selectedPageIndex")
  //--- Atomic property: zoom
    self.zoom_property.readFrom (dictionary: inDictionary, forKey: "zoom")
  //--- Atomic property: showDisplaySettingView
    self.showDisplaySettingView_property.readFrom (dictionary: inDictionary, forKey: "showDisplaySettingView")
  //--- Atomic property: modelInsertionRotation
    self.modelInsertionRotation_property.readFrom (dictionary: inDictionary, forKey: "modelInsertionRotation")
  //--- Atomic property: automaticBoardSize
    self.automaticBoardSize_property.readFrom (dictionary: inDictionary, forKey: "automaticBoardSize")
  //--- Atomic property: boardManualWidth
    self.boardManualWidth_property.readFrom (dictionary: inDictionary, forKey: "boardManualWidth")
  //--- Atomic property: boardManualHeight
    self.boardManualHeight_property.readFrom (dictionary: inDictionary, forKey: "boardManualHeight")
  //--- Atomic property: boardWidthUnit
    self.boardWidthUnit_property.readFrom (dictionary: inDictionary, forKey: "boardWidthUnit")
  //--- Atomic property: boardHeightUnit
    self.boardHeightUnit_property.readFrom (dictionary: inDictionary, forKey: "boardHeightUnit")
  //--- Atomic property: overlapingArrangment
    self.overlapingArrangment_property.readFrom (dictionary: inDictionary, forKey: "overlapingArrangment")
  //--- Atomic property: selectedBoardXUnit
    self.selectedBoardXUnit_property.readFrom (dictionary: inDictionary, forKey: "selectedBoardXUnit")
  //--- Atomic property: selectedBoardYUnit
    self.selectedBoardYUnit_property.readFrom (dictionary: inDictionary, forKey: "selectedBoardYUnit")
  //--- Atomic property: boardLimitWidth
    self.boardLimitWidth_property.readFrom (dictionary: inDictionary, forKey: "boardLimitWidth")
  //--- Atomic property: boardLimitWidthUnit
    self.boardLimitWidthUnit_property.readFrom (dictionary: inDictionary, forKey: "boardLimitWidthUnit")
  //--- Atomic property: arrowMagnitude
    self.arrowMagnitude_property.readFrom (dictionary: inDictionary, forKey: "arrowMagnitude")
  //--- Atomic property: arrowMagnitudeUnit
    self.arrowMagnitudeUnit_property.readFrom (dictionary: inDictionary, forKey: "arrowMagnitudeUnit")
  //--- Atomic property: shiftArrowMagnitude
    self.shiftArrowMagnitude_property.readFrom (dictionary: inDictionary, forKey: "shiftArrowMagnitude")
  //--- Atomic property: shiftArrowMagnitudeUnit
    self.shiftArrowMagnitudeUnit_property.readFrom (dictionary: inDictionary, forKey: "shiftArrowMagnitudeUnit")
  //--- Atomic property: mPDFBoardBackgroundColor
    self.mPDFBoardBackgroundColor_property.readFrom (dictionary: inDictionary, forKey: "mPDFBoardBackgroundColor")
  //--- Atomic property: mArtworkName
    self.mArtworkName_property.readFrom (dictionary: inDictionary, forKey: "mArtworkName")
  //--- Atomic property: mArtworkVersion
    self.mArtworkVersion_property.readFrom (dictionary: inDictionary, forKey: "mArtworkVersion")
  }


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

  override func appendPropertyNamesTo (_ ioString : inout String) {
    super.appendPropertyNamesTo (&ioString)
  //--- Atomic properties
    ioString += "selectedPageIndex\n"
    ioString += "zoom\n"
    ioString += "showDisplaySettingView\n"
    ioString += "modelInsertionRotation\n"
    ioString += "automaticBoardSize\n"
    ioString += "boardManualWidth\n"
    ioString += "boardManualHeight\n"
    ioString += "boardWidthUnit\n"
    ioString += "boardHeightUnit\n"
    ioString += "overlapingArrangment\n"
    ioString += "selectedBoardXUnit\n"
    ioString += "selectedBoardYUnit\n"
    ioString += "boardLimitWidth\n"
    ioString += "boardLimitWidthUnit\n"
    ioString += "arrowMagnitude\n"
    ioString += "arrowMagnitudeUnit\n"
    ioString += "shiftArrowMagnitude\n"
    ioString += "shiftArrowMagnitudeUnit\n"
    ioString += "mPDFBoardBackgroundColor\n"
    ioString += "mArtworkName\n"
    ioString += "mArtworkVersion\n"
  //--- To one relationships
    ioString += "mArtwork\n"
  //--- To many relationships
    ioString += "boardModels\n"
    ioString += "boardInstances\n"
  }

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

  override func appendPropertyValuesTo (_ ioData : inout Data) {
    super.appendPropertyValuesTo (&ioData)
  //--- Atomic properties
    self.selectedPageIndex.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.zoom.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.showDisplaySettingView.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.modelInsertionRotation.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.automaticBoardSize.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardManualWidth.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardManualHeight.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardWidthUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardHeightUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.overlapingArrangment.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.selectedBoardXUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.selectedBoardYUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardLimitWidth.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.boardLimitWidthUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.arrowMagnitude.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.arrowMagnitudeUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.shiftArrowMagnitude.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.shiftArrowMagnitudeUnit.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mPDFBoardBackgroundColor.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mArtworkName.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
    self.mArtworkVersion.appendPropertyValueTo (&ioData)
    ioData.append (ascii: .lineFeed)
  //--- To one relationships
    if let object = self.mArtwork {
      ioData.append (base62Encoded: object.savingIndex)
    }
    ioData.append (ascii: .lineFeed)
  //--- To many relationships
    do{
      var optionalFirstIndex : Int? = nil
      var rangeCount = 0
      for object in self.boardModels.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.boardInstances.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 ["selectedPageIndex"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.selectedPageIndex = value
      }
      if let range = inDictionary ["zoom"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.zoom = value
      }
      if let range = inDictionary ["showDisplaySettingView"], let value = Bool.unarchiveFromDataRange (inData, range) {
        self.showDisplaySettingView = value
      }
      if let range = inDictionary ["modelInsertionRotation"], let value = QuadrantRotation.unarchiveFromDataRange (inData, range) {
        self.modelInsertionRotation = value
      }
      if let range = inDictionary ["automaticBoardSize"], let value = Bool.unarchiveFromDataRange (inData, range) {
        self.automaticBoardSize = value
      }
      if let range = inDictionary ["boardManualWidth"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardManualWidth = value
      }
      if let range = inDictionary ["boardManualHeight"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardManualHeight = value
      }
      if let range = inDictionary ["boardWidthUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardWidthUnit = value
      }
      if let range = inDictionary ["boardHeightUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardHeightUnit = value
      }
      if let range = inDictionary ["overlapingArrangment"], let value = Bool.unarchiveFromDataRange (inData, range) {
        self.overlapingArrangment = value
      }
      if let range = inDictionary ["selectedBoardXUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.selectedBoardXUnit = value
      }
      if let range = inDictionary ["selectedBoardYUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.selectedBoardYUnit = value
      }
      if let range = inDictionary ["boardLimitWidth"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardLimitWidth = value
      }
      if let range = inDictionary ["boardLimitWidthUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.boardLimitWidthUnit = value
      }
      if let range = inDictionary ["arrowMagnitude"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.arrowMagnitude = value
      }
      if let range = inDictionary ["arrowMagnitudeUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.arrowMagnitudeUnit = value
      }
      if let range = inDictionary ["shiftArrowMagnitude"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.shiftArrowMagnitude = value
      }
      if let range = inDictionary ["shiftArrowMagnitudeUnit"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.shiftArrowMagnitudeUnit = value
      }
      if let range = inDictionary ["mPDFBoardBackgroundColor"], let value = NSColor.unarchiveFromDataRange (inData, range) {
        self.mPDFBoardBackgroundColor = value
      }
      if let range = inDictionary ["mArtworkName"], let value = String.unarchiveFromDataRange (inData, range) {
        self.mArtworkName = value
      }
      if let range = inDictionary ["mArtworkVersion"], let value = Int.unarchiveFromDataRange (inData, range) {
        self.mArtworkVersion = value
      }
    //--- To one relationships
      if let range = inDictionary ["mArtwork"], let objectIndex = inData.base62EncodedInt (range: range) {
        let object = inObjectArray [objectIndex] as! ArtworkRoot
        inParallelObjectSetupContext.addToOneSetupDeferredOperation { self.mArtwork = object }
      }
    //--- To many relationships
      if let range = inDictionary ["boardModels"], range.length > 0 {
        var relationshipArray = EBReferenceArray <BoardModel> ()
        let indexArray = inData.base62EncodedIntArray (fromRange: range)
        for idx in indexArray {
          relationshipArray.append (inObjectArray [idx] as! BoardModel)
        }
        inParallelObjectSetupContext.addToManySetupDeferredOperation { self.boardModels = relationshipArray }
      }
      if let range = inDictionary ["boardInstances"], range.length > 0 {
        var relationshipArray = EBReferenceArray <MergerBoardInstance> ()
        let indexArray = inData.base62EncodedIntArray (fromRange: range)
        for idx in indexArray {
          relationshipArray.append (inObjectArray [idx] as! MergerBoardInstance)
        }
        inParallelObjectSetupContext.addToManySetupDeferredOperation { self.boardInstances = relationshipArray }
      }
    }
  //--- End of addOperation
  }

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

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

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

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

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

}

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

