net.sourceforge.msscodefactory.cfbam.v2_7.CFBamJavaFX.CFBamJavaFXTableAttrPane.java Source code

Introduction

Here is the source code for net.sourceforge.msscodefactory.cfbam.v2_7.CFBamJavaFX.CFBamJavaFXTableAttrPane.java

Source

// Description: Java 8 JavaFX Attribute Pane implementation for Table.

/*
 *   CFBam
 *
 *   Copyright (c) 2014-2016 Mark Sobkow
 *   
 *   This program is available as free software under the GNU GPL v3, or
 *   under a commercial license from Mark Sobkow.  For commercial licensing
 *   details, please contact msobkow@sasktel.net.
 *   
 *   Under the terms of the GPL:
 *   
 *      This program is free software: you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License as published by
 *      the Free Software Foundation, either version 3 of the License, or
 *      (at your option) any later version.
 *     
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *     
 *      You should have received a copy of the GNU General Public License
 *      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *   
 */

package net.sourceforge.msscodefactory.cfbam.v2_7.CFBamJavaFX;

import java.math.*;
import java.sql.*;
import java.text.*;
import java.util.*;
import javafx.collections.FXCollections;
import javafx.collections.ObservableList;
import javafx.geometry.HPos;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.Node;
import javafx.scene.control.ButtonType;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Control;
import javafx.scene.layout.ColumnConstraints;
import javafx.scene.layout.Priority;
import net.sourceforge.msscodefactory.cflib.v2_7.CFLib.*;
import net.sourceforge.msscodefactory.cflib.v2_7.CFLib.JavaFX.*;
import net.sourceforge.msscodefactory.cflib.v2_7.CFLib.JavaFX.CFReferenceEditor.ICFReferenceCallback;
import org.apache.commons.codec.binary.Base64;
import net.sourceforge.msscodefactory.cfsecurity.v2_7.CFSecurity.*;
import net.sourceforge.msscodefactory.cfinternet.v2_7.CFInternet.*;
import net.sourceforge.msscodefactory.cfbam.v2_7.CFBam.*;
import net.sourceforge.msscodefactory.cfsecurity.v2_7.CFSecurityObj.*;
import net.sourceforge.msscodefactory.cfinternet.v2_7.CFInternetObj.*;
import net.sourceforge.msscodefactory.cfbam.v2_7.CFBamObj.*;
import net.sourceforge.msscodefactory.cfsecurity.v2_7.CFSecurityJavaFX.*;
import net.sourceforge.msscodefactory.cfinternet.v2_7.CFInternetJavaFX.*;

/**
 *   CFBamJavaFXTableAttrPane JavaFX Attribute Pane implementation
 *   for Table.
 */
public class CFBamJavaFXTableAttrPane extends CFGridPane implements ICFBamJavaFXTablePaneCommon {
    protected ICFFormManager cfFormManager = null;
    protected ICFBamJavaFXSchema javafxSchema = null;
    boolean javafxIsInitializing = true;

    protected ObservableList<String> observableListOfLoaderBehaviour = FXCollections.observableArrayList("Insert",
            "Update", "Replace");

    protected ObservableList<String> observableListOfSecurityScope = FXCollections.observableArrayList("None",
            "System", "Cluster", "Tenant");

    protected class DefSchemaCFLabel extends CFLabel {
        public DefSchemaCFLabel() {
            super();
            setText("Defining Schema Definition");
        }
    }

    protected class CallbackDefSchemaChosen implements ICFBamJavaFXSchemaDefChosen {
        public CallbackDefSchemaChosen() {
        }

        public void choseSchemaDef(ICFBamSchemaDefObj value) {
            if (javafxReferenceLookupDefSchema != null) {
                ICFBamTableObj cur = getJavaFXFocusAsTable();
                if (cur != null) {
                    ICFBamTableEditObj editObj = (ICFBamTableEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupDefSchema.setReferencedObject(value);
                            editObj.setOptionalLookupDefSchema(value);
                        }
                    }
                }
            }
        }
    }

    protected class DefSchemaReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            ICFBamTableEditObj editObj = (ICFBamTableEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFBamSchemaDefObj referencedObj = (ICFBamSchemaDefObj) javafxReferenceLookupDefSchema
                    .getReferencedObject();
            java.util.List<ICFBamSchemaDefObj> listOfSchemaDef = null;
            Collection<ICFBamSchemaDefObj> cltn = null;
            CFBorderPane form = javafxSchema.getSchemaDefFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackDefSchemaChosen());
            ((ICFBamJavaFXSchemaDefPaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus != null) {
                ICFBamSchemaDefObj referencedObj = (ICFBamSchemaDefObj) javafxReferenceLookupDefSchema
                        .getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("SCHM".equals(classCode)) {
                        form = javafxSchema.getSchemaDefFactory().newAddForm(cfFormManager, referencedObj, null,
                                true);
                        ICFBamJavaFXSchemaDefPaneCommon spec = (ICFBamJavaFXSchemaDefPaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamSchemaDefObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class DefSchemaCFReferenceEditor extends CFReferenceEditor {
        public DefSchemaCFReferenceEditor() {
            super(new DefSchemaReferenceCallback());
            setFieldName("Defining Schema Definition");
        }
    }

    protected class LookupIndexCFLabel extends CFLabel {
        public LookupIndexCFLabel() {
            super();
            setText("Lookup Index");
        }
    }

    protected class CallbackLookupIndexChosen implements ICFBamJavaFXIndexChosen {
        public CallbackLookupIndexChosen() {
        }

        public void choseIndex(ICFBamIndexObj value) {
            if (javafxReferenceLookupLookupIndex != null) {
                ICFBamTableObj cur = getJavaFXFocusAsTable();
                if (cur != null) {
                    ICFBamTableEditObj editObj = (ICFBamTableEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupLookupIndex.setReferencedObject(value);
                            editObj.setOptionalLookupLookupIndex(value);
                        }
                    }
                }
            }
        }
    }

    protected class LookupIndexReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            ICFBamTableEditObj editObj = (ICFBamTableEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupLookupIndex.getReferencedObject();
            java.util.List<ICFBamIndexObj> listOfIndex = null;
            Collection<ICFBamIndexObj> cltn = null;
            CFBorderPane form = javafxSchema.getIndexFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackLookupIndexChosen());
            ((ICFBamJavaFXIndexPaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus != null) {
                ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupLookupIndex
                        .getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("IDXD".equals(classCode)) {
                        form = javafxSchema.getIndexFactory().newAddForm(cfFormManager, referencedObj, null, true);
                        ICFBamJavaFXIndexPaneCommon spec = (ICFBamJavaFXIndexPaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamIndexObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class LookupIndexCFReferenceEditor extends CFReferenceEditor {
        public LookupIndexCFReferenceEditor() {
            super(new LookupIndexReferenceCallback());
            setFieldName("Lookup Index");
        }
    }

    protected class AltIndexCFLabel extends CFLabel {
        public AltIndexCFLabel() {
            super();
            setText("Alt Index");
        }
    }

    protected class CallbackAltIndexChosen implements ICFBamJavaFXIndexChosen {
        public CallbackAltIndexChosen() {
        }

        public void choseIndex(ICFBamIndexObj value) {
            if (javafxReferenceLookupAltIndex != null) {
                ICFBamTableObj cur = getJavaFXFocusAsTable();
                if (cur != null) {
                    ICFBamTableEditObj editObj = (ICFBamTableEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupAltIndex.setReferencedObject(value);
                            editObj.setOptionalLookupAltIndex(value);
                        }
                    }
                }
            }
        }
    }

    protected class AltIndexReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            ICFBamTableEditObj editObj = (ICFBamTableEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupAltIndex.getReferencedObject();
            java.util.List<ICFBamIndexObj> listOfIndex = null;
            Collection<ICFBamIndexObj> cltn = null;
            CFBorderPane form = javafxSchema.getIndexFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackAltIndexChosen());
            ((ICFBamJavaFXIndexPaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus != null) {
                ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupAltIndex.getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("IDXD".equals(classCode)) {
                        form = javafxSchema.getIndexFactory().newAddForm(cfFormManager, referencedObj, null, true);
                        ICFBamJavaFXIndexPaneCommon spec = (ICFBamJavaFXIndexPaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamIndexObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class AltIndexCFReferenceEditor extends CFReferenceEditor {
        public AltIndexCFReferenceEditor() {
            super(new AltIndexReferenceCallback());
            setFieldName("Alt Index");
        }
    }

    protected class QualifyingTableCFLabel extends CFLabel {
        public QualifyingTableCFLabel() {
            super();
            setText("Qualifying Table");
        }
    }

    protected class CallbackQualifyingTableChosen implements ICFBamJavaFXTableChosen {
        public CallbackQualifyingTableChosen() {
        }

        public void choseTable(ICFBamTableObj value) {
            if (javafxReferenceLookupQualTable != null) {
                ICFBamTableObj cur = getJavaFXFocusAsTable();
                if (cur != null) {
                    ICFBamTableEditObj editObj = (ICFBamTableEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupQualTable.setReferencedObject(value);
                            editObj.setOptionalLookupQualTable(value);
                        }
                    }
                }
            }
        }
    }

    protected class QualifyingTableReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            ICFBamTableEditObj editObj = (ICFBamTableEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFBamTableObj referencedObj = (ICFBamTableObj) javafxReferenceLookupQualTable.getReferencedObject();
            java.util.List<ICFBamTableObj> listOfTable = null;
            Collection<ICFBamTableObj> cltn = null;
            CFBorderPane form = javafxSchema.getTableFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackQualifyingTableChosen());
            ((ICFBamJavaFXTablePaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus != null) {
                ICFBamTableObj referencedObj = (ICFBamTableObj) javafxReferenceLookupQualTable
                        .getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("TBLD".equals(classCode)) {
                        form = javafxSchema.getTableFactory().newAddForm(cfFormManager, referencedObj, null, true);
                        ICFBamJavaFXTablePaneCommon spec = (ICFBamJavaFXTablePaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamTableObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class QualifyingTableCFReferenceEditor extends CFReferenceEditor {
        public QualifyingTableCFReferenceEditor() {
            super(new QualifyingTableReferenceCallback());
            setFieldName("Qualifying Table");
        }
    }

    protected class PrimaryIndexCFLabel extends CFLabel {
        public PrimaryIndexCFLabel() {
            super();
            setText("Primary Index");
        }
    }

    protected class CallbackPrimaryIndexChosen implements ICFBamJavaFXIndexChosen {
        public CallbackPrimaryIndexChosen() {
        }

        public void choseIndex(ICFBamIndexObj value) {
            if (javafxReferenceLookupPrimaryIndex != null) {
                ICFBamTableObj cur = getJavaFXFocusAsTable();
                if (cur != null) {
                    ICFBamTableEditObj editObj = (ICFBamTableEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupPrimaryIndex.setReferencedObject(value);
                            editObj.setOptionalLookupPrimaryIndex(value);
                        }
                    }
                }
            }
        }
    }

    protected class PrimaryIndexReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            ICFBamTableEditObj editObj = (ICFBamTableEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupPrimaryIndex.getReferencedObject();
            java.util.List<ICFBamIndexObj> listOfIndex = null;
            listOfIndex = focus.getOptionalComponentsIndex(javafxIsInitializing);
            if (listOfIndex == null) {
                throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 0,
                        "listOfIndex");
            }
            Collection<ICFBamIndexObj> cltn = listOfIndex;
            CFBorderPane form = javafxSchema.getIndexFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackPrimaryIndexChosen());
            ((ICFBamJavaFXIndexPaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus != null) {
                ICFBamIndexObj referencedObj = (ICFBamIndexObj) javafxReferenceLookupPrimaryIndex
                        .getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("IDXD".equals(classCode)) {
                        form = javafxSchema.getIndexFactory().newAddForm(cfFormManager, referencedObj, null, true);
                        ICFBamJavaFXIndexPaneCommon spec = (ICFBamJavaFXIndexPaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamIndexObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class PrimaryIndexCFReferenceEditor extends CFReferenceEditor {
        public PrimaryIndexCFReferenceEditor() {
            super(new PrimaryIndexReferenceCallback());
            setFieldName("Primary Index");
        }
    }

    protected class IdCFLabel extends CFLabel {
        public IdCFLabel() {
            super();
            setText("Id");
        }
    }

    protected class IdEditor extends CFInt64Editor {
        public IdEditor() {
            super();
            setMinValue(CFBamScopeBuff.ID_MIN_VALUE);
            setFieldName("Id");
        }
    }

    protected class NameCFLabel extends CFLabel {
        public NameCFLabel() {
            super();
            setText("Name");
        }
    }

    protected class NameEditor extends CFStringEditor {
        public NameEditor() {
            super();
            setMaxLen(192);
            setFieldName("Name");
        }
    }

    protected class DbNameCFLabel extends CFLabel {
        public DbNameCFLabel() {
            super();
            setText("Db Name");
        }
    }

    protected class DbNameEditor extends CFStringEditor {
        public DbNameEditor() {
            super();
            setMaxLen(32);
            setFieldName("Db Name");
        }
    }

    protected class ShortNameCFLabel extends CFLabel {
        public ShortNameCFLabel() {
            super();
            setText("Short Name");
        }
    }

    protected class ShortNameEditor extends CFStringEditor {
        public ShortNameEditor() {
            super();
            setMaxLen(16);
            setFieldName("Short Name");
        }
    }

    protected class LabelCFLabel extends CFLabel {
        public LabelCFLabel() {
            super();
            setText("Label");
        }
    }

    protected class LabelEditor extends CFStringEditor {
        public LabelEditor() {
            super();
            setMaxLen(64);
            setFieldName("Label");
        }
    }

    protected class ShortDescriptionCFLabel extends CFLabel {
        public ShortDescriptionCFLabel() {
            super();
            setText("Short Description");
        }
    }

    protected class ShortDescriptionEditor extends CFStringEditor {
        public ShortDescriptionEditor() {
            super();
            setMaxLen(50);
            setFieldName("Short Description");
        }
    }

    protected class DescriptionCFLabel extends CFLabel {
        public DescriptionCFLabel() {
            super();
            setText("Description");
        }
    }

    protected class DescriptionEditor extends CFStringEditor {
        public DescriptionEditor() {
            super();
            setMaxLen(100);
            setFieldName("Description");
        }
    }

    protected class PageDataCFLabel extends CFLabel {
        public PageDataCFLabel() {
            super();
            setText("PageData");
        }
    }

    protected class PageDataEditor extends CFBoolEditor {
        public PageDataEditor() {
            super();
            setIsNullable(false);
            setFieldName("PageData");
        }
    }

    protected class TableClassCodeCFLabel extends CFLabel {
        public TableClassCodeCFLabel() {
            super();
            setText("Table Class Code");
        }
    }

    protected class TableClassCodeEditor extends CFStringEditor {
        public TableClassCodeEditor() {
            super();
            setMaxLen(4);
            setFieldName("Table Class Code");
        }
    }

    protected class PolyBaseCFLabel extends CFLabel {
        public PolyBaseCFLabel() {
            super();
            setText("Polymorphic Base");
        }
    }

    protected class PolyBaseEditor extends CFBoolEditor {
        public PolyBaseEditor() {
            super();
            setIsNullable(false);
            setFieldName("Polymorphic Base");
        }
    }

    protected class IsInstantiableCFLabel extends CFLabel {
        public IsInstantiableCFLabel() {
            super();
            setText("Is Instantiable");
        }
    }

    protected class IsInstantiableEditor extends CFBoolEditor {
        public IsInstantiableEditor() {
            super();
            setIsNullable(false);
            setFieldName("Is Instantiable");
        }
    }

    protected class HasHistoryCFLabel extends CFLabel {
        public HasHistoryCFLabel() {
            super();
            setText("Has History");
        }
    }

    protected class HasHistoryEditor extends CFBoolEditor {
        public HasHistoryEditor() {
            super();
            setIsNullable(false);
            setFieldName("Has History");
        }
    }

    protected class HasAuditColumnsCFLabel extends CFLabel {
        public HasAuditColumnsCFLabel() {
            super();
            setText("Has Audit Columns");
        }
    }

    protected class HasAuditColumnsEditor extends CFBoolEditor {
        public HasAuditColumnsEditor() {
            super();
            setIsNullable(false);
            setFieldName("Has Audit Columns");
        }
    }

    protected class LoaderBehaviourCFLabel extends CFLabel {
        public LoaderBehaviourCFLabel() {
            super();
            setText("Loader Behaviour");
        }
    }

    protected class LoaderBehaviourEditor extends ComboBox<String> {
        public LoaderBehaviourEditor() {
            super();
            setItems(observableListOfLoaderBehaviour);
        }
    }

    protected class SecurityScopeCFLabel extends CFLabel {
        public SecurityScopeCFLabel() {
            super();
            setText("Security Scope");
        }
    }

    protected class SecurityScopeEditor extends ComboBox<String> {
        public SecurityScopeEditor() {
            super();
            setItems(observableListOfSecurityScope);
        }
    }

    protected class JObjMembersCFLabel extends CFLabel {
        public JObjMembersCFLabel() {
            super();
            setText("JObjMembers");
        }
    }

    protected class JObjMembersEditor extends CFTextEditor {
        public JObjMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JObjMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JObjInterfaceCFLabel extends CFLabel {
        public JObjInterfaceCFLabel() {
            super();
            setText("JObjInterface");
        }
    }

    protected class JObjInterfaceEditor extends CFTextEditor {
        public JObjInterfaceEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JObjInterface");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JObjImportCFLabel extends CFLabel {
        public JObjImportCFLabel() {
            super();
            setText("JObjImport");
        }
    }

    protected class JObjImportEditor extends CFTextEditor {
        public JObjImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JObjImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JObjImplementationCFLabel extends CFLabel {
        public JObjImplementationCFLabel() {
            super();
            setText("JObjImplementation");
        }
    }

    protected class JObjImplementationEditor extends CFTextEditor {
        public JObjImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JObjImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JEditObjMembersCFLabel extends CFLabel {
        public JEditObjMembersCFLabel() {
            super();
            setText("JEditObjMembers");
        }
    }

    protected class JEditObjMembersEditor extends CFTextEditor {
        public JEditObjMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JEditObjMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JEditObjInterfaceCFLabel extends CFLabel {
        public JEditObjInterfaceCFLabel() {
            super();
            setText("JEditObjInterface");
        }
    }

    protected class JEditObjInterfaceEditor extends CFTextEditor {
        public JEditObjInterfaceEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JEditObjInterface");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JEditObjImportCFLabel extends CFLabel {
        public JEditObjImportCFLabel() {
            super();
            setText("JEditObjImport");
        }
    }

    protected class JEditObjImportEditor extends CFTextEditor {
        public JEditObjImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JEditObjImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JEditObjImplementationCFLabel extends CFLabel {
        public JEditObjImplementationCFLabel() {
            super();
            setText("JEditObjImplementation");
        }
    }

    protected class JEditObjImplementationEditor extends CFTextEditor {
        public JEditObjImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JEditObjImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableImportCFLabel extends CFLabel {
        public JTableImportCFLabel() {
            super();
            setText("JTableImport");
        }
    }

    protected class JTableImportEditor extends CFTextEditor {
        public JTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableMembersCFLabel extends CFLabel {
        public JTableMembersCFLabel() {
            super();
            setText("JTableMembers");
        }
    }

    protected class JTableMembersEditor extends CFTextEditor {
        public JTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableInterfaceCFLabel extends CFLabel {
        public JTableInterfaceCFLabel() {
            super();
            setText("JTableInterface");
        }
    }

    protected class JTableInterfaceEditor extends CFTextEditor {
        public JTableInterfaceEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableInterface");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableImplementationCFLabel extends CFLabel {
        public JTableImplementationCFLabel() {
            super();
            setText("JTableImplementation");
        }
    }

    protected class JTableImplementationEditor extends CFTextEditor {
        public JTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableObjImportCFLabel extends CFLabel {
        public JTableObjImportCFLabel() {
            super();
            setText("JTableObjImport");
        }
    }

    protected class JTableObjImportEditor extends CFTextEditor {
        public JTableObjImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableObjImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableObjMembersCFLabel extends CFLabel {
        public JTableObjMembersCFLabel() {
            super();
            setText("JTableObjMembers");
        }
    }

    protected class JTableObjMembersEditor extends CFTextEditor {
        public JTableObjMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableObjMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableObjInterfaceCFLabel extends CFLabel {
        public JTableObjInterfaceCFLabel() {
            super();
            setText("JTableObjInterface");
        }
    }

    protected class JTableObjInterfaceEditor extends CFTextEditor {
        public JTableObjInterfaceEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableObjInterface");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JTableObjImplementationCFLabel extends CFLabel {
        public JTableObjImplementationCFLabel() {
            super();
            setText("JTableObjImplementation");
        }
    }

    protected class JTableObjImplementationEditor extends CFTextEditor {
        public JTableObjImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JTableObjImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JDb2LUWTableImportCFLabel extends CFLabel {
        public JDb2LUWTableImportCFLabel() {
            super();
            setText("JDb2LUWTableImport");
        }
    }

    protected class JDb2LUWTableImportEditor extends CFTextEditor {
        public JDb2LUWTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JDb2LUWTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JDb2LUWTableMembersCFLabel extends CFLabel {
        public JDb2LUWTableMembersCFLabel() {
            super();
            setText("JDb2LUWTableMembers");
        }
    }

    protected class JDb2LUWTableMembersEditor extends CFTextEditor {
        public JDb2LUWTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JDb2LUWTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JDb2LUWTableImplementationCFLabel extends CFLabel {
        public JDb2LUWTableImplementationCFLabel() {
            super();
            setText("JDb2LUWTableImplementation");
        }
    }

    protected class JDb2LUWTableImplementationEditor extends CFTextEditor {
        public JDb2LUWTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JDb2LUWTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMSSqlTableImportCFLabel extends CFLabel {
        public JMSSqlTableImportCFLabel() {
            super();
            setText("JMSSqlTableImport");
        }
    }

    protected class JMSSqlTableImportEditor extends CFTextEditor {
        public JMSSqlTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMSSqlTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMSSqlTableMembersCFLabel extends CFLabel {
        public JMSSqlTableMembersCFLabel() {
            super();
            setText("JMSSqlTableMembers");
        }
    }

    protected class JMSSqlTableMembersEditor extends CFTextEditor {
        public JMSSqlTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMSSqlTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMSSqlTableImplementationCFLabel extends CFLabel {
        public JMSSqlTableImplementationCFLabel() {
            super();
            setText("JMSSqlTableImplementation");
        }
    }

    protected class JMSSqlTableImplementationEditor extends CFTextEditor {
        public JMSSqlTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMSSqlTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMySqlTableImportCFLabel extends CFLabel {
        public JMySqlTableImportCFLabel() {
            super();
            setText("JMySqlTableImport");
        }
    }

    protected class JMySqlTableImportEditor extends CFTextEditor {
        public JMySqlTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMySqlTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMySqlTableMembersCFLabel extends CFLabel {
        public JMySqlTableMembersCFLabel() {
            super();
            setText("JMySqlTableMembers");
        }
    }

    protected class JMySqlTableMembersEditor extends CFTextEditor {
        public JMySqlTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMySqlTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JMySqlTableImplementationCFLabel extends CFLabel {
        public JMySqlTableImplementationCFLabel() {
            super();
            setText("JMySqlTableImplementation");
        }
    }

    protected class JMySqlTableImplementationEditor extends CFTextEditor {
        public JMySqlTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JMySqlTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JOracleTableImportCFLabel extends CFLabel {
        public JOracleTableImportCFLabel() {
            super();
            setText("JOracleTableImport");
        }
    }

    protected class JOracleTableImportEditor extends CFTextEditor {
        public JOracleTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JOracleTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JOracleTableMembersCFLabel extends CFLabel {
        public JOracleTableMembersCFLabel() {
            super();
            setText("JOracleTableMembers");
        }
    }

    protected class JOracleTableMembersEditor extends CFTextEditor {
        public JOracleTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JOracleTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JOracleTableImplementationCFLabel extends CFLabel {
        public JOracleTableImplementationCFLabel() {
            super();
            setText("JOracleTableImplementation");
        }
    }

    protected class JOracleTableImplementationEditor extends CFTextEditor {
        public JOracleTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JOracleTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JPgSqlTableImportCFLabel extends CFLabel {
        public JPgSqlTableImportCFLabel() {
            super();
            setText("JPgSqlTableImport");
        }
    }

    protected class JPgSqlTableImportEditor extends CFTextEditor {
        public JPgSqlTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JPgSqlTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JPgSqlTableMembersCFLabel extends CFLabel {
        public JPgSqlTableMembersCFLabel() {
            super();
            setText("JPgSqlTableMembers");
        }
    }

    protected class JPgSqlTableMembersEditor extends CFTextEditor {
        public JPgSqlTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JPgSqlTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JPgSqlTableImplementationCFLabel extends CFLabel {
        public JPgSqlTableImplementationCFLabel() {
            super();
            setText("JPgSqlTableImplementation");
        }
    }

    protected class JPgSqlTableImplementationEditor extends CFTextEditor {
        public JPgSqlTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JPgSqlTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSybaseTableImportCFLabel extends CFLabel {
        public JSybaseTableImportCFLabel() {
            super();
            setText("JSybaseTableImport");
        }
    }

    protected class JSybaseTableImportEditor extends CFTextEditor {
        public JSybaseTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSybaseTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSybaseTableMembersCFLabel extends CFLabel {
        public JSybaseTableMembersCFLabel() {
            super();
            setText("JSybaseTableMembers");
        }
    }

    protected class JSybaseTableMembersEditor extends CFTextEditor {
        public JSybaseTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSybaseTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSybaseTableImplementationCFLabel extends CFLabel {
        public JSybaseTableImplementationCFLabel() {
            super();
            setText("JSybaseTableImplementation");
        }
    }

    protected class JSybaseTableImplementationEditor extends CFTextEditor {
        public JSybaseTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSybaseTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JRamTableImportCFLabel extends CFLabel {
        public JRamTableImportCFLabel() {
            super();
            setText("JRamTableImport");
        }
    }

    protected class JRamTableImportEditor extends CFTextEditor {
        public JRamTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JRamTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JRamTableMembersCFLabel extends CFLabel {
        public JRamTableMembersCFLabel() {
            super();
            setText("JRamTableMembers");
        }
    }

    protected class JRamTableMembersEditor extends CFTextEditor {
        public JRamTableMembersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JRamTableMembers");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JRamTableImplementationCFLabel extends CFLabel {
        public JRamTableImplementationCFLabel() {
            super();
            setText("JRamTableImplementation");
        }
    }

    protected class JRamTableImplementationEditor extends CFTextEditor {
        public JRamTableImplementationEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JRamTableImplementation");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSaxLoaderImportCFLabel extends CFLabel {
        public JSaxLoaderImportCFLabel() {
            super();
            setText("JSaxLoaderImport");
        }
    }

    protected class JSaxLoaderImportEditor extends CFTextEditor {
        public JSaxLoaderImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSaxLoaderImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSaxLoaderStartElementCFLabel extends CFLabel {
        public JSaxLoaderStartElementCFLabel() {
            super();
            setText("JSaxLoaderStartElement");
        }
    }

    protected class JSaxLoaderStartElementEditor extends CFTextEditor {
        public JSaxLoaderStartElementEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSaxLoaderStartElement");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JSaxLoaderEndElementCFLabel extends CFLabel {
        public JSaxLoaderEndElementCFLabel() {
            super();
            setText("JSaxLoaderEndElement");
        }
    }

    protected class JSaxLoaderEndElementEditor extends CFTextEditor {
        public JSaxLoaderEndElementEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JSaxLoaderEndElement");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgTableImportCFLabel extends CFLabel {
        public JXMsgTableImportCFLabel() {
            super();
            setText("JXMsgTableImport");
        }
    }

    protected class JXMsgTableImportEditor extends CFTextEditor {
        public JXMsgTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgTableFormattersCFLabel extends CFLabel {
        public JXMsgTableFormattersCFLabel() {
            super();
            setText("JXMsgTableFormatters");
        }
    }

    protected class JXMsgTableFormattersEditor extends CFTextEditor {
        public JXMsgTableFormattersEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgTableFormatters");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgRqstTableImportCFLabel extends CFLabel {
        public JXMsgRqstTableImportCFLabel() {
            super();
            setText("JXMsgRqstTableImport");
        }
    }

    protected class JXMsgRqstTableImportEditor extends CFTextEditor {
        public JXMsgRqstTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgRqstTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgRspnTableImportCFLabel extends CFLabel {
        public JXMsgRspnTableImportCFLabel() {
            super();
            setText("JXMsgRspnTableImport");
        }
    }

    protected class JXMsgRspnTableImportEditor extends CFTextEditor {
        public JXMsgRspnTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgRspnTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgClientTableImportCFLabel extends CFLabel {
        public JXMsgClientTableImportCFLabel() {
            super();
            setText("JXMsgClientTableImport");
        }
    }

    protected class JXMsgClientTableImportEditor extends CFTextEditor {
        public JXMsgClientTableImportEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgClientTableImport");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgRqstTableBodyCFLabel extends CFLabel {
        public JXMsgRqstTableBodyCFLabel() {
            super();
            setText("JXMsgRqstTableBody");
        }
    }

    protected class JXMsgRqstTableBodyEditor extends CFTextEditor {
        public JXMsgRqstTableBodyEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgRqstTableBody");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgRspnTableBodyCFLabel extends CFLabel {
        public JXMsgRspnTableBodyCFLabel() {
            super();
            setText("JXMsgRspnTableBody");
        }
    }

    protected class JXMsgRspnTableBodyEditor extends CFTextEditor {
        public JXMsgRspnTableBodyEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgRspnTableBody");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class JXMsgClientTableBodyCFLabel extends CFLabel {
        public JXMsgClientTableBodyCFLabel() {
            super();
            setText("JXMsgClientTableBody");
        }
    }

    protected class JXMsgClientTableBodyEditor extends CFTextEditor {
        public JXMsgClientTableBodyEditor() {
            super();
            setMaxLen(2000000);
            setFieldName("JXMsgClientTableBody");
            setPrefHeight(10 * 20);
            setMinHeight(10 * 20);
        }
    }

    protected class DefaultVisibilityCFLabel extends CFLabel {
        public DefaultVisibilityCFLabel() {
            super();
            setText("DefaultVisibility");
        }
    }

    protected class DefaultVisibilityEditor extends CFBoolEditor {
        public DefaultVisibilityEditor() {
            super();
            setIsNullable(false);
            setFieldName("DefaultVisibility");
        }
    }

    protected ICFBamSchemaDefObj javafxLookupDefSchemaObj = null;
    protected DefSchemaCFLabel javafxLabelLookupDefSchema = null;
    protected DefSchemaCFReferenceEditor javafxReferenceLookupDefSchema = null;
    protected ICFBamIndexObj javafxLookupLookupIndexObj = null;
    protected LookupIndexCFLabel javafxLabelLookupLookupIndex = null;
    protected LookupIndexCFReferenceEditor javafxReferenceLookupLookupIndex = null;
    protected ICFBamIndexObj javafxLookupAltIndexObj = null;
    protected AltIndexCFLabel javafxLabelLookupAltIndex = null;
    protected AltIndexCFReferenceEditor javafxReferenceLookupAltIndex = null;
    protected ICFBamTableObj javafxLookupQualTableObj = null;
    protected QualifyingTableCFLabel javafxLabelLookupQualTable = null;
    protected QualifyingTableCFReferenceEditor javafxReferenceLookupQualTable = null;
    protected ICFBamIndexObj javafxLookupPrimaryIndexObj = null;
    protected PrimaryIndexCFLabel javafxLabelLookupPrimaryIndex = null;
    protected PrimaryIndexCFReferenceEditor javafxReferenceLookupPrimaryIndex = null;
    protected IdCFLabel javafxLabelId = null;
    protected IdEditor javafxEditorId = null;
    protected NameCFLabel javafxLabelName = null;
    protected NameEditor javafxEditorName = null;
    protected DbNameCFLabel javafxLabelDbName = null;
    protected DbNameEditor javafxEditorDbName = null;
    protected ShortNameCFLabel javafxLabelShortName = null;
    protected ShortNameEditor javafxEditorShortName = null;
    protected LabelCFLabel javafxLabelLabel = null;
    protected LabelEditor javafxEditorLabel = null;
    protected ShortDescriptionCFLabel javafxLabelShortDescription = null;
    protected ShortDescriptionEditor javafxEditorShortDescription = null;
    protected DescriptionCFLabel javafxLabelDescription = null;
    protected DescriptionEditor javafxEditorDescription = null;
    protected PageDataCFLabel javafxLabelPageData = null;
    protected PageDataEditor javafxEditorPageData = null;
    protected TableClassCodeCFLabel javafxLabelTableClassCode = null;
    protected TableClassCodeEditor javafxEditorTableClassCode = null;
    protected PolyBaseCFLabel javafxLabelPolyBase = null;
    protected PolyBaseEditor javafxEditorPolyBase = null;
    protected IsInstantiableCFLabel javafxLabelIsInstantiable = null;
    protected IsInstantiableEditor javafxEditorIsInstantiable = null;
    protected HasHistoryCFLabel javafxLabelHasHistory = null;
    protected HasHistoryEditor javafxEditorHasHistory = null;
    protected HasAuditColumnsCFLabel javafxLabelHasAuditColumns = null;
    protected HasAuditColumnsEditor javafxEditorHasAuditColumns = null;
    protected LoaderBehaviourCFLabel javafxLabelLoaderBehaviour = null;
    protected LoaderBehaviourEditor javafxEditorLoaderBehaviour = null;
    protected SecurityScopeCFLabel javafxLabelSecurityScope = null;
    protected SecurityScopeEditor javafxEditorSecurityScope = null;
    protected JObjMembersCFLabel javafxLabelJObjMembers = null;
    protected JObjMembersEditor javafxEditorJObjMembers = null;
    protected JObjInterfaceCFLabel javafxLabelJObjInterface = null;
    protected JObjInterfaceEditor javafxEditorJObjInterface = null;
    protected JObjImportCFLabel javafxLabelJObjImport = null;
    protected JObjImportEditor javafxEditorJObjImport = null;
    protected JObjImplementationCFLabel javafxLabelJObjImplementation = null;
    protected JObjImplementationEditor javafxEditorJObjImplementation = null;
    protected JEditObjMembersCFLabel javafxLabelJEditObjMembers = null;
    protected JEditObjMembersEditor javafxEditorJEditObjMembers = null;
    protected JEditObjInterfaceCFLabel javafxLabelJEditObjInterface = null;
    protected JEditObjInterfaceEditor javafxEditorJEditObjInterface = null;
    protected JEditObjImportCFLabel javafxLabelJEditObjImport = null;
    protected JEditObjImportEditor javafxEditorJEditObjImport = null;
    protected JEditObjImplementationCFLabel javafxLabelJEditObjImplementation = null;
    protected JEditObjImplementationEditor javafxEditorJEditObjImplementation = null;
    protected JTableImportCFLabel javafxLabelJTableImport = null;
    protected JTableImportEditor javafxEditorJTableImport = null;
    protected JTableMembersCFLabel javafxLabelJTableMembers = null;
    protected JTableMembersEditor javafxEditorJTableMembers = null;
    protected JTableInterfaceCFLabel javafxLabelJTableInterface = null;
    protected JTableInterfaceEditor javafxEditorJTableInterface = null;
    protected JTableImplementationCFLabel javafxLabelJTableImplementation = null;
    protected JTableImplementationEditor javafxEditorJTableImplementation = null;
    protected JTableObjImportCFLabel javafxLabelJTableObjImport = null;
    protected JTableObjImportEditor javafxEditorJTableObjImport = null;
    protected JTableObjMembersCFLabel javafxLabelJTableObjMembers = null;
    protected JTableObjMembersEditor javafxEditorJTableObjMembers = null;
    protected JTableObjInterfaceCFLabel javafxLabelJTableObjInterface = null;
    protected JTableObjInterfaceEditor javafxEditorJTableObjInterface = null;
    protected JTableObjImplementationCFLabel javafxLabelJTableObjImplementation = null;
    protected JTableObjImplementationEditor javafxEditorJTableObjImplementation = null;
    protected JDb2LUWTableImportCFLabel javafxLabelJDb2LUWTableImport = null;
    protected JDb2LUWTableImportEditor javafxEditorJDb2LUWTableImport = null;
    protected JDb2LUWTableMembersCFLabel javafxLabelJDb2LUWTableMembers = null;
    protected JDb2LUWTableMembersEditor javafxEditorJDb2LUWTableMembers = null;
    protected JDb2LUWTableImplementationCFLabel javafxLabelJDb2LUWTableImplementation = null;
    protected JDb2LUWTableImplementationEditor javafxEditorJDb2LUWTableImplementation = null;
    protected JMSSqlTableImportCFLabel javafxLabelJMSSqlTableImport = null;
    protected JMSSqlTableImportEditor javafxEditorJMSSqlTableImport = null;
    protected JMSSqlTableMembersCFLabel javafxLabelJMSSqlTableMembers = null;
    protected JMSSqlTableMembersEditor javafxEditorJMSSqlTableMembers = null;
    protected JMSSqlTableImplementationCFLabel javafxLabelJMSSqlTableImplementation = null;
    protected JMSSqlTableImplementationEditor javafxEditorJMSSqlTableImplementation = null;
    protected JMySqlTableImportCFLabel javafxLabelJMySqlTableImport = null;
    protected JMySqlTableImportEditor javafxEditorJMySqlTableImport = null;
    protected JMySqlTableMembersCFLabel javafxLabelJMySqlTableMembers = null;
    protected JMySqlTableMembersEditor javafxEditorJMySqlTableMembers = null;
    protected JMySqlTableImplementationCFLabel javafxLabelJMySqlTableImplementation = null;
    protected JMySqlTableImplementationEditor javafxEditorJMySqlTableImplementation = null;
    protected JOracleTableImportCFLabel javafxLabelJOracleTableImport = null;
    protected JOracleTableImportEditor javafxEditorJOracleTableImport = null;
    protected JOracleTableMembersCFLabel javafxLabelJOracleTableMembers = null;
    protected JOracleTableMembersEditor javafxEditorJOracleTableMembers = null;
    protected JOracleTableImplementationCFLabel javafxLabelJOracleTableImplementation = null;
    protected JOracleTableImplementationEditor javafxEditorJOracleTableImplementation = null;
    protected JPgSqlTableImportCFLabel javafxLabelJPgSqlTableImport = null;
    protected JPgSqlTableImportEditor javafxEditorJPgSqlTableImport = null;
    protected JPgSqlTableMembersCFLabel javafxLabelJPgSqlTableMembers = null;
    protected JPgSqlTableMembersEditor javafxEditorJPgSqlTableMembers = null;
    protected JPgSqlTableImplementationCFLabel javafxLabelJPgSqlTableImplementation = null;
    protected JPgSqlTableImplementationEditor javafxEditorJPgSqlTableImplementation = null;
    protected JSybaseTableImportCFLabel javafxLabelJSybaseTableImport = null;
    protected JSybaseTableImportEditor javafxEditorJSybaseTableImport = null;
    protected JSybaseTableMembersCFLabel javafxLabelJSybaseTableMembers = null;
    protected JSybaseTableMembersEditor javafxEditorJSybaseTableMembers = null;
    protected JSybaseTableImplementationCFLabel javafxLabelJSybaseTableImplementation = null;
    protected JSybaseTableImplementationEditor javafxEditorJSybaseTableImplementation = null;
    protected JRamTableImportCFLabel javafxLabelJRamTableImport = null;
    protected JRamTableImportEditor javafxEditorJRamTableImport = null;
    protected JRamTableMembersCFLabel javafxLabelJRamTableMembers = null;
    protected JRamTableMembersEditor javafxEditorJRamTableMembers = null;
    protected JRamTableImplementationCFLabel javafxLabelJRamTableImplementation = null;
    protected JRamTableImplementationEditor javafxEditorJRamTableImplementation = null;
    protected JSaxLoaderImportCFLabel javafxLabelJSaxLoaderImport = null;
    protected JSaxLoaderImportEditor javafxEditorJSaxLoaderImport = null;
    protected JSaxLoaderStartElementCFLabel javafxLabelJSaxLoaderStartElement = null;
    protected JSaxLoaderStartElementEditor javafxEditorJSaxLoaderStartElement = null;
    protected JSaxLoaderEndElementCFLabel javafxLabelJSaxLoaderEndElement = null;
    protected JSaxLoaderEndElementEditor javafxEditorJSaxLoaderEndElement = null;
    protected JXMsgTableImportCFLabel javafxLabelJXMsgTableImport = null;
    protected JXMsgTableImportEditor javafxEditorJXMsgTableImport = null;
    protected JXMsgTableFormattersCFLabel javafxLabelJXMsgTableFormatters = null;
    protected JXMsgTableFormattersEditor javafxEditorJXMsgTableFormatters = null;
    protected JXMsgRqstTableImportCFLabel javafxLabelJXMsgRqstTableImport = null;
    protected JXMsgRqstTableImportEditor javafxEditorJXMsgRqstTableImport = null;
    protected JXMsgRspnTableImportCFLabel javafxLabelJXMsgRspnTableImport = null;
    protected JXMsgRspnTableImportEditor javafxEditorJXMsgRspnTableImport = null;
    protected JXMsgClientTableImportCFLabel javafxLabelJXMsgClientTableImport = null;
    protected JXMsgClientTableImportEditor javafxEditorJXMsgClientTableImport = null;
    protected JXMsgRqstTableBodyCFLabel javafxLabelJXMsgRqstTableBody = null;
    protected JXMsgRqstTableBodyEditor javafxEditorJXMsgRqstTableBody = null;
    protected JXMsgRspnTableBodyCFLabel javafxLabelJXMsgRspnTableBody = null;
    protected JXMsgRspnTableBodyEditor javafxEditorJXMsgRspnTableBody = null;
    protected JXMsgClientTableBodyCFLabel javafxLabelJXMsgClientTableBody = null;
    protected JXMsgClientTableBodyEditor javafxEditorJXMsgClientTableBody = null;
    protected DefaultVisibilityCFLabel javafxLabelDefaultVisibility = null;
    protected DefaultVisibilityEditor javafxEditorDefaultVisibility = null;

    public CFBamJavaFXTableAttrPane(ICFFormManager formManager, ICFBamJavaFXSchema argSchema,
            ICFBamTableObj argFocus) {
        super();
        Control ctrl;
        CFLabel label;
        CFReferenceEditor reference;
        final String S_ProcName = "construct-schema-focus";
        if (formManager == null) {
            throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 1,
                    "formManager");
        }
        cfFormManager = formManager;
        if (argSchema == null) {
            throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 2,
                    "argSchema");
        }
        // argFocus is optional; focus may be set later during execution as
        // conditions of the runtime change.
        javafxSchema = argSchema;
        setJavaFXFocusAsTable(argFocus);
        setPadding(new Insets(5));
        setHgap(5);
        setVgap(5);
        setAlignment(Pos.CENTER);
        ColumnConstraints column1 = new ColumnConstraints(125);
        ColumnConstraints column2 = new ColumnConstraints(125, 300, 500);
        column2.setHgrow(Priority.ALWAYS);
        getColumnConstraints().addAll(column1, column2);
        int gridRow = 0;
        label = getJavaFXLabelLookupDefSchema();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupDefSchema();
        setHalignment(reference, HPos.LEFT);
        add(reference, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLookupLookupIndex();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupLookupIndex();
        setHalignment(reference, HPos.LEFT);
        add(reference, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLookupAltIndex();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupAltIndex();
        setHalignment(reference, HPos.LEFT);
        add(reference, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLookupQualTable();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupQualTable();
        setHalignment(reference, HPos.LEFT);
        add(reference, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLookupPrimaryIndex();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupPrimaryIndex();
        setHalignment(reference, HPos.LEFT);
        add(reference, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelId();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorId();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelName();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorName();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelDbName();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorDbName();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelShortName();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorShortName();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLabel();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorLabel();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelShortDescription();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorShortDescription();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelDescription();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorDescription();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelPageData();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorPageData();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelTableClassCode();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorTableClassCode();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelPolyBase();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorPolyBase();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelIsInstantiable();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorIsInstantiable();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelHasHistory();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorHasHistory();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelHasAuditColumns();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorHasAuditColumns();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelLoaderBehaviour();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorLoaderBehaviour();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelSecurityScope();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorSecurityScope();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJObjMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJObjMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJObjInterface();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJObjInterface();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJObjImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJObjImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJObjImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJObjImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJEditObjMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJEditObjMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJEditObjInterface();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJEditObjInterface();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJEditObjImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJEditObjImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJEditObjImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJEditObjImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableInterface();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableInterface();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableObjImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableObjImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableObjMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableObjMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableObjInterface();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableObjInterface();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJTableObjImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJTableObjImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJDb2LUWTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJDb2LUWTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJDb2LUWTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJDb2LUWTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJDb2LUWTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJDb2LUWTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMSSqlTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMSSqlTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMSSqlTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMSSqlTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMSSqlTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMSSqlTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMySqlTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMySqlTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMySqlTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMySqlTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJMySqlTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJMySqlTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJOracleTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJOracleTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJOracleTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJOracleTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJOracleTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJOracleTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJPgSqlTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJPgSqlTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJPgSqlTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJPgSqlTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJPgSqlTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJPgSqlTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSybaseTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSybaseTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSybaseTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSybaseTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSybaseTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSybaseTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJRamTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJRamTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJRamTableMembers();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJRamTableMembers();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJRamTableImplementation();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJRamTableImplementation();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSaxLoaderImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSaxLoaderImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSaxLoaderStartElement();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSaxLoaderStartElement();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJSaxLoaderEndElement();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJSaxLoaderEndElement();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgTableFormatters();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgTableFormatters();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgRqstTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgRqstTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgRspnTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgRspnTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgClientTableImport();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgClientTableImport();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgRqstTableBody();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgRqstTableBody();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgRspnTableBody();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgRspnTableBody();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelJXMsgClientTableBody();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorJXMsgClientTableBody();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        label = getJavaFXLabelDefaultVisibility();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        ctrl = getJavaFXEditorDefaultVisibility();
        setHalignment(ctrl, HPos.LEFT);
        add(ctrl, 1, gridRow);

        gridRow++;

        populateFields();
        adjustComponentEnableStates();
        javafxIsInitializing = false;
    }

    public ICFFormManager getCFFormManager() {
        return (cfFormManager);
    }

    public void setCFFormManager(ICFFormManager value) {
        final String S_ProcName = "setCFFormManager";
        if (value == null) {
            throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 1, "value");
        }
        cfFormManager = value;
    }

    public ICFBamJavaFXSchema getJavaFXSchema() {
        return (javafxSchema);
    }

    public void setJavaFXFocus(ICFLibAnyObj value) {
        final String S_ProcName = "setJavaFXFocus";
        if ((value == null) || (value instanceof ICFBamTableObj)) {
            super.setJavaFXFocus(value);
        } else {
            throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(), S_ProcName, "value",
                    value, "ICFBamTableObj");
        }
        populateFields();
        adjustComponentEnableStates();
    }

    public ICFBamTableObj getJavaFXFocusAsTable() {
        return ((ICFBamTableObj) getJavaFXFocus());
    }

    public void setJavaFXFocusAsTable(ICFBamTableObj value) {
        setJavaFXFocus(value);
    }

    public ICFBamSchemaDefObj getJavaFXLookupDefSchemaObj() {
        return (javafxLookupDefSchemaObj);
    }

    public void setJavaFXLookupDefSchemaObj(ICFBamSchemaDefObj value) {
        javafxLookupDefSchemaObj = value;
    }

    public CFLabel getJavaFXLabelLookupDefSchema() {
        if (javafxLabelLookupDefSchema == null) {
            javafxLabelLookupDefSchema = new DefSchemaCFLabel();
        }
        return (javafxLabelLookupDefSchema);
    }

    public CFReferenceEditor getJavaFXReferenceLookupDefSchema() {
        if (javafxReferenceLookupDefSchema == null) {
            javafxReferenceLookupDefSchema = new DefSchemaCFReferenceEditor();
        }
        return (javafxReferenceLookupDefSchema);
    }

    public void setJavaFXReferenceLookupDefSchema(DefSchemaCFReferenceEditor value) {
        javafxReferenceLookupDefSchema = value;
    }

    public ICFBamIndexObj getJavaFXLookupLookupIndexObj() {
        return (javafxLookupLookupIndexObj);
    }

    public void setJavaFXLookupLookupIndexObj(ICFBamIndexObj value) {
        javafxLookupLookupIndexObj = value;
    }

    public CFLabel getJavaFXLabelLookupLookupIndex() {
        if (javafxLabelLookupLookupIndex == null) {
            javafxLabelLookupLookupIndex = new LookupIndexCFLabel();
        }
        return (javafxLabelLookupLookupIndex);
    }

    public CFReferenceEditor getJavaFXReferenceLookupLookupIndex() {
        if (javafxReferenceLookupLookupIndex == null) {
            javafxReferenceLookupLookupIndex = new LookupIndexCFReferenceEditor();
        }
        return (javafxReferenceLookupLookupIndex);
    }

    public void setJavaFXReferenceLookupLookupIndex(LookupIndexCFReferenceEditor value) {
        javafxReferenceLookupLookupIndex = value;
    }

    public ICFBamIndexObj getJavaFXLookupAltIndexObj() {
        return (javafxLookupAltIndexObj);
    }

    public void setJavaFXLookupAltIndexObj(ICFBamIndexObj value) {
        javafxLookupAltIndexObj = value;
    }

    public CFLabel getJavaFXLabelLookupAltIndex() {
        if (javafxLabelLookupAltIndex == null) {
            javafxLabelLookupAltIndex = new AltIndexCFLabel();
        }
        return (javafxLabelLookupAltIndex);
    }

    public CFReferenceEditor getJavaFXReferenceLookupAltIndex() {
        if (javafxReferenceLookupAltIndex == null) {
            javafxReferenceLookupAltIndex = new AltIndexCFReferenceEditor();
        }
        return (javafxReferenceLookupAltIndex);
    }

    public void setJavaFXReferenceLookupAltIndex(AltIndexCFReferenceEditor value) {
        javafxReferenceLookupAltIndex = value;
    }

    public ICFBamTableObj getJavaFXLookupQualTableObj() {
        return (javafxLookupQualTableObj);
    }

    public void setJavaFXLookupQualTableObj(ICFBamTableObj value) {
        javafxLookupQualTableObj = value;
    }

    public CFLabel getJavaFXLabelLookupQualTable() {
        if (javafxLabelLookupQualTable == null) {
            javafxLabelLookupQualTable = new QualifyingTableCFLabel();
        }
        return (javafxLabelLookupQualTable);
    }

    public CFReferenceEditor getJavaFXReferenceLookupQualTable() {
        if (javafxReferenceLookupQualTable == null) {
            javafxReferenceLookupQualTable = new QualifyingTableCFReferenceEditor();
        }
        return (javafxReferenceLookupQualTable);
    }

    public void setJavaFXReferenceLookupQualTable(QualifyingTableCFReferenceEditor value) {
        javafxReferenceLookupQualTable = value;
    }

    public ICFBamIndexObj getJavaFXLookupPrimaryIndexObj() {
        return (javafxLookupPrimaryIndexObj);
    }

    public void setJavaFXLookupPrimaryIndexObj(ICFBamIndexObj value) {
        javafxLookupPrimaryIndexObj = value;
    }

    public CFLabel getJavaFXLabelLookupPrimaryIndex() {
        if (javafxLabelLookupPrimaryIndex == null) {
            javafxLabelLookupPrimaryIndex = new PrimaryIndexCFLabel();
        }
        return (javafxLabelLookupPrimaryIndex);
    }

    public CFReferenceEditor getJavaFXReferenceLookupPrimaryIndex() {
        if (javafxReferenceLookupPrimaryIndex == null) {
            javafxReferenceLookupPrimaryIndex = new PrimaryIndexCFReferenceEditor();
        }
        return (javafxReferenceLookupPrimaryIndex);
    }

    public void setJavaFXReferenceLookupPrimaryIndex(PrimaryIndexCFReferenceEditor value) {
        javafxReferenceLookupPrimaryIndex = value;
    }

    public IdCFLabel getJavaFXLabelId() {
        if (javafxLabelId == null) {
            javafxLabelId = new IdCFLabel();
        }
        return (javafxLabelId);
    }

    public void setJavaFXLabelId(IdCFLabel value) {
        javafxLabelId = value;
    }

    public IdEditor getJavaFXEditorId() {
        if (javafxEditorId == null) {
            javafxEditorId = new IdEditor();
        }
        return (javafxEditorId);
    }

    public void setJavaFXEditorId(IdEditor value) {
        javafxEditorId = value;
    }

    public NameCFLabel getJavaFXLabelName() {
        if (javafxLabelName == null) {
            javafxLabelName = new NameCFLabel();
        }
        return (javafxLabelName);
    }

    public void setJavaFXLabelName(NameCFLabel value) {
        javafxLabelName = value;
    }

    public NameEditor getJavaFXEditorName() {
        if (javafxEditorName == null) {
            javafxEditorName = new NameEditor();
        }
        return (javafxEditorName);
    }

    public void setJavaFXEditorName(NameEditor value) {
        javafxEditorName = value;
    }

    public DbNameCFLabel getJavaFXLabelDbName() {
        if (javafxLabelDbName == null) {
            javafxLabelDbName = new DbNameCFLabel();
        }
        return (javafxLabelDbName);
    }

    public void setJavaFXLabelDbName(DbNameCFLabel value) {
        javafxLabelDbName = value;
    }

    public DbNameEditor getJavaFXEditorDbName() {
        if (javafxEditorDbName == null) {
            javafxEditorDbName = new DbNameEditor();
        }
        return (javafxEditorDbName);
    }

    public void setJavaFXEditorDbName(DbNameEditor value) {
        javafxEditorDbName = value;
    }

    public ShortNameCFLabel getJavaFXLabelShortName() {
        if (javafxLabelShortName == null) {
            javafxLabelShortName = new ShortNameCFLabel();
        }
        return (javafxLabelShortName);
    }

    public void setJavaFXLabelShortName(ShortNameCFLabel value) {
        javafxLabelShortName = value;
    }

    public ShortNameEditor getJavaFXEditorShortName() {
        if (javafxEditorShortName == null) {
            javafxEditorShortName = new ShortNameEditor();
        }
        return (javafxEditorShortName);
    }

    public void setJavaFXEditorShortName(ShortNameEditor value) {
        javafxEditorShortName = value;
    }

    public LabelCFLabel getJavaFXLabelLabel() {
        if (javafxLabelLabel == null) {
            javafxLabelLabel = new LabelCFLabel();
        }
        return (javafxLabelLabel);
    }

    public void setJavaFXLabelLabel(LabelCFLabel value) {
        javafxLabelLabel = value;
    }

    public LabelEditor getJavaFXEditorLabel() {
        if (javafxEditorLabel == null) {
            javafxEditorLabel = new LabelEditor();
        }
        return (javafxEditorLabel);
    }

    public void setJavaFXEditorLabel(LabelEditor value) {
        javafxEditorLabel = value;
    }

    public ShortDescriptionCFLabel getJavaFXLabelShortDescription() {
        if (javafxLabelShortDescription == null) {
            javafxLabelShortDescription = new ShortDescriptionCFLabel();
        }
        return (javafxLabelShortDescription);
    }

    public void setJavaFXLabelShortDescription(ShortDescriptionCFLabel value) {
        javafxLabelShortDescription = value;
    }

    public ShortDescriptionEditor getJavaFXEditorShortDescription() {
        if (javafxEditorShortDescription == null) {
            javafxEditorShortDescription = new ShortDescriptionEditor();
        }
        return (javafxEditorShortDescription);
    }

    public void setJavaFXEditorShortDescription(ShortDescriptionEditor value) {
        javafxEditorShortDescription = value;
    }

    public DescriptionCFLabel getJavaFXLabelDescription() {
        if (javafxLabelDescription == null) {
            javafxLabelDescription = new DescriptionCFLabel();
        }
        return (javafxLabelDescription);
    }

    public void setJavaFXLabelDescription(DescriptionCFLabel value) {
        javafxLabelDescription = value;
    }

    public DescriptionEditor getJavaFXEditorDescription() {
        if (javafxEditorDescription == null) {
            javafxEditorDescription = new DescriptionEditor();
        }
        return (javafxEditorDescription);
    }

    public void setJavaFXEditorDescription(DescriptionEditor value) {
        javafxEditorDescription = value;
    }

    public PageDataCFLabel getJavaFXLabelPageData() {
        if (javafxLabelPageData == null) {
            javafxLabelPageData = new PageDataCFLabel();
        }
        return (javafxLabelPageData);
    }

    public void setJavaFXLabelPageData(PageDataCFLabel value) {
        javafxLabelPageData = value;
    }

    public PageDataEditor getJavaFXEditorPageData() {
        if (javafxEditorPageData == null) {
            javafxEditorPageData = new PageDataEditor();
        }
        return (javafxEditorPageData);
    }

    public void setJavaFXEditorPageData(PageDataEditor value) {
        javafxEditorPageData = value;
    }

    public TableClassCodeCFLabel getJavaFXLabelTableClassCode() {
        if (javafxLabelTableClassCode == null) {
            javafxLabelTableClassCode = new TableClassCodeCFLabel();
        }
        return (javafxLabelTableClassCode);
    }

    public void setJavaFXLabelTableClassCode(TableClassCodeCFLabel value) {
        javafxLabelTableClassCode = value;
    }

    public TableClassCodeEditor getJavaFXEditorTableClassCode() {
        if (javafxEditorTableClassCode == null) {
            javafxEditorTableClassCode = new TableClassCodeEditor();
        }
        return (javafxEditorTableClassCode);
    }

    public void setJavaFXEditorTableClassCode(TableClassCodeEditor value) {
        javafxEditorTableClassCode = value;
    }

    public PolyBaseCFLabel getJavaFXLabelPolyBase() {
        if (javafxLabelPolyBase == null) {
            javafxLabelPolyBase = new PolyBaseCFLabel();
        }
        return (javafxLabelPolyBase);
    }

    public void setJavaFXLabelPolyBase(PolyBaseCFLabel value) {
        javafxLabelPolyBase = value;
    }

    public PolyBaseEditor getJavaFXEditorPolyBase() {
        if (javafxEditorPolyBase == null) {
            javafxEditorPolyBase = new PolyBaseEditor();
        }
        return (javafxEditorPolyBase);
    }

    public void setJavaFXEditorPolyBase(PolyBaseEditor value) {
        javafxEditorPolyBase = value;
    }

    public IsInstantiableCFLabel getJavaFXLabelIsInstantiable() {
        if (javafxLabelIsInstantiable == null) {
            javafxLabelIsInstantiable = new IsInstantiableCFLabel();
        }
        return (javafxLabelIsInstantiable);
    }

    public void setJavaFXLabelIsInstantiable(IsInstantiableCFLabel value) {
        javafxLabelIsInstantiable = value;
    }

    public IsInstantiableEditor getJavaFXEditorIsInstantiable() {
        if (javafxEditorIsInstantiable == null) {
            javafxEditorIsInstantiable = new IsInstantiableEditor();
        }
        return (javafxEditorIsInstantiable);
    }

    public void setJavaFXEditorIsInstantiable(IsInstantiableEditor value) {
        javafxEditorIsInstantiable = value;
    }

    public HasHistoryCFLabel getJavaFXLabelHasHistory() {
        if (javafxLabelHasHistory == null) {
            javafxLabelHasHistory = new HasHistoryCFLabel();
        }
        return (javafxLabelHasHistory);
    }

    public void setJavaFXLabelHasHistory(HasHistoryCFLabel value) {
        javafxLabelHasHistory = value;
    }

    public HasHistoryEditor getJavaFXEditorHasHistory() {
        if (javafxEditorHasHistory == null) {
            javafxEditorHasHistory = new HasHistoryEditor();
        }
        return (javafxEditorHasHistory);
    }

    public void setJavaFXEditorHasHistory(HasHistoryEditor value) {
        javafxEditorHasHistory = value;
    }

    public HasAuditColumnsCFLabel getJavaFXLabelHasAuditColumns() {
        if (javafxLabelHasAuditColumns == null) {
            javafxLabelHasAuditColumns = new HasAuditColumnsCFLabel();
        }
        return (javafxLabelHasAuditColumns);
    }

    public void setJavaFXLabelHasAuditColumns(HasAuditColumnsCFLabel value) {
        javafxLabelHasAuditColumns = value;
    }

    public HasAuditColumnsEditor getJavaFXEditorHasAuditColumns() {
        if (javafxEditorHasAuditColumns == null) {
            javafxEditorHasAuditColumns = new HasAuditColumnsEditor();
        }
        return (javafxEditorHasAuditColumns);
    }

    public void setJavaFXEditorHasAuditColumns(HasAuditColumnsEditor value) {
        javafxEditorHasAuditColumns = value;
    }

    public LoaderBehaviourCFLabel getJavaFXLabelLoaderBehaviour() {
        if (javafxLabelLoaderBehaviour == null) {
            javafxLabelLoaderBehaviour = new LoaderBehaviourCFLabel();
        }
        return (javafxLabelLoaderBehaviour);
    }

    public void setJavaFXLabelLoaderBehaviour(LoaderBehaviourCFLabel value) {
        javafxLabelLoaderBehaviour = value;
    }

    public LoaderBehaviourEditor getJavaFXEditorLoaderBehaviour() {
        if (javafxEditorLoaderBehaviour == null) {
            javafxEditorLoaderBehaviour = new LoaderBehaviourEditor();
        }
        return (javafxEditorLoaderBehaviour);
    }

    public void setJavaFXEditorLoaderBehaviour(LoaderBehaviourEditor value) {
        javafxEditorLoaderBehaviour = value;
    }

    public SecurityScopeCFLabel getJavaFXLabelSecurityScope() {
        if (javafxLabelSecurityScope == null) {
            javafxLabelSecurityScope = new SecurityScopeCFLabel();
        }
        return (javafxLabelSecurityScope);
    }

    public void setJavaFXLabelSecurityScope(SecurityScopeCFLabel value) {
        javafxLabelSecurityScope = value;
    }

    public SecurityScopeEditor getJavaFXEditorSecurityScope() {
        if (javafxEditorSecurityScope == null) {
            javafxEditorSecurityScope = new SecurityScopeEditor();
        }
        return (javafxEditorSecurityScope);
    }

    public void setJavaFXEditorSecurityScope(SecurityScopeEditor value) {
        javafxEditorSecurityScope = value;
    }

    public JObjMembersCFLabel getJavaFXLabelJObjMembers() {
        if (javafxLabelJObjMembers == null) {
            javafxLabelJObjMembers = new JObjMembersCFLabel();
        }
        return (javafxLabelJObjMembers);
    }

    public void setJavaFXLabelJObjMembers(JObjMembersCFLabel value) {
        javafxLabelJObjMembers = value;
    }

    public JObjMembersEditor getJavaFXEditorJObjMembers() {
        if (javafxEditorJObjMembers == null) {
            javafxEditorJObjMembers = new JObjMembersEditor();
        }
        return (javafxEditorJObjMembers);
    }

    public void setJavaFXEditorJObjMembers(JObjMembersEditor value) {
        javafxEditorJObjMembers = value;
    }

    public JObjInterfaceCFLabel getJavaFXLabelJObjInterface() {
        if (javafxLabelJObjInterface == null) {
            javafxLabelJObjInterface = new JObjInterfaceCFLabel();
        }
        return (javafxLabelJObjInterface);
    }

    public void setJavaFXLabelJObjInterface(JObjInterfaceCFLabel value) {
        javafxLabelJObjInterface = value;
    }

    public JObjInterfaceEditor getJavaFXEditorJObjInterface() {
        if (javafxEditorJObjInterface == null) {
            javafxEditorJObjInterface = new JObjInterfaceEditor();
        }
        return (javafxEditorJObjInterface);
    }

    public void setJavaFXEditorJObjInterface(JObjInterfaceEditor value) {
        javafxEditorJObjInterface = value;
    }

    public JObjImportCFLabel getJavaFXLabelJObjImport() {
        if (javafxLabelJObjImport == null) {
            javafxLabelJObjImport = new JObjImportCFLabel();
        }
        return (javafxLabelJObjImport);
    }

    public void setJavaFXLabelJObjImport(JObjImportCFLabel value) {
        javafxLabelJObjImport = value;
    }

    public JObjImportEditor getJavaFXEditorJObjImport() {
        if (javafxEditorJObjImport == null) {
            javafxEditorJObjImport = new JObjImportEditor();
        }
        return (javafxEditorJObjImport);
    }

    public void setJavaFXEditorJObjImport(JObjImportEditor value) {
        javafxEditorJObjImport = value;
    }

    public JObjImplementationCFLabel getJavaFXLabelJObjImplementation() {
        if (javafxLabelJObjImplementation == null) {
            javafxLabelJObjImplementation = new JObjImplementationCFLabel();
        }
        return (javafxLabelJObjImplementation);
    }

    public void setJavaFXLabelJObjImplementation(JObjImplementationCFLabel value) {
        javafxLabelJObjImplementation = value;
    }

    public JObjImplementationEditor getJavaFXEditorJObjImplementation() {
        if (javafxEditorJObjImplementation == null) {
            javafxEditorJObjImplementation = new JObjImplementationEditor();
        }
        return (javafxEditorJObjImplementation);
    }

    public void setJavaFXEditorJObjImplementation(JObjImplementationEditor value) {
        javafxEditorJObjImplementation = value;
    }

    public JEditObjMembersCFLabel getJavaFXLabelJEditObjMembers() {
        if (javafxLabelJEditObjMembers == null) {
            javafxLabelJEditObjMembers = new JEditObjMembersCFLabel();
        }
        return (javafxLabelJEditObjMembers);
    }

    public void setJavaFXLabelJEditObjMembers(JEditObjMembersCFLabel value) {
        javafxLabelJEditObjMembers = value;
    }

    public JEditObjMembersEditor getJavaFXEditorJEditObjMembers() {
        if (javafxEditorJEditObjMembers == null) {
            javafxEditorJEditObjMembers = new JEditObjMembersEditor();
        }
        return (javafxEditorJEditObjMembers);
    }

    public void setJavaFXEditorJEditObjMembers(JEditObjMembersEditor value) {
        javafxEditorJEditObjMembers = value;
    }

    public JEditObjInterfaceCFLabel getJavaFXLabelJEditObjInterface() {
        if (javafxLabelJEditObjInterface == null) {
            javafxLabelJEditObjInterface = new JEditObjInterfaceCFLabel();
        }
        return (javafxLabelJEditObjInterface);
    }

    public void setJavaFXLabelJEditObjInterface(JEditObjInterfaceCFLabel value) {
        javafxLabelJEditObjInterface = value;
    }

    public JEditObjInterfaceEditor getJavaFXEditorJEditObjInterface() {
        if (javafxEditorJEditObjInterface == null) {
            javafxEditorJEditObjInterface = new JEditObjInterfaceEditor();
        }
        return (javafxEditorJEditObjInterface);
    }

    public void setJavaFXEditorJEditObjInterface(JEditObjInterfaceEditor value) {
        javafxEditorJEditObjInterface = value;
    }

    public JEditObjImportCFLabel getJavaFXLabelJEditObjImport() {
        if (javafxLabelJEditObjImport == null) {
            javafxLabelJEditObjImport = new JEditObjImportCFLabel();
        }
        return (javafxLabelJEditObjImport);
    }

    public void setJavaFXLabelJEditObjImport(JEditObjImportCFLabel value) {
        javafxLabelJEditObjImport = value;
    }

    public JEditObjImportEditor getJavaFXEditorJEditObjImport() {
        if (javafxEditorJEditObjImport == null) {
            javafxEditorJEditObjImport = new JEditObjImportEditor();
        }
        return (javafxEditorJEditObjImport);
    }

    public void setJavaFXEditorJEditObjImport(JEditObjImportEditor value) {
        javafxEditorJEditObjImport = value;
    }

    public JEditObjImplementationCFLabel getJavaFXLabelJEditObjImplementation() {
        if (javafxLabelJEditObjImplementation == null) {
            javafxLabelJEditObjImplementation = new JEditObjImplementationCFLabel();
        }
        return (javafxLabelJEditObjImplementation);
    }

    public void setJavaFXLabelJEditObjImplementation(JEditObjImplementationCFLabel value) {
        javafxLabelJEditObjImplementation = value;
    }

    public JEditObjImplementationEditor getJavaFXEditorJEditObjImplementation() {
        if (javafxEditorJEditObjImplementation == null) {
            javafxEditorJEditObjImplementation = new JEditObjImplementationEditor();
        }
        return (javafxEditorJEditObjImplementation);
    }

    public void setJavaFXEditorJEditObjImplementation(JEditObjImplementationEditor value) {
        javafxEditorJEditObjImplementation = value;
    }

    public JTableImportCFLabel getJavaFXLabelJTableImport() {
        if (javafxLabelJTableImport == null) {
            javafxLabelJTableImport = new JTableImportCFLabel();
        }
        return (javafxLabelJTableImport);
    }

    public void setJavaFXLabelJTableImport(JTableImportCFLabel value) {
        javafxLabelJTableImport = value;
    }

    public JTableImportEditor getJavaFXEditorJTableImport() {
        if (javafxEditorJTableImport == null) {
            javafxEditorJTableImport = new JTableImportEditor();
        }
        return (javafxEditorJTableImport);
    }

    public void setJavaFXEditorJTableImport(JTableImportEditor value) {
        javafxEditorJTableImport = value;
    }

    public JTableMembersCFLabel getJavaFXLabelJTableMembers() {
        if (javafxLabelJTableMembers == null) {
            javafxLabelJTableMembers = new JTableMembersCFLabel();
        }
        return (javafxLabelJTableMembers);
    }

    public void setJavaFXLabelJTableMembers(JTableMembersCFLabel value) {
        javafxLabelJTableMembers = value;
    }

    public JTableMembersEditor getJavaFXEditorJTableMembers() {
        if (javafxEditorJTableMembers == null) {
            javafxEditorJTableMembers = new JTableMembersEditor();
        }
        return (javafxEditorJTableMembers);
    }

    public void setJavaFXEditorJTableMembers(JTableMembersEditor value) {
        javafxEditorJTableMembers = value;
    }

    public JTableInterfaceCFLabel getJavaFXLabelJTableInterface() {
        if (javafxLabelJTableInterface == null) {
            javafxLabelJTableInterface = new JTableInterfaceCFLabel();
        }
        return (javafxLabelJTableInterface);
    }

    public void setJavaFXLabelJTableInterface(JTableInterfaceCFLabel value) {
        javafxLabelJTableInterface = value;
    }

    public JTableInterfaceEditor getJavaFXEditorJTableInterface() {
        if (javafxEditorJTableInterface == null) {
            javafxEditorJTableInterface = new JTableInterfaceEditor();
        }
        return (javafxEditorJTableInterface);
    }

    public void setJavaFXEditorJTableInterface(JTableInterfaceEditor value) {
        javafxEditorJTableInterface = value;
    }

    public JTableImplementationCFLabel getJavaFXLabelJTableImplementation() {
        if (javafxLabelJTableImplementation == null) {
            javafxLabelJTableImplementation = new JTableImplementationCFLabel();
        }
        return (javafxLabelJTableImplementation);
    }

    public void setJavaFXLabelJTableImplementation(JTableImplementationCFLabel value) {
        javafxLabelJTableImplementation = value;
    }

    public JTableImplementationEditor getJavaFXEditorJTableImplementation() {
        if (javafxEditorJTableImplementation == null) {
            javafxEditorJTableImplementation = new JTableImplementationEditor();
        }
        return (javafxEditorJTableImplementation);
    }

    public void setJavaFXEditorJTableImplementation(JTableImplementationEditor value) {
        javafxEditorJTableImplementation = value;
    }

    public JTableObjImportCFLabel getJavaFXLabelJTableObjImport() {
        if (javafxLabelJTableObjImport == null) {
            javafxLabelJTableObjImport = new JTableObjImportCFLabel();
        }
        return (javafxLabelJTableObjImport);
    }

    public void setJavaFXLabelJTableObjImport(JTableObjImportCFLabel value) {
        javafxLabelJTableObjImport = value;
    }

    public JTableObjImportEditor getJavaFXEditorJTableObjImport() {
        if (javafxEditorJTableObjImport == null) {
            javafxEditorJTableObjImport = new JTableObjImportEditor();
        }
        return (javafxEditorJTableObjImport);
    }

    public void setJavaFXEditorJTableObjImport(JTableObjImportEditor value) {
        javafxEditorJTableObjImport = value;
    }

    public JTableObjMembersCFLabel getJavaFXLabelJTableObjMembers() {
        if (javafxLabelJTableObjMembers == null) {
            javafxLabelJTableObjMembers = new JTableObjMembersCFLabel();
        }
        return (javafxLabelJTableObjMembers);
    }

    public void setJavaFXLabelJTableObjMembers(JTableObjMembersCFLabel value) {
        javafxLabelJTableObjMembers = value;
    }

    public JTableObjMembersEditor getJavaFXEditorJTableObjMembers() {
        if (javafxEditorJTableObjMembers == null) {
            javafxEditorJTableObjMembers = new JTableObjMembersEditor();
        }
        return (javafxEditorJTableObjMembers);
    }

    public void setJavaFXEditorJTableObjMembers(JTableObjMembersEditor value) {
        javafxEditorJTableObjMembers = value;
    }

    public JTableObjInterfaceCFLabel getJavaFXLabelJTableObjInterface() {
        if (javafxLabelJTableObjInterface == null) {
            javafxLabelJTableObjInterface = new JTableObjInterfaceCFLabel();
        }
        return (javafxLabelJTableObjInterface);
    }

    public void setJavaFXLabelJTableObjInterface(JTableObjInterfaceCFLabel value) {
        javafxLabelJTableObjInterface = value;
    }

    public JTableObjInterfaceEditor getJavaFXEditorJTableObjInterface() {
        if (javafxEditorJTableObjInterface == null) {
            javafxEditorJTableObjInterface = new JTableObjInterfaceEditor();
        }
        return (javafxEditorJTableObjInterface);
    }

    public void setJavaFXEditorJTableObjInterface(JTableObjInterfaceEditor value) {
        javafxEditorJTableObjInterface = value;
    }

    public JTableObjImplementationCFLabel getJavaFXLabelJTableObjImplementation() {
        if (javafxLabelJTableObjImplementation == null) {
            javafxLabelJTableObjImplementation = new JTableObjImplementationCFLabel();
        }
        return (javafxLabelJTableObjImplementation);
    }

    public void setJavaFXLabelJTableObjImplementation(JTableObjImplementationCFLabel value) {
        javafxLabelJTableObjImplementation = value;
    }

    public JTableObjImplementationEditor getJavaFXEditorJTableObjImplementation() {
        if (javafxEditorJTableObjImplementation == null) {
            javafxEditorJTableObjImplementation = new JTableObjImplementationEditor();
        }
        return (javafxEditorJTableObjImplementation);
    }

    public void setJavaFXEditorJTableObjImplementation(JTableObjImplementationEditor value) {
        javafxEditorJTableObjImplementation = value;
    }

    public JDb2LUWTableImportCFLabel getJavaFXLabelJDb2LUWTableImport() {
        if (javafxLabelJDb2LUWTableImport == null) {
            javafxLabelJDb2LUWTableImport = new JDb2LUWTableImportCFLabel();
        }
        return (javafxLabelJDb2LUWTableImport);
    }

    public void setJavaFXLabelJDb2LUWTableImport(JDb2LUWTableImportCFLabel value) {
        javafxLabelJDb2LUWTableImport = value;
    }

    public JDb2LUWTableImportEditor getJavaFXEditorJDb2LUWTableImport() {
        if (javafxEditorJDb2LUWTableImport == null) {
            javafxEditorJDb2LUWTableImport = new JDb2LUWTableImportEditor();
        }
        return (javafxEditorJDb2LUWTableImport);
    }

    public void setJavaFXEditorJDb2LUWTableImport(JDb2LUWTableImportEditor value) {
        javafxEditorJDb2LUWTableImport = value;
    }

    public JDb2LUWTableMembersCFLabel getJavaFXLabelJDb2LUWTableMembers() {
        if (javafxLabelJDb2LUWTableMembers == null) {
            javafxLabelJDb2LUWTableMembers = new JDb2LUWTableMembersCFLabel();
        }
        return (javafxLabelJDb2LUWTableMembers);
    }

    public void setJavaFXLabelJDb2LUWTableMembers(JDb2LUWTableMembersCFLabel value) {
        javafxLabelJDb2LUWTableMembers = value;
    }

    public JDb2LUWTableMembersEditor getJavaFXEditorJDb2LUWTableMembers() {
        if (javafxEditorJDb2LUWTableMembers == null) {
            javafxEditorJDb2LUWTableMembers = new JDb2LUWTableMembersEditor();
        }
        return (javafxEditorJDb2LUWTableMembers);
    }

    public void setJavaFXEditorJDb2LUWTableMembers(JDb2LUWTableMembersEditor value) {
        javafxEditorJDb2LUWTableMembers = value;
    }

    public JDb2LUWTableImplementationCFLabel getJavaFXLabelJDb2LUWTableImplementation() {
        if (javafxLabelJDb2LUWTableImplementation == null) {
            javafxLabelJDb2LUWTableImplementation = new JDb2LUWTableImplementationCFLabel();
        }
        return (javafxLabelJDb2LUWTableImplementation);
    }

    public void setJavaFXLabelJDb2LUWTableImplementation(JDb2LUWTableImplementationCFLabel value) {
        javafxLabelJDb2LUWTableImplementation = value;
    }

    public JDb2LUWTableImplementationEditor getJavaFXEditorJDb2LUWTableImplementation() {
        if (javafxEditorJDb2LUWTableImplementation == null) {
            javafxEditorJDb2LUWTableImplementation = new JDb2LUWTableImplementationEditor();
        }
        return (javafxEditorJDb2LUWTableImplementation);
    }

    public void setJavaFXEditorJDb2LUWTableImplementation(JDb2LUWTableImplementationEditor value) {
        javafxEditorJDb2LUWTableImplementation = value;
    }

    public JMSSqlTableImportCFLabel getJavaFXLabelJMSSqlTableImport() {
        if (javafxLabelJMSSqlTableImport == null) {
            javafxLabelJMSSqlTableImport = new JMSSqlTableImportCFLabel();
        }
        return (javafxLabelJMSSqlTableImport);
    }

    public void setJavaFXLabelJMSSqlTableImport(JMSSqlTableImportCFLabel value) {
        javafxLabelJMSSqlTableImport = value;
    }

    public JMSSqlTableImportEditor getJavaFXEditorJMSSqlTableImport() {
        if (javafxEditorJMSSqlTableImport == null) {
            javafxEditorJMSSqlTableImport = new JMSSqlTableImportEditor();
        }
        return (javafxEditorJMSSqlTableImport);
    }

    public void setJavaFXEditorJMSSqlTableImport(JMSSqlTableImportEditor value) {
        javafxEditorJMSSqlTableImport = value;
    }

    public JMSSqlTableMembersCFLabel getJavaFXLabelJMSSqlTableMembers() {
        if (javafxLabelJMSSqlTableMembers == null) {
            javafxLabelJMSSqlTableMembers = new JMSSqlTableMembersCFLabel();
        }
        return (javafxLabelJMSSqlTableMembers);
    }

    public void setJavaFXLabelJMSSqlTableMembers(JMSSqlTableMembersCFLabel value) {
        javafxLabelJMSSqlTableMembers = value;
    }

    public JMSSqlTableMembersEditor getJavaFXEditorJMSSqlTableMembers() {
        if (javafxEditorJMSSqlTableMembers == null) {
            javafxEditorJMSSqlTableMembers = new JMSSqlTableMembersEditor();
        }
        return (javafxEditorJMSSqlTableMembers);
    }

    public void setJavaFXEditorJMSSqlTableMembers(JMSSqlTableMembersEditor value) {
        javafxEditorJMSSqlTableMembers = value;
    }

    public JMSSqlTableImplementationCFLabel getJavaFXLabelJMSSqlTableImplementation() {
        if (javafxLabelJMSSqlTableImplementation == null) {
            javafxLabelJMSSqlTableImplementation = new JMSSqlTableImplementationCFLabel();
        }
        return (javafxLabelJMSSqlTableImplementation);
    }

    public void setJavaFXLabelJMSSqlTableImplementation(JMSSqlTableImplementationCFLabel value) {
        javafxLabelJMSSqlTableImplementation = value;
    }

    public JMSSqlTableImplementationEditor getJavaFXEditorJMSSqlTableImplementation() {
        if (javafxEditorJMSSqlTableImplementation == null) {
            javafxEditorJMSSqlTableImplementation = new JMSSqlTableImplementationEditor();
        }
        return (javafxEditorJMSSqlTableImplementation);
    }

    public void setJavaFXEditorJMSSqlTableImplementation(JMSSqlTableImplementationEditor value) {
        javafxEditorJMSSqlTableImplementation = value;
    }

    public JMySqlTableImportCFLabel getJavaFXLabelJMySqlTableImport() {
        if (javafxLabelJMySqlTableImport == null) {
            javafxLabelJMySqlTableImport = new JMySqlTableImportCFLabel();
        }
        return (javafxLabelJMySqlTableImport);
    }

    public void setJavaFXLabelJMySqlTableImport(JMySqlTableImportCFLabel value) {
        javafxLabelJMySqlTableImport = value;
    }

    public JMySqlTableImportEditor getJavaFXEditorJMySqlTableImport() {
        if (javafxEditorJMySqlTableImport == null) {
            javafxEditorJMySqlTableImport = new JMySqlTableImportEditor();
        }
        return (javafxEditorJMySqlTableImport);
    }

    public void setJavaFXEditorJMySqlTableImport(JMySqlTableImportEditor value) {
        javafxEditorJMySqlTableImport = value;
    }

    public JMySqlTableMembersCFLabel getJavaFXLabelJMySqlTableMembers() {
        if (javafxLabelJMySqlTableMembers == null) {
            javafxLabelJMySqlTableMembers = new JMySqlTableMembersCFLabel();
        }
        return (javafxLabelJMySqlTableMembers);
    }

    public void setJavaFXLabelJMySqlTableMembers(JMySqlTableMembersCFLabel value) {
        javafxLabelJMySqlTableMembers = value;
    }

    public JMySqlTableMembersEditor getJavaFXEditorJMySqlTableMembers() {
        if (javafxEditorJMySqlTableMembers == null) {
            javafxEditorJMySqlTableMembers = new JMySqlTableMembersEditor();
        }
        return (javafxEditorJMySqlTableMembers);
    }

    public void setJavaFXEditorJMySqlTableMembers(JMySqlTableMembersEditor value) {
        javafxEditorJMySqlTableMembers = value;
    }

    public JMySqlTableImplementationCFLabel getJavaFXLabelJMySqlTableImplementation() {
        if (javafxLabelJMySqlTableImplementation == null) {
            javafxLabelJMySqlTableImplementation = new JMySqlTableImplementationCFLabel();
        }
        return (javafxLabelJMySqlTableImplementation);
    }

    public void setJavaFXLabelJMySqlTableImplementation(JMySqlTableImplementationCFLabel value) {
        javafxLabelJMySqlTableImplementation = value;
    }

    public JMySqlTableImplementationEditor getJavaFXEditorJMySqlTableImplementation() {
        if (javafxEditorJMySqlTableImplementation == null) {
            javafxEditorJMySqlTableImplementation = new JMySqlTableImplementationEditor();
        }
        return (javafxEditorJMySqlTableImplementation);
    }

    public void setJavaFXEditorJMySqlTableImplementation(JMySqlTableImplementationEditor value) {
        javafxEditorJMySqlTableImplementation = value;
    }

    public JOracleTableImportCFLabel getJavaFXLabelJOracleTableImport() {
        if (javafxLabelJOracleTableImport == null) {
            javafxLabelJOracleTableImport = new JOracleTableImportCFLabel();
        }
        return (javafxLabelJOracleTableImport);
    }

    public void setJavaFXLabelJOracleTableImport(JOracleTableImportCFLabel value) {
        javafxLabelJOracleTableImport = value;
    }

    public JOracleTableImportEditor getJavaFXEditorJOracleTableImport() {
        if (javafxEditorJOracleTableImport == null) {
            javafxEditorJOracleTableImport = new JOracleTableImportEditor();
        }
        return (javafxEditorJOracleTableImport);
    }

    public void setJavaFXEditorJOracleTableImport(JOracleTableImportEditor value) {
        javafxEditorJOracleTableImport = value;
    }

    public JOracleTableMembersCFLabel getJavaFXLabelJOracleTableMembers() {
        if (javafxLabelJOracleTableMembers == null) {
            javafxLabelJOracleTableMembers = new JOracleTableMembersCFLabel();
        }
        return (javafxLabelJOracleTableMembers);
    }

    public void setJavaFXLabelJOracleTableMembers(JOracleTableMembersCFLabel value) {
        javafxLabelJOracleTableMembers = value;
    }

    public JOracleTableMembersEditor getJavaFXEditorJOracleTableMembers() {
        if (javafxEditorJOracleTableMembers == null) {
            javafxEditorJOracleTableMembers = new JOracleTableMembersEditor();
        }
        return (javafxEditorJOracleTableMembers);
    }

    public void setJavaFXEditorJOracleTableMembers(JOracleTableMembersEditor value) {
        javafxEditorJOracleTableMembers = value;
    }

    public JOracleTableImplementationCFLabel getJavaFXLabelJOracleTableImplementation() {
        if (javafxLabelJOracleTableImplementation == null) {
            javafxLabelJOracleTableImplementation = new JOracleTableImplementationCFLabel();
        }
        return (javafxLabelJOracleTableImplementation);
    }

    public void setJavaFXLabelJOracleTableImplementation(JOracleTableImplementationCFLabel value) {
        javafxLabelJOracleTableImplementation = value;
    }

    public JOracleTableImplementationEditor getJavaFXEditorJOracleTableImplementation() {
        if (javafxEditorJOracleTableImplementation == null) {
            javafxEditorJOracleTableImplementation = new JOracleTableImplementationEditor();
        }
        return (javafxEditorJOracleTableImplementation);
    }

    public void setJavaFXEditorJOracleTableImplementation(JOracleTableImplementationEditor value) {
        javafxEditorJOracleTableImplementation = value;
    }

    public JPgSqlTableImportCFLabel getJavaFXLabelJPgSqlTableImport() {
        if (javafxLabelJPgSqlTableImport == null) {
            javafxLabelJPgSqlTableImport = new JPgSqlTableImportCFLabel();
        }
        return (javafxLabelJPgSqlTableImport);
    }

    public void setJavaFXLabelJPgSqlTableImport(JPgSqlTableImportCFLabel value) {
        javafxLabelJPgSqlTableImport = value;
    }

    public JPgSqlTableImportEditor getJavaFXEditorJPgSqlTableImport() {
        if (javafxEditorJPgSqlTableImport == null) {
            javafxEditorJPgSqlTableImport = new JPgSqlTableImportEditor();
        }
        return (javafxEditorJPgSqlTableImport);
    }

    public void setJavaFXEditorJPgSqlTableImport(JPgSqlTableImportEditor value) {
        javafxEditorJPgSqlTableImport = value;
    }

    public JPgSqlTableMembersCFLabel getJavaFXLabelJPgSqlTableMembers() {
        if (javafxLabelJPgSqlTableMembers == null) {
            javafxLabelJPgSqlTableMembers = new JPgSqlTableMembersCFLabel();
        }
        return (javafxLabelJPgSqlTableMembers);
    }

    public void setJavaFXLabelJPgSqlTableMembers(JPgSqlTableMembersCFLabel value) {
        javafxLabelJPgSqlTableMembers = value;
    }

    public JPgSqlTableMembersEditor getJavaFXEditorJPgSqlTableMembers() {
        if (javafxEditorJPgSqlTableMembers == null) {
            javafxEditorJPgSqlTableMembers = new JPgSqlTableMembersEditor();
        }
        return (javafxEditorJPgSqlTableMembers);
    }

    public void setJavaFXEditorJPgSqlTableMembers(JPgSqlTableMembersEditor value) {
        javafxEditorJPgSqlTableMembers = value;
    }

    public JPgSqlTableImplementationCFLabel getJavaFXLabelJPgSqlTableImplementation() {
        if (javafxLabelJPgSqlTableImplementation == null) {
            javafxLabelJPgSqlTableImplementation = new JPgSqlTableImplementationCFLabel();
        }
        return (javafxLabelJPgSqlTableImplementation);
    }

    public void setJavaFXLabelJPgSqlTableImplementation(JPgSqlTableImplementationCFLabel value) {
        javafxLabelJPgSqlTableImplementation = value;
    }

    public JPgSqlTableImplementationEditor getJavaFXEditorJPgSqlTableImplementation() {
        if (javafxEditorJPgSqlTableImplementation == null) {
            javafxEditorJPgSqlTableImplementation = new JPgSqlTableImplementationEditor();
        }
        return (javafxEditorJPgSqlTableImplementation);
    }

    public void setJavaFXEditorJPgSqlTableImplementation(JPgSqlTableImplementationEditor value) {
        javafxEditorJPgSqlTableImplementation = value;
    }

    public JSybaseTableImportCFLabel getJavaFXLabelJSybaseTableImport() {
        if (javafxLabelJSybaseTableImport == null) {
            javafxLabelJSybaseTableImport = new JSybaseTableImportCFLabel();
        }
        return (javafxLabelJSybaseTableImport);
    }

    public void setJavaFXLabelJSybaseTableImport(JSybaseTableImportCFLabel value) {
        javafxLabelJSybaseTableImport = value;
    }

    public JSybaseTableImportEditor getJavaFXEditorJSybaseTableImport() {
        if (javafxEditorJSybaseTableImport == null) {
            javafxEditorJSybaseTableImport = new JSybaseTableImportEditor();
        }
        return (javafxEditorJSybaseTableImport);
    }

    public void setJavaFXEditorJSybaseTableImport(JSybaseTableImportEditor value) {
        javafxEditorJSybaseTableImport = value;
    }

    public JSybaseTableMembersCFLabel getJavaFXLabelJSybaseTableMembers() {
        if (javafxLabelJSybaseTableMembers == null) {
            javafxLabelJSybaseTableMembers = new JSybaseTableMembersCFLabel();
        }
        return (javafxLabelJSybaseTableMembers);
    }

    public void setJavaFXLabelJSybaseTableMembers(JSybaseTableMembersCFLabel value) {
        javafxLabelJSybaseTableMembers = value;
    }

    public JSybaseTableMembersEditor getJavaFXEditorJSybaseTableMembers() {
        if (javafxEditorJSybaseTableMembers == null) {
            javafxEditorJSybaseTableMembers = new JSybaseTableMembersEditor();
        }
        return (javafxEditorJSybaseTableMembers);
    }

    public void setJavaFXEditorJSybaseTableMembers(JSybaseTableMembersEditor value) {
        javafxEditorJSybaseTableMembers = value;
    }

    public JSybaseTableImplementationCFLabel getJavaFXLabelJSybaseTableImplementation() {
        if (javafxLabelJSybaseTableImplementation == null) {
            javafxLabelJSybaseTableImplementation = new JSybaseTableImplementationCFLabel();
        }
        return (javafxLabelJSybaseTableImplementation);
    }

    public void setJavaFXLabelJSybaseTableImplementation(JSybaseTableImplementationCFLabel value) {
        javafxLabelJSybaseTableImplementation = value;
    }

    public JSybaseTableImplementationEditor getJavaFXEditorJSybaseTableImplementation() {
        if (javafxEditorJSybaseTableImplementation == null) {
            javafxEditorJSybaseTableImplementation = new JSybaseTableImplementationEditor();
        }
        return (javafxEditorJSybaseTableImplementation);
    }

    public void setJavaFXEditorJSybaseTableImplementation(JSybaseTableImplementationEditor value) {
        javafxEditorJSybaseTableImplementation = value;
    }

    public JRamTableImportCFLabel getJavaFXLabelJRamTableImport() {
        if (javafxLabelJRamTableImport == null) {
            javafxLabelJRamTableImport = new JRamTableImportCFLabel();
        }
        return (javafxLabelJRamTableImport);
    }

    public void setJavaFXLabelJRamTableImport(JRamTableImportCFLabel value) {
        javafxLabelJRamTableImport = value;
    }

    public JRamTableImportEditor getJavaFXEditorJRamTableImport() {
        if (javafxEditorJRamTableImport == null) {
            javafxEditorJRamTableImport = new JRamTableImportEditor();
        }
        return (javafxEditorJRamTableImport);
    }

    public void setJavaFXEditorJRamTableImport(JRamTableImportEditor value) {
        javafxEditorJRamTableImport = value;
    }

    public JRamTableMembersCFLabel getJavaFXLabelJRamTableMembers() {
        if (javafxLabelJRamTableMembers == null) {
            javafxLabelJRamTableMembers = new JRamTableMembersCFLabel();
        }
        return (javafxLabelJRamTableMembers);
    }

    public void setJavaFXLabelJRamTableMembers(JRamTableMembersCFLabel value) {
        javafxLabelJRamTableMembers = value;
    }

    public JRamTableMembersEditor getJavaFXEditorJRamTableMembers() {
        if (javafxEditorJRamTableMembers == null) {
            javafxEditorJRamTableMembers = new JRamTableMembersEditor();
        }
        return (javafxEditorJRamTableMembers);
    }

    public void setJavaFXEditorJRamTableMembers(JRamTableMembersEditor value) {
        javafxEditorJRamTableMembers = value;
    }

    public JRamTableImplementationCFLabel getJavaFXLabelJRamTableImplementation() {
        if (javafxLabelJRamTableImplementation == null) {
            javafxLabelJRamTableImplementation = new JRamTableImplementationCFLabel();
        }
        return (javafxLabelJRamTableImplementation);
    }

    public void setJavaFXLabelJRamTableImplementation(JRamTableImplementationCFLabel value) {
        javafxLabelJRamTableImplementation = value;
    }

    public JRamTableImplementationEditor getJavaFXEditorJRamTableImplementation() {
        if (javafxEditorJRamTableImplementation == null) {
            javafxEditorJRamTableImplementation = new JRamTableImplementationEditor();
        }
        return (javafxEditorJRamTableImplementation);
    }

    public void setJavaFXEditorJRamTableImplementation(JRamTableImplementationEditor value) {
        javafxEditorJRamTableImplementation = value;
    }

    public JSaxLoaderImportCFLabel getJavaFXLabelJSaxLoaderImport() {
        if (javafxLabelJSaxLoaderImport == null) {
            javafxLabelJSaxLoaderImport = new JSaxLoaderImportCFLabel();
        }
        return (javafxLabelJSaxLoaderImport);
    }

    public void setJavaFXLabelJSaxLoaderImport(JSaxLoaderImportCFLabel value) {
        javafxLabelJSaxLoaderImport = value;
    }

    public JSaxLoaderImportEditor getJavaFXEditorJSaxLoaderImport() {
        if (javafxEditorJSaxLoaderImport == null) {
            javafxEditorJSaxLoaderImport = new JSaxLoaderImportEditor();
        }
        return (javafxEditorJSaxLoaderImport);
    }

    public void setJavaFXEditorJSaxLoaderImport(JSaxLoaderImportEditor value) {
        javafxEditorJSaxLoaderImport = value;
    }

    public JSaxLoaderStartElementCFLabel getJavaFXLabelJSaxLoaderStartElement() {
        if (javafxLabelJSaxLoaderStartElement == null) {
            javafxLabelJSaxLoaderStartElement = new JSaxLoaderStartElementCFLabel();
        }
        return (javafxLabelJSaxLoaderStartElement);
    }

    public void setJavaFXLabelJSaxLoaderStartElement(JSaxLoaderStartElementCFLabel value) {
        javafxLabelJSaxLoaderStartElement = value;
    }

    public JSaxLoaderStartElementEditor getJavaFXEditorJSaxLoaderStartElement() {
        if (javafxEditorJSaxLoaderStartElement == null) {
            javafxEditorJSaxLoaderStartElement = new JSaxLoaderStartElementEditor();
        }
        return (javafxEditorJSaxLoaderStartElement);
    }

    public void setJavaFXEditorJSaxLoaderStartElement(JSaxLoaderStartElementEditor value) {
        javafxEditorJSaxLoaderStartElement = value;
    }

    public JSaxLoaderEndElementCFLabel getJavaFXLabelJSaxLoaderEndElement() {
        if (javafxLabelJSaxLoaderEndElement == null) {
            javafxLabelJSaxLoaderEndElement = new JSaxLoaderEndElementCFLabel();
        }
        return (javafxLabelJSaxLoaderEndElement);
    }

    public void setJavaFXLabelJSaxLoaderEndElement(JSaxLoaderEndElementCFLabel value) {
        javafxLabelJSaxLoaderEndElement = value;
    }

    public JSaxLoaderEndElementEditor getJavaFXEditorJSaxLoaderEndElement() {
        if (javafxEditorJSaxLoaderEndElement == null) {
            javafxEditorJSaxLoaderEndElement = new JSaxLoaderEndElementEditor();
        }
        return (javafxEditorJSaxLoaderEndElement);
    }

    public void setJavaFXEditorJSaxLoaderEndElement(JSaxLoaderEndElementEditor value) {
        javafxEditorJSaxLoaderEndElement = value;
    }

    public JXMsgTableImportCFLabel getJavaFXLabelJXMsgTableImport() {
        if (javafxLabelJXMsgTableImport == null) {
            javafxLabelJXMsgTableImport = new JXMsgTableImportCFLabel();
        }
        return (javafxLabelJXMsgTableImport);
    }

    public void setJavaFXLabelJXMsgTableImport(JXMsgTableImportCFLabel value) {
        javafxLabelJXMsgTableImport = value;
    }

    public JXMsgTableImportEditor getJavaFXEditorJXMsgTableImport() {
        if (javafxEditorJXMsgTableImport == null) {
            javafxEditorJXMsgTableImport = new JXMsgTableImportEditor();
        }
        return (javafxEditorJXMsgTableImport);
    }

    public void setJavaFXEditorJXMsgTableImport(JXMsgTableImportEditor value) {
        javafxEditorJXMsgTableImport = value;
    }

    public JXMsgTableFormattersCFLabel getJavaFXLabelJXMsgTableFormatters() {
        if (javafxLabelJXMsgTableFormatters == null) {
            javafxLabelJXMsgTableFormatters = new JXMsgTableFormattersCFLabel();
        }
        return (javafxLabelJXMsgTableFormatters);
    }

    public void setJavaFXLabelJXMsgTableFormatters(JXMsgTableFormattersCFLabel value) {
        javafxLabelJXMsgTableFormatters = value;
    }

    public JXMsgTableFormattersEditor getJavaFXEditorJXMsgTableFormatters() {
        if (javafxEditorJXMsgTableFormatters == null) {
            javafxEditorJXMsgTableFormatters = new JXMsgTableFormattersEditor();
        }
        return (javafxEditorJXMsgTableFormatters);
    }

    public void setJavaFXEditorJXMsgTableFormatters(JXMsgTableFormattersEditor value) {
        javafxEditorJXMsgTableFormatters = value;
    }

    public JXMsgRqstTableImportCFLabel getJavaFXLabelJXMsgRqstTableImport() {
        if (javafxLabelJXMsgRqstTableImport == null) {
            javafxLabelJXMsgRqstTableImport = new JXMsgRqstTableImportCFLabel();
        }
        return (javafxLabelJXMsgRqstTableImport);
    }

    public void setJavaFXLabelJXMsgRqstTableImport(JXMsgRqstTableImportCFLabel value) {
        javafxLabelJXMsgRqstTableImport = value;
    }

    public JXMsgRqstTableImportEditor getJavaFXEditorJXMsgRqstTableImport() {
        if (javafxEditorJXMsgRqstTableImport == null) {
            javafxEditorJXMsgRqstTableImport = new JXMsgRqstTableImportEditor();
        }
        return (javafxEditorJXMsgRqstTableImport);
    }

    public void setJavaFXEditorJXMsgRqstTableImport(JXMsgRqstTableImportEditor value) {
        javafxEditorJXMsgRqstTableImport = value;
    }

    public JXMsgRspnTableImportCFLabel getJavaFXLabelJXMsgRspnTableImport() {
        if (javafxLabelJXMsgRspnTableImport == null) {
            javafxLabelJXMsgRspnTableImport = new JXMsgRspnTableImportCFLabel();
        }
        return (javafxLabelJXMsgRspnTableImport);
    }

    public void setJavaFXLabelJXMsgRspnTableImport(JXMsgRspnTableImportCFLabel value) {
        javafxLabelJXMsgRspnTableImport = value;
    }

    public JXMsgRspnTableImportEditor getJavaFXEditorJXMsgRspnTableImport() {
        if (javafxEditorJXMsgRspnTableImport == null) {
            javafxEditorJXMsgRspnTableImport = new JXMsgRspnTableImportEditor();
        }
        return (javafxEditorJXMsgRspnTableImport);
    }

    public void setJavaFXEditorJXMsgRspnTableImport(JXMsgRspnTableImportEditor value) {
        javafxEditorJXMsgRspnTableImport = value;
    }

    public JXMsgClientTableImportCFLabel getJavaFXLabelJXMsgClientTableImport() {
        if (javafxLabelJXMsgClientTableImport == null) {
            javafxLabelJXMsgClientTableImport = new JXMsgClientTableImportCFLabel();
        }
        return (javafxLabelJXMsgClientTableImport);
    }

    public void setJavaFXLabelJXMsgClientTableImport(JXMsgClientTableImportCFLabel value) {
        javafxLabelJXMsgClientTableImport = value;
    }

    public JXMsgClientTableImportEditor getJavaFXEditorJXMsgClientTableImport() {
        if (javafxEditorJXMsgClientTableImport == null) {
            javafxEditorJXMsgClientTableImport = new JXMsgClientTableImportEditor();
        }
        return (javafxEditorJXMsgClientTableImport);
    }

    public void setJavaFXEditorJXMsgClientTableImport(JXMsgClientTableImportEditor value) {
        javafxEditorJXMsgClientTableImport = value;
    }

    public JXMsgRqstTableBodyCFLabel getJavaFXLabelJXMsgRqstTableBody() {
        if (javafxLabelJXMsgRqstTableBody == null) {
            javafxLabelJXMsgRqstTableBody = new JXMsgRqstTableBodyCFLabel();
        }
        return (javafxLabelJXMsgRqstTableBody);
    }

    public void setJavaFXLabelJXMsgRqstTableBody(JXMsgRqstTableBodyCFLabel value) {
        javafxLabelJXMsgRqstTableBody = value;
    }

    public JXMsgRqstTableBodyEditor getJavaFXEditorJXMsgRqstTableBody() {
        if (javafxEditorJXMsgRqstTableBody == null) {
            javafxEditorJXMsgRqstTableBody = new JXMsgRqstTableBodyEditor();
        }
        return (javafxEditorJXMsgRqstTableBody);
    }

    public void setJavaFXEditorJXMsgRqstTableBody(JXMsgRqstTableBodyEditor value) {
        javafxEditorJXMsgRqstTableBody = value;
    }

    public JXMsgRspnTableBodyCFLabel getJavaFXLabelJXMsgRspnTableBody() {
        if (javafxLabelJXMsgRspnTableBody == null) {
            javafxLabelJXMsgRspnTableBody = new JXMsgRspnTableBodyCFLabel();
        }
        return (javafxLabelJXMsgRspnTableBody);
    }

    public void setJavaFXLabelJXMsgRspnTableBody(JXMsgRspnTableBodyCFLabel value) {
        javafxLabelJXMsgRspnTableBody = value;
    }

    public JXMsgRspnTableBodyEditor getJavaFXEditorJXMsgRspnTableBody() {
        if (javafxEditorJXMsgRspnTableBody == null) {
            javafxEditorJXMsgRspnTableBody = new JXMsgRspnTableBodyEditor();
        }
        return (javafxEditorJXMsgRspnTableBody);
    }

    public void setJavaFXEditorJXMsgRspnTableBody(JXMsgRspnTableBodyEditor value) {
        javafxEditorJXMsgRspnTableBody = value;
    }

    public JXMsgClientTableBodyCFLabel getJavaFXLabelJXMsgClientTableBody() {
        if (javafxLabelJXMsgClientTableBody == null) {
            javafxLabelJXMsgClientTableBody = new JXMsgClientTableBodyCFLabel();
        }
        return (javafxLabelJXMsgClientTableBody);
    }

    public void setJavaFXLabelJXMsgClientTableBody(JXMsgClientTableBodyCFLabel value) {
        javafxLabelJXMsgClientTableBody = value;
    }

    public JXMsgClientTableBodyEditor getJavaFXEditorJXMsgClientTableBody() {
        if (javafxEditorJXMsgClientTableBody == null) {
            javafxEditorJXMsgClientTableBody = new JXMsgClientTableBodyEditor();
        }
        return (javafxEditorJXMsgClientTableBody);
    }

    public void setJavaFXEditorJXMsgClientTableBody(JXMsgClientTableBodyEditor value) {
        javafxEditorJXMsgClientTableBody = value;
    }

    public DefaultVisibilityCFLabel getJavaFXLabelDefaultVisibility() {
        if (javafxLabelDefaultVisibility == null) {
            javafxLabelDefaultVisibility = new DefaultVisibilityCFLabel();
        }
        return (javafxLabelDefaultVisibility);
    }

    public void setJavaFXLabelDefaultVisibility(DefaultVisibilityCFLabel value) {
        javafxLabelDefaultVisibility = value;
    }

    public DefaultVisibilityEditor getJavaFXEditorDefaultVisibility() {
        if (javafxEditorDefaultVisibility == null) {
            javafxEditorDefaultVisibility = new DefaultVisibilityEditor();
        }
        return (javafxEditorDefaultVisibility);
    }

    public void setJavaFXEditorDefaultVisibility(DefaultVisibilityEditor value) {
        javafxEditorDefaultVisibility = value;
    }

    public void populateFields() {
        ICFBamTableObj popObj;
        ICFBamTableObj focus = getJavaFXFocusAsTable();
        if (focus != null) {
            popObj = (ICFBamTableObj) (focus.getEdit());
            if (popObj == null) {
                popObj = focus;
            }
        } else {
            popObj = null;
        }
        if (getPaneMode() == CFPane.PaneMode.Unknown) {
            popObj = null;
        }
        if (popObj == null) {
            javafxLookupDefSchemaObj = null;
        } else {
            javafxLookupDefSchemaObj = (ICFBamSchemaDefObj) popObj.getOptionalLookupDefSchema(javafxIsInitializing);
        }
        if (javafxReferenceLookupDefSchema != null) {
            javafxReferenceLookupDefSchema.setReferencedObject(javafxLookupDefSchemaObj);
        }

        if (popObj == null) {
            javafxLookupLookupIndexObj = null;
        } else {
            javafxLookupLookupIndexObj = (ICFBamIndexObj) popObj.getOptionalLookupLookupIndex(javafxIsInitializing);
        }
        if (javafxReferenceLookupLookupIndex != null) {
            javafxReferenceLookupLookupIndex.setReferencedObject(javafxLookupLookupIndexObj);
        }

        if (popObj == null) {
            javafxLookupAltIndexObj = null;
        } else {
            javafxLookupAltIndexObj = (ICFBamIndexObj) popObj.getOptionalLookupAltIndex(javafxIsInitializing);
        }
        if (javafxReferenceLookupAltIndex != null) {
            javafxReferenceLookupAltIndex.setReferencedObject(javafxLookupAltIndexObj);
        }

        if (popObj == null) {
            javafxLookupQualTableObj = null;
        } else {
            javafxLookupQualTableObj = (ICFBamTableObj) popObj.getOptionalLookupQualTable(javafxIsInitializing);
        }
        if (javafxReferenceLookupQualTable != null) {
            javafxReferenceLookupQualTable.setReferencedObject(javafxLookupQualTableObj);
        }

        if (popObj == null) {
            javafxLookupPrimaryIndexObj = null;
        } else {
            javafxLookupPrimaryIndexObj = (ICFBamIndexObj) popObj
                    .getOptionalLookupPrimaryIndex(javafxIsInitializing);
        }
        if (javafxReferenceLookupPrimaryIndex != null) {
            javafxReferenceLookupPrimaryIndex.setReferencedObject(javafxLookupPrimaryIndexObj);
        }

        if (popObj == null) {
            getJavaFXEditorId().setInt64Value(null);
        } else {
            getJavaFXEditorId().setInt64Value(popObj.getRequiredId());
        }

        if (popObj == null) {
            getJavaFXEditorName().setStringValue(null);
        } else {
            getJavaFXEditorName().setStringValue(popObj.getRequiredName());
        }

        if (popObj == null) {
            getJavaFXEditorDbName().setStringValue(null);
        } else {
            getJavaFXEditorDbName().setStringValue(popObj.getOptionalDbName());
        }

        if (popObj == null) {
            getJavaFXEditorShortName().setStringValue(null);
        } else {
            getJavaFXEditorShortName().setStringValue(popObj.getOptionalShortName());
        }

        if (popObj == null) {
            getJavaFXEditorLabel().setStringValue(null);
        } else {
            getJavaFXEditorLabel().setStringValue(popObj.getOptionalLabel());
        }

        if (popObj == null) {
            getJavaFXEditorShortDescription().setStringValue(null);
        } else {
            getJavaFXEditorShortDescription().setStringValue(popObj.getOptionalShortDescription());
        }

        if (popObj == null) {
            getJavaFXEditorDescription().setStringValue(null);
        } else {
            getJavaFXEditorDescription().setStringValue(popObj.getOptionalDescription());
        }

        if (popObj == null) {
            getJavaFXEditorPageData().setBooleanValue(null);
        } else {
            getJavaFXEditorPageData().setBooleanValue(popObj.getRequiredPageData());
        }

        if (popObj == null) {
            getJavaFXEditorTableClassCode().setStringValue(null);
        } else {
            getJavaFXEditorTableClassCode().setStringValue(popObj.getRequiredTableClassCode());
        }

        if (popObj == null) {
            getJavaFXEditorPolyBase().setBooleanValue(null);
        } else {
            getJavaFXEditorPolyBase().setBooleanValue(popObj.getRequiredPolyBase());
        }

        if (popObj == null) {
            getJavaFXEditorIsInstantiable().setBooleanValue(null);
        } else {
            getJavaFXEditorIsInstantiable().setBooleanValue(popObj.getRequiredIsInstantiable());
        }

        if (popObj == null) {
            getJavaFXEditorHasHistory().setBooleanValue(null);
        } else {
            getJavaFXEditorHasHistory().setBooleanValue(popObj.getRequiredHasHistory());
        }

        if (popObj == null) {
            getJavaFXEditorHasAuditColumns().setBooleanValue(null);
        } else {
            getJavaFXEditorHasAuditColumns().setBooleanValue(popObj.getRequiredHasAuditColumns());
        }

        if (popObj == null) {
            getJavaFXEditorLoaderBehaviour().setValue(null);
        } else {
            getJavaFXEditorLoaderBehaviour().setValue((popObj.getRequiredLoaderBehaviour() == null) ? null
                    : popObj.getRequiredLoaderBehaviour().toString());
        }

        if (popObj == null) {
            getJavaFXEditorSecurityScope().setValue(null);
        } else {
            getJavaFXEditorSecurityScope().setValue((popObj.getRequiredSecurityScope() == null) ? null
                    : popObj.getRequiredSecurityScope().toString());
        }

        if (popObj == null) {
            getJavaFXEditorJObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJObjMembers().setTextValue(popObj.getOptionalJObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJObjInterface().setTextValue(null);
        } else {
            getJavaFXEditorJObjInterface().setTextValue(popObj.getOptionalJObjInterface());
        }

        if (popObj == null) {
            getJavaFXEditorJObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJObjImport().setTextValue(popObj.getOptionalJObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJObjImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJObjImplementation().setTextValue(popObj.getOptionalJObjImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJEditObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJEditObjMembers().setTextValue(popObj.getOptionalJEditObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJEditObjInterface().setTextValue(null);
        } else {
            getJavaFXEditorJEditObjInterface().setTextValue(popObj.getOptionalJEditObjInterface());
        }

        if (popObj == null) {
            getJavaFXEditorJEditObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJEditObjImport().setTextValue(popObj.getOptionalJEditObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJEditObjImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJEditObjImplementation().setTextValue(popObj.getOptionalJEditObjImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJTableImport().setTextValue(popObj.getOptionalJTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJTableMembers().setTextValue(popObj.getOptionalJTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJTableInterface().setTextValue(null);
        } else {
            getJavaFXEditorJTableInterface().setTextValue(popObj.getOptionalJTableInterface());
        }

        if (popObj == null) {
            getJavaFXEditorJTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJTableImplementation().setTextValue(popObj.getOptionalJTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJTableObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJTableObjImport().setTextValue(popObj.getOptionalJTableObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJTableObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJTableObjMembers().setTextValue(popObj.getOptionalJTableObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJTableObjInterface().setTextValue(null);
        } else {
            getJavaFXEditorJTableObjInterface().setTextValue(popObj.getOptionalJTableObjInterface());
        }

        if (popObj == null) {
            getJavaFXEditorJTableObjImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJTableObjImplementation().setTextValue(popObj.getOptionalJTableObjImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWTableImport().setTextValue(popObj.getOptionalJDb2LUWTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWTableMembers().setTextValue(popObj.getOptionalJDb2LUWTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWTableImplementation()
                    .setTextValue(popObj.getOptionalJDb2LUWTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlTableImport().setTextValue(popObj.getOptionalJMSSqlTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlTableMembers().setTextValue(popObj.getOptionalJMSSqlTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlTableImplementation().setTextValue(popObj.getOptionalJMSSqlTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlTableImport().setTextValue(popObj.getOptionalJMySqlTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlTableMembers().setTextValue(popObj.getOptionalJMySqlTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlTableImplementation().setTextValue(popObj.getOptionalJMySqlTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJOracleTableImport().setTextValue(popObj.getOptionalJOracleTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJOracleTableMembers().setTextValue(popObj.getOptionalJOracleTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJOracleTableImplementation()
                    .setTextValue(popObj.getOptionalJOracleTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlTableImport().setTextValue(popObj.getOptionalJPgSqlTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlTableMembers().setTextValue(popObj.getOptionalJPgSqlTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlTableImplementation().setTextValue(popObj.getOptionalJPgSqlTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseTableImport().setTextValue(popObj.getOptionalJSybaseTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseTableMembers().setTextValue(popObj.getOptionalJSybaseTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseTableImplementation()
                    .setTextValue(popObj.getOptionalJSybaseTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJRamTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJRamTableImport().setTextValue(popObj.getOptionalJRamTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJRamTableMembers().setTextValue(null);
        } else {
            getJavaFXEditorJRamTableMembers().setTextValue(popObj.getOptionalJRamTableMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJRamTableImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJRamTableImplementation().setTextValue(popObj.getOptionalJRamTableImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJSaxLoaderImport().setTextValue(null);
        } else {
            getJavaFXEditorJSaxLoaderImport().setTextValue(popObj.getOptionalJSaxLoaderImport());
        }

        if (popObj == null) {
            getJavaFXEditorJSaxLoaderStartElement().setTextValue(null);
        } else {
            getJavaFXEditorJSaxLoaderStartElement().setTextValue(popObj.getOptionalJSaxLoaderStartElement());
        }

        if (popObj == null) {
            getJavaFXEditorJSaxLoaderEndElement().setTextValue(null);
        } else {
            getJavaFXEditorJSaxLoaderEndElement().setTextValue(popObj.getOptionalJSaxLoaderEndElement());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgTableImport().setTextValue(popObj.getOptionalJXMsgTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgTableFormatters().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgTableFormatters().setTextValue(popObj.getOptionalJXMsgTableFormatters());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstTableImport().setTextValue(popObj.getOptionalJXMsgRqstTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnTableImport().setTextValue(popObj.getOptionalJXMsgRspnTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgClientTableImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgClientTableImport().setTextValue(popObj.getOptionalJXMsgClientTableImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstTableBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstTableBody().setTextValue(popObj.getOptionalJXMsgRqstTableBody());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnTableBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnTableBody().setTextValue(popObj.getOptionalJXMsgRspnTableBody());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgClientTableBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgClientTableBody().setTextValue(popObj.getOptionalJXMsgClientTableBody());
        }

        if (popObj == null) {
            getJavaFXEditorDefaultVisibility().setBooleanValue(null);
        } else {
            getJavaFXEditorDefaultVisibility().setBooleanValue(popObj.getRequiredDefaultVisibility());
        }
    }

    public void postFields() {
        final String S_ProcName = "postFields";
        ICFBamTableObj focus = getJavaFXFocusAsTable();
        ICFBamTableEditObj editObj;
        if (focus != null) {
            editObj = (ICFBamTableEditObj) (focus.getEdit());
        } else {
            editObj = null;
        }
        if (editObj == null) {
            throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                    "Pane is unfocused or is not editing the focus object");
        }

        javafxLookupDefSchemaObj = (ICFBamSchemaDefObj) (javafxReferenceLookupDefSchema.getReferencedObject());
        editObj.setOptionalLookupDefSchema(javafxLookupDefSchemaObj);

        javafxLookupLookupIndexObj = (ICFBamIndexObj) (javafxReferenceLookupLookupIndex.getReferencedObject());
        editObj.setOptionalLookupLookupIndex(javafxLookupLookupIndexObj);

        javafxLookupAltIndexObj = (ICFBamIndexObj) (javafxReferenceLookupAltIndex.getReferencedObject());
        editObj.setOptionalLookupAltIndex(javafxLookupAltIndexObj);

        javafxLookupQualTableObj = (ICFBamTableObj) (javafxReferenceLookupQualTable.getReferencedObject());
        editObj.setOptionalLookupQualTable(javafxLookupQualTableObj);

        javafxLookupPrimaryIndexObj = (ICFBamIndexObj) (javafxReferenceLookupPrimaryIndex.getReferencedObject());
        editObj.setOptionalLookupPrimaryIndex(javafxLookupPrimaryIndexObj);

        editObj.setRequiredName(getJavaFXEditorName().getStringValue());

        editObj.setOptionalDbName(getJavaFXEditorDbName().getStringValue());

        editObj.setOptionalShortName(getJavaFXEditorShortName().getStringValue());

        editObj.setOptionalLabel(getJavaFXEditorLabel().getStringValue());

        editObj.setOptionalShortDescription(getJavaFXEditorShortDescription().getStringValue());

        editObj.setOptionalDescription(getJavaFXEditorDescription().getStringValue());

        editObj.setRequiredPageData(getJavaFXEditorPageData().getBooleanValue());

        editObj.setRequiredTableClassCode(getJavaFXEditorTableClassCode().getStringValue());

        editObj.setRequiredPolyBase(getJavaFXEditorPolyBase().getBooleanValue());

        editObj.setRequiredIsInstantiable(getJavaFXEditorIsInstantiable().getBooleanValue());

        editObj.setRequiredHasHistory(getJavaFXEditorHasHistory().getBooleanValue());

        editObj.setRequiredHasAuditColumns(getJavaFXEditorHasAuditColumns().getBooleanValue());

        String strloaderbehaviour = getJavaFXEditorLoaderBehaviour().getValue();
        ICFBamSchema.LoaderBehaviourEnum curloaderbehaviour = CFBamSchema
                .parseLoaderBehaviourEnum("LoaderBehaviour", strloaderbehaviour);
        editObj.setRequiredLoaderBehaviour(curloaderbehaviour);

        String strsecurityscope = getJavaFXEditorSecurityScope().getValue();
        ICFBamSchema.SecurityScopeEnum cursecurityscope = CFBamSchema.parseSecurityScopeEnum("SecurityScope",
                strsecurityscope);
        editObj.setRequiredSecurityScope(cursecurityscope);

        editObj.setOptionalJObjMembers(getJavaFXEditorJObjMembers().getTextValue());

        editObj.setOptionalJObjInterface(getJavaFXEditorJObjInterface().getTextValue());

        editObj.setOptionalJObjImport(getJavaFXEditorJObjImport().getTextValue());

        editObj.setOptionalJObjImplementation(getJavaFXEditorJObjImplementation().getTextValue());

        editObj.setOptionalJEditObjMembers(getJavaFXEditorJEditObjMembers().getTextValue());

        editObj.setOptionalJEditObjInterface(getJavaFXEditorJEditObjInterface().getTextValue());

        editObj.setOptionalJEditObjImport(getJavaFXEditorJEditObjImport().getTextValue());

        editObj.setOptionalJEditObjImplementation(getJavaFXEditorJEditObjImplementation().getTextValue());

        editObj.setOptionalJTableImport(getJavaFXEditorJTableImport().getTextValue());

        editObj.setOptionalJTableMembers(getJavaFXEditorJTableMembers().getTextValue());

        editObj.setOptionalJTableInterface(getJavaFXEditorJTableInterface().getTextValue());

        editObj.setOptionalJTableImplementation(getJavaFXEditorJTableImplementation().getTextValue());

        editObj.setOptionalJTableObjImport(getJavaFXEditorJTableObjImport().getTextValue());

        editObj.setOptionalJTableObjMembers(getJavaFXEditorJTableObjMembers().getTextValue());

        editObj.setOptionalJTableObjInterface(getJavaFXEditorJTableObjInterface().getTextValue());

        editObj.setOptionalJTableObjImplementation(getJavaFXEditorJTableObjImplementation().getTextValue());

        editObj.setOptionalJDb2LUWTableImport(getJavaFXEditorJDb2LUWTableImport().getTextValue());

        editObj.setOptionalJDb2LUWTableMembers(getJavaFXEditorJDb2LUWTableMembers().getTextValue());

        editObj.setOptionalJDb2LUWTableImplementation(getJavaFXEditorJDb2LUWTableImplementation().getTextValue());

        editObj.setOptionalJMSSqlTableImport(getJavaFXEditorJMSSqlTableImport().getTextValue());

        editObj.setOptionalJMSSqlTableMembers(getJavaFXEditorJMSSqlTableMembers().getTextValue());

        editObj.setOptionalJMSSqlTableImplementation(getJavaFXEditorJMSSqlTableImplementation().getTextValue());

        editObj.setOptionalJMySqlTableImport(getJavaFXEditorJMySqlTableImport().getTextValue());

        editObj.setOptionalJMySqlTableMembers(getJavaFXEditorJMySqlTableMembers().getTextValue());

        editObj.setOptionalJMySqlTableImplementation(getJavaFXEditorJMySqlTableImplementation().getTextValue());

        editObj.setOptionalJOracleTableImport(getJavaFXEditorJOracleTableImport().getTextValue());

        editObj.setOptionalJOracleTableMembers(getJavaFXEditorJOracleTableMembers().getTextValue());

        editObj.setOptionalJOracleTableImplementation(getJavaFXEditorJOracleTableImplementation().getTextValue());

        editObj.setOptionalJPgSqlTableImport(getJavaFXEditorJPgSqlTableImport().getTextValue());

        editObj.setOptionalJPgSqlTableMembers(getJavaFXEditorJPgSqlTableMembers().getTextValue());

        editObj.setOptionalJPgSqlTableImplementation(getJavaFXEditorJPgSqlTableImplementation().getTextValue());

        editObj.setOptionalJSybaseTableImport(getJavaFXEditorJSybaseTableImport().getTextValue());

        editObj.setOptionalJSybaseTableMembers(getJavaFXEditorJSybaseTableMembers().getTextValue());

        editObj.setOptionalJSybaseTableImplementation(getJavaFXEditorJSybaseTableImplementation().getTextValue());

        editObj.setOptionalJRamTableImport(getJavaFXEditorJRamTableImport().getTextValue());

        editObj.setOptionalJRamTableMembers(getJavaFXEditorJRamTableMembers().getTextValue());

        editObj.setOptionalJRamTableImplementation(getJavaFXEditorJRamTableImplementation().getTextValue());

        editObj.setOptionalJSaxLoaderImport(getJavaFXEditorJSaxLoaderImport().getTextValue());

        editObj.setOptionalJSaxLoaderStartElement(getJavaFXEditorJSaxLoaderStartElement().getTextValue());

        editObj.setOptionalJSaxLoaderEndElement(getJavaFXEditorJSaxLoaderEndElement().getTextValue());

        editObj.setOptionalJXMsgTableImport(getJavaFXEditorJXMsgTableImport().getTextValue());

        editObj.setOptionalJXMsgTableFormatters(getJavaFXEditorJXMsgTableFormatters().getTextValue());

        editObj.setOptionalJXMsgRqstTableImport(getJavaFXEditorJXMsgRqstTableImport().getTextValue());

        editObj.setOptionalJXMsgRspnTableImport(getJavaFXEditorJXMsgRspnTableImport().getTextValue());

        editObj.setOptionalJXMsgClientTableImport(getJavaFXEditorJXMsgClientTableImport().getTextValue());

        editObj.setOptionalJXMsgRqstTableBody(getJavaFXEditorJXMsgRqstTableBody().getTextValue());

        editObj.setOptionalJXMsgRspnTableBody(getJavaFXEditorJXMsgRspnTableBody().getTextValue());

        editObj.setOptionalJXMsgClientTableBody(getJavaFXEditorJXMsgClientTableBody().getTextValue());

        editObj.setRequiredDefaultVisibility(getJavaFXEditorDefaultVisibility().getBooleanValue());
    }

    public void setPaneMode(CFPane.PaneMode value) {
        final String S_ProcName = "setPaneMode";
        CFPane.PaneMode oldValue = getPaneMode();
        if (oldValue == value) {
            return;
        }
        ICFBamTableObj focus = getJavaFXFocusAsTable();
        if ((value != CFPane.PaneMode.Unknown) && (value != CFPane.PaneMode.View)) {
            if (focus == null) {
                throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 0,
                        "javaFXFocus");
            }
        }
        ICFBamTableEditObj editObj;
        if (focus != null) {
            editObj = (ICFBamTableEditObj) focus.getEdit();
        } else {
            editObj = null;
        }
        switch (value) {
        case Unknown:
            switch (oldValue) {
            case Unknown:
                break;
            default:
                if (editObj != null) {
                    editObj.endEdit();
                }
                break;
            }
            break;
        case Add:
            switch (oldValue) {
            case Unknown:
            case Add:
            case View:
                if (editObj == null) {
                    if (focus != null) {
                        if (!focus.getIsNew()) {
                            throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                    "Transitioning to PaneMode Add requires Focus.getIsNew() to be true");
                        }
                        editObj = (ICFBamTableEditObj) focus.beginEdit();
                        if (editObj == null) {
                            throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                    "Expected beginEdit() to return a new edition of the focus object");
                        }
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 0,
                                "focus");
                    }
                }
                break;
            case Edit:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode Edit to Add");
            case Update:
                if ((editObj == null) || (!editObj.getIsNew())) {
                    throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                            "Cannot transition PaneMode Update to Add");
                }
                break;
            case Delete:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode Delete to Add");
            default:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode default to Add");
            }
            break;
        case View:
            switch (oldValue) {
            case Unknown:
                break;
            case View:
                break;
            case Edit:
                break;
            case Update:
                break;
            case Delete:
                break;
            default:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode " + oldValue + " to View");
            }
            if (editObj != null) {
                editObj.endEdit();
            }
            break;
        case Edit:
            switch (oldValue) {
            case Unknown:
                if (editObj == null) {
                    editObj = (ICFBamTableEditObj) focus.beginEdit();
                    if (editObj == null) {
                        throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                "Expected beginEdit() to return a new edition of the focus object");
                    }
                }
                break;
            case View:
                if (editObj == null) {
                    editObj = (ICFBamTableEditObj) focus.beginEdit();
                    if (editObj == null) {
                        throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                "Expected beginEdit() to return a new edition of the focus object");
                    }
                }
                break;
            case Edit:
                if (editObj == null) {
                    editObj = (ICFBamTableEditObj) focus.beginEdit();
                    if (editObj == null) {
                        throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                "Expected beginEdit() to return a new edition of the focus object");
                    }
                }
                break;
            case Update:
                if (editObj == null) {
                    throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                            "Cannot transition PaneMode " + oldValue + " to Edit");
                }
                break;
            default:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode " + oldValue + " to Edit");
            }
            break;
        case Update:
            if ((oldValue != CFPane.PaneMode.Edit) && (oldValue != CFPane.PaneMode.Add)) {
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition from mode " + oldValue + " to Update");
            }
            super.setPaneMode(value);
            if (editObj != null) {
                postFields();
                if (editObj.getIsNew()) {
                    focus = (ICFBamTableObj) editObj.create();
                    setJavaFXFocus(focus);
                } else {
                    editObj.update();
                }
                editObj.endEdit();
                editObj = null;
            }
            setPaneMode(CFPane.PaneMode.View);
            break;
        case Delete:
            switch (oldValue) {
            case View:
                if (focus != null) {
                    if (editObj == null) {
                        editObj = (ICFBamTableEditObj) focus.beginEdit();
                        if (editObj == null) {
                            throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                    "Expected beginEdit() to return a new edition of the focus object");
                        }
                    }
                }
                break;
            case Edit:
                if (focus != null) {
                    if (editObj == null) {
                        editObj = (ICFBamTableEditObj) focus.beginEdit();
                        if (editObj == null) {
                            throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                    "Expected beginEdit() to return a new edition of the focus object");
                        }
                    }
                }
                break;
            case Update:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode Update to Delete");
            case Delete:
                if (editObj == null) {
                    editObj = (ICFBamTableEditObj) focus.beginEdit();
                    if (editObj == null) {
                        throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                                "Expected beginEdit() to return a new edition of the focus object");
                    }
                }
                break;
            default:
                throw CFLib.getDefaultExceptionFactory().newUsageException(getClass(), S_ProcName,
                        "Cannot transition PaneMode " + oldValue + " to Delete");
            }
            editObj.delete();
            editObj.endEdit();
            setJavaFXFocus(null);
            setPaneMode(CFPane.PaneMode.Unknown);
            break;
        default:
            switch (oldValue) {
            case Unknown:
                break;
            default:
                if (editObj != null) {
                    editObj.endEdit();
                }
                break;
            }
            break;
        }
        super.setPaneMode(value);
        populateFields();
        adjustComponentEnableStates();
    }

    public void adjustComponentEnableStates() {
        CFPane.PaneMode mode = getPaneMode();
        boolean isEditing;
        switch (mode) {
        case Unknown:
        case View:
        case Delete:
            isEditing = false;
            break;
        case Add:
        case Edit:
        case Update:
            isEditing = true;
            break;
        default:
            isEditing = false;
            break;
        }
        if (isEditing) {
            ICFBamTableObj focus = getJavaFXFocusAsTable();
            if (focus == null) {
                isEditing = false;
            } else if (null == focus.getEdit()) {
                isEditing = false;
            }
        }
        if (javafxReferenceLookupDefSchema != null) {
            javafxReferenceLookupDefSchema.setCustomDisable(!isEditing);
        }
        if (javafxReferenceLookupLookupIndex != null) {
            javafxReferenceLookupLookupIndex.setCustomDisable(!isEditing);
        }
        if (javafxReferenceLookupAltIndex != null) {
            javafxReferenceLookupAltIndex.setCustomDisable(!isEditing);
        }
        if (javafxReferenceLookupQualTable != null) {
            javafxReferenceLookupQualTable.setCustomDisable(!isEditing);
        }
        if (javafxReferenceLookupPrimaryIndex != null) {
            javafxReferenceLookupPrimaryIndex.setCustomDisable(!isEditing);
        }
        if (javafxEditorId != null) {
            javafxEditorId.setDisable(true);
        }
        if (javafxEditorName != null) {
            javafxEditorName.setDisable(!isEditing);
        }
        if (javafxEditorDbName != null) {
            javafxEditorDbName.setDisable(!isEditing);
        }
        if (javafxEditorShortName != null) {
            javafxEditorShortName.setDisable(!isEditing);
        }
        if (javafxEditorLabel != null) {
            javafxEditorLabel.setDisable(!isEditing);
        }
        if (javafxEditorShortDescription != null) {
            javafxEditorShortDescription.setDisable(!isEditing);
        }
        if (javafxEditorDescription != null) {
            javafxEditorDescription.setDisable(!isEditing);
        }
        if (javafxEditorPageData != null) {
            javafxEditorPageData.setDisable(!isEditing);
        }
        if (javafxEditorTableClassCode != null) {
            javafxEditorTableClassCode.setDisable(!isEditing);
        }
        if (javafxEditorPolyBase != null) {
            javafxEditorPolyBase.setDisable(!isEditing);
        }
        if (javafxEditorIsInstantiable != null) {
            javafxEditorIsInstantiable.setDisable(!isEditing);
        }
        if (javafxEditorHasHistory != null) {
            javafxEditorHasHistory.setDisable(!isEditing);
        }
        if (javafxEditorHasAuditColumns != null) {
            javafxEditorHasAuditColumns.setDisable(!isEditing);
        }
        if (javafxEditorLoaderBehaviour != null) {
            javafxEditorLoaderBehaviour.setDisable(!isEditing);
        }
        if (javafxEditorSecurityScope != null) {
            javafxEditorSecurityScope.setDisable(!isEditing);
        }
        if (javafxEditorJObjMembers != null) {
            javafxEditorJObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJObjInterface != null) {
            javafxEditorJObjInterface.setDisable(!isEditing);
        }
        if (javafxEditorJObjImport != null) {
            javafxEditorJObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJObjImplementation != null) {
            javafxEditorJObjImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJEditObjMembers != null) {
            javafxEditorJEditObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJEditObjInterface != null) {
            javafxEditorJEditObjInterface.setDisable(!isEditing);
        }
        if (javafxEditorJEditObjImport != null) {
            javafxEditorJEditObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJEditObjImplementation != null) {
            javafxEditorJEditObjImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJTableImport != null) {
            javafxEditorJTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJTableMembers != null) {
            javafxEditorJTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJTableInterface != null) {
            javafxEditorJTableInterface.setDisable(!isEditing);
        }
        if (javafxEditorJTableImplementation != null) {
            javafxEditorJTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJTableObjImport != null) {
            javafxEditorJTableObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJTableObjMembers != null) {
            javafxEditorJTableObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJTableObjInterface != null) {
            javafxEditorJTableObjInterface.setDisable(!isEditing);
        }
        if (javafxEditorJTableObjImplementation != null) {
            javafxEditorJTableObjImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWTableImport != null) {
            javafxEditorJDb2LUWTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWTableMembers != null) {
            javafxEditorJDb2LUWTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWTableImplementation != null) {
            javafxEditorJDb2LUWTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlTableImport != null) {
            javafxEditorJMSSqlTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlTableMembers != null) {
            javafxEditorJMSSqlTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlTableImplementation != null) {
            javafxEditorJMSSqlTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlTableImport != null) {
            javafxEditorJMySqlTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlTableMembers != null) {
            javafxEditorJMySqlTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlTableImplementation != null) {
            javafxEditorJMySqlTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJOracleTableImport != null) {
            javafxEditorJOracleTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJOracleTableMembers != null) {
            javafxEditorJOracleTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJOracleTableImplementation != null) {
            javafxEditorJOracleTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlTableImport != null) {
            javafxEditorJPgSqlTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlTableMembers != null) {
            javafxEditorJPgSqlTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlTableImplementation != null) {
            javafxEditorJPgSqlTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseTableImport != null) {
            javafxEditorJSybaseTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseTableMembers != null) {
            javafxEditorJSybaseTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseTableImplementation != null) {
            javafxEditorJSybaseTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJRamTableImport != null) {
            javafxEditorJRamTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJRamTableMembers != null) {
            javafxEditorJRamTableMembers.setDisable(!isEditing);
        }
        if (javafxEditorJRamTableImplementation != null) {
            javafxEditorJRamTableImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJSaxLoaderImport != null) {
            javafxEditorJSaxLoaderImport.setDisable(!isEditing);
        }
        if (javafxEditorJSaxLoaderStartElement != null) {
            javafxEditorJSaxLoaderStartElement.setDisable(!isEditing);
        }
        if (javafxEditorJSaxLoaderEndElement != null) {
            javafxEditorJSaxLoaderEndElement.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgTableImport != null) {
            javafxEditorJXMsgTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgTableFormatters != null) {
            javafxEditorJXMsgTableFormatters.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstTableImport != null) {
            javafxEditorJXMsgRqstTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnTableImport != null) {
            javafxEditorJXMsgRspnTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgClientTableImport != null) {
            javafxEditorJXMsgClientTableImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstTableBody != null) {
            javafxEditorJXMsgRqstTableBody.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnTableBody != null) {
            javafxEditorJXMsgRspnTableBody.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgClientTableBody != null) {
            javafxEditorJXMsgClientTableBody.setDisable(!isEditing);
        }
        if (javafxEditorDefaultVisibility != null) {
            javafxEditorDefaultVisibility.setDisable(!isEditing);
        }
    }
}