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

Introduction

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

Source

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

/*
 *   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.*;

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

    protected class DefaultLicenseCFLabel extends CFLabel {
        public DefaultLicenseCFLabel() {
            super();
            setText("Default License");
        }
    }

    protected class CallbackDefaultLicenseChosen implements ICFInternetJavaFXLicenseChosen {
        public CallbackDefaultLicenseChosen() {
        }

        public void choseLicense(ICFInternetLicenseObj value) {
            if (javafxReferenceLookupDefaultLicense != null) {
                ICFBamSchemaDefObj cur = getJavaFXFocusAsSchemaDef();
                if (cur != null) {
                    ICFBamSchemaDefEditObj editObj = (ICFBamSchemaDefEditObj) cur.getEdit();
                    if (null != editObj) {
                        CFPane.PaneMode curMode = getPaneMode();
                        if ((curMode == CFPane.PaneMode.Add) || (curMode == CFPane.PaneMode.Edit)) {
                            javafxReferenceLookupDefaultLicense.setReferencedObject(value);
                            editObj.setOptionalLookupDefaultLicense(value);
                        }
                    }
                }
            }
        }
    }

    protected class DefaultLicenseReferenceCallback implements ICFReferenceCallback {
        public void chose(ICFLibAnyObj value) {
            final String S_ProcName = "chose";
            Node cont;
            ICFBamSchemaObj schemaObj = (ICFBamSchemaObj) javafxSchema.getSchema();
            ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
            ICFBamSchemaDefEditObj editObj = (ICFBamSchemaDefEditObj) focus.getEdit();
            if (editObj != null) {
                focus = editObj;
            }
            ICFInternetLicenseObj referencedObj = (ICFInternetLicenseObj) javafxReferenceLookupDefaultLicense
                    .getReferencedObject();
            java.util.List<ICFInternetLicenseObj> listOfLicense = null;
            Collection<ICFInternetLicenseObj> cltn = null;
            CFBorderPane form = javafxSchema.getLicenseFactory().newPickerForm(cfFormManager, referencedObj, null,
                    cltn, new CallbackDefaultLicenseChosen());
            ((ICFInternetJavaFXLicensePaneCommon) form).setPaneMode(CFPane.PaneMode.View);
            cfFormManager.pushForm(form);
        }

        public void view(ICFLibAnyObj value) {
            final String S_ProcName = "actionPerformed";
            ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
            if (focus != null) {
                ICFInternetLicenseObj referencedObj = (ICFInternetLicenseObj) javafxReferenceLookupDefaultLicense
                        .getReferencedObject();
                CFBorderPane form = null;
                if (referencedObj != null) {
                    String classCode = referencedObj.getClassCode();
                    if ("LIC".equals(classCode)) {
                        form = javafxSchema.getLicenseFactory().newAddForm(cfFormManager, referencedObj, null,
                                true);
                        ICFInternetJavaFXLicensePaneCommon spec = (ICFInternetJavaFXLicensePaneCommon) form;
                        spec.setJavaFXFocus(referencedObj);
                        spec.setPaneMode(CFPane.PaneMode.View);
                    } else {
                        throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(),
                                S_ProcName, "javaFXFocus", focus, "ICFBamLicenseObj");
                    }
                    cfFormManager.pushForm(form);
                }
            }
        }
    }

    protected class DefaultLicenseCFReferenceEditor extends CFReferenceEditor {
        public DefaultLicenseCFReferenceEditor() {
            super(new DefaultLicenseReferenceCallback());
            setFieldName("Default License");
        }
    }

    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(12);
            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(128);
            setFieldName("Short Description");
        }
    }

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

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

    protected class ExtendCFCoreCFLabel extends CFLabel {
        public ExtendCFCoreCFLabel() {
            super();
            setText("Extend CF Core");
        }
    }

    protected class ExtendCFCoreEditor extends CFBoolEditor {
        public ExtendCFCoreEditor() {
            super();
            setIsNullable(false);
            setFieldName("Extend CF Core");
        }
    }

    protected class CopyrightPeriodCFLabel extends CFLabel {
        public CopyrightPeriodCFLabel() {
            super();
            setText("Copyright Period");
        }
    }

    protected class CopyrightPeriodEditor extends CFStringEditor {
        public CopyrightPeriodEditor() {
            super();
            setMaxLen(10);
            setFieldName("Copyright Period");
        }
    }

    protected class CopyrightHolderCFLabel extends CFLabel {
        public CopyrightHolderCFLabel() {
            super();
            setText("Copyright Holder");
        }
    }

    protected class CopyrightHolderEditor extends CFStringEditor {
        public CopyrightHolderEditor() {
            super();
            setMaxLen(511);
            setFieldName("Copyright Holder");
        }
    }

    protected class PublishURICFLabel extends CFLabel {
        public PublishURICFLabel() {
            super();
            setText("Publish URI");
        }
    }

    protected class PublishURIEditor extends CFStringEditor {
        public PublishURIEditor() {
            super();
            setMaxLen(512);
            setFieldName("Publish URI");
        }
    }

    protected class JSchemaObjImportCFLabel extends CFLabel {
        public JSchemaObjImportCFLabel() {
            super();
            setText("JSchemaObjImport");
        }
    }

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

    protected class JSchemaObjInterfaceCFLabel extends CFLabel {
        public JSchemaObjInterfaceCFLabel() {
            super();
            setText("JSchemaObjInterface");
        }
    }

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

    protected class JSchemaObjMembersCFLabel extends CFLabel {
        public JSchemaObjMembersCFLabel() {
            super();
            setText("JSchemaObjMembers");
        }
    }

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

    protected class JSchemaObjImplementationCFLabel extends CFLabel {
        public JSchemaObjImplementationCFLabel() {
            super();
            setText("JSchemaObjImplementation");
        }
    }

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

    protected class JDb2LUWSchemaObjMembersCFLabel extends CFLabel {
        public JDb2LUWSchemaObjMembersCFLabel() {
            super();
            setText("JDb2LUWSchemaObjMembers");
        }
    }

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

    protected class JDb2LUWSchemaObjImplCFLabel extends CFLabel {
        public JDb2LUWSchemaObjImplCFLabel() {
            super();
            setText("JDb2LUWSchemaObjImpl");
        }
    }

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

    protected class JDb2LUWSchemaObjImportCFLabel extends CFLabel {
        public JDb2LUWSchemaObjImportCFLabel() {
            super();
            setText("JDb2LUWSchemaObjImport");
        }
    }

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

    protected class JMSSqlSchemaObjMembersCFLabel extends CFLabel {
        public JMSSqlSchemaObjMembersCFLabel() {
            super();
            setText("JMSSqlSchemaObjMembers");
        }
    }

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

    protected class JMSSqlSchemaObjImplCFLabel extends CFLabel {
        public JMSSqlSchemaObjImplCFLabel() {
            super();
            setText("JMSSqlSchemaObjImpl");
        }
    }

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

    protected class JMSSqlSchemaObjImportCFLabel extends CFLabel {
        public JMSSqlSchemaObjImportCFLabel() {
            super();
            setText("JMSSqlSchemaObjImport");
        }
    }

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

    protected class JMySqlSchemaObjMembersCFLabel extends CFLabel {
        public JMySqlSchemaObjMembersCFLabel() {
            super();
            setText("JMySqlSchemaObjMembers");
        }
    }

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

    protected class JMySqlSchemaObjImplCFLabel extends CFLabel {
        public JMySqlSchemaObjImplCFLabel() {
            super();
            setText("JMySqlSchemaObjImpl");
        }
    }

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

    protected class JMySqlSchemaObjImportCFLabel extends CFLabel {
        public JMySqlSchemaObjImportCFLabel() {
            super();
            setText("JMySqlSchemaObjImport");
        }
    }

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

    protected class JOracleSchemaObjMembersCFLabel extends CFLabel {
        public JOracleSchemaObjMembersCFLabel() {
            super();
            setText("JOracleSchemaObjMembers");
        }
    }

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

    protected class JOracleSchemaObjImplCFLabel extends CFLabel {
        public JOracleSchemaObjImplCFLabel() {
            super();
            setText("JOracleSchemaObjImpl");
        }
    }

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

    protected class JOracleSchemaObjImportCFLabel extends CFLabel {
        public JOracleSchemaObjImportCFLabel() {
            super();
            setText("JOracleSchemaObjImport");
        }
    }

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

    protected class JPgSqlSchemaObjMembersCFLabel extends CFLabel {
        public JPgSqlSchemaObjMembersCFLabel() {
            super();
            setText("JPgSqlSchemaObjMembers");
        }
    }

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

    protected class JPgSqlSchemaObjImplCFLabel extends CFLabel {
        public JPgSqlSchemaObjImplCFLabel() {
            super();
            setText("JPgSqlSchemaObjImpl");
        }
    }

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

    protected class JPgSqlSchemaObjImportCFLabel extends CFLabel {
        public JPgSqlSchemaObjImportCFLabel() {
            super();
            setText("JPgSqlSchemaObjImport");
        }
    }

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

    protected class JSybaseSchemaObjMembersCFLabel extends CFLabel {
        public JSybaseSchemaObjMembersCFLabel() {
            super();
            setText("JSybaseSchemaObjMembers");
        }
    }

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

    protected class JSybaseSchemaObjImplCFLabel extends CFLabel {
        public JSybaseSchemaObjImplCFLabel() {
            super();
            setText("JSybaseSchemaObjImpl");
        }
    }

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

    protected class JSybaseSchemaObjImportCFLabel extends CFLabel {
        public JSybaseSchemaObjImportCFLabel() {
            super();
            setText("JSybaseSchemaObjImport");
        }
    }

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

    protected class JRamSchemaObjMembersCFLabel extends CFLabel {
        public JRamSchemaObjMembersCFLabel() {
            super();
            setText("JRamSchemaObjMembers");
        }
    }

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

    protected class JRamSchemaObjImplCFLabel extends CFLabel {
        public JRamSchemaObjImplCFLabel() {
            super();
            setText("JRamSchemaObjImpl");
        }
    }

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

    protected class JRamSchemaObjImportCFLabel extends CFLabel {
        public JRamSchemaObjImportCFLabel() {
            super();
            setText("JRamSchemaObjImport");
        }
    }

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

    protected class JXMsgSchemaImportCFLabel extends CFLabel {
        public JXMsgSchemaImportCFLabel() {
            super();
            setText("JXMsgSchemaImport");
        }
    }

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

    protected class JXMsgSchemaFormattersCFLabel extends CFLabel {
        public JXMsgSchemaFormattersCFLabel() {
            super();
            setText("JXMsgSchemaFormatters");
        }
    }

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

    protected class JXMsgClientSchemaImportCFLabel extends CFLabel {
        public JXMsgClientSchemaImportCFLabel() {
            super();
            setText("JXMsgClientSchemaImport");
        }
    }

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

    protected class JXMsgClientSchemaBodyCFLabel extends CFLabel {
        public JXMsgClientSchemaBodyCFLabel() {
            super();
            setText("JXMsgClientSchemaBody");
        }
    }

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

    protected class JXMsgRqstSchemaBodyCFLabel extends CFLabel {
        public JXMsgRqstSchemaBodyCFLabel() {
            super();
            setText("JXMsgRqstSchemaBody");
        }
    }

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

    protected class JXMsgRqstSchemaImportCFLabel extends CFLabel {
        public JXMsgRqstSchemaImportCFLabel() {
            super();
            setText("JXMsgRqstSchemaImport");
        }
    }

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

    protected class JXMsgRqstSchemaWireParsersCFLabel extends CFLabel {
        public JXMsgRqstSchemaWireParsersCFLabel() {
            super();
            setText("JXMsgRqstSchemaWireParsers");
        }
    }

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

    protected class JXMsgRqstSchemaXsdSpecCFLabel extends CFLabel {
        public JXMsgRqstSchemaXsdSpecCFLabel() {
            super();
            setText("JXMsgRqstSchemaXsdSpec");
        }
    }

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

    protected class JXMsgRqstSchemaXsdElementListCFLabel extends CFLabel {
        public JXMsgRqstSchemaXsdElementListCFLabel() {
            super();
            setText("JXMsgRqstSchemaXsdElementList");
        }
    }

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

    protected class JXMsgRspnSchemaBodyCFLabel extends CFLabel {
        public JXMsgRspnSchemaBodyCFLabel() {
            super();
            setText("JXMsgRspnSchemaBody");
        }
    }

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

    protected class JXMsgRspnSchemaImportCFLabel extends CFLabel {
        public JXMsgRspnSchemaImportCFLabel() {
            super();
            setText("JXMsgRspnSchemaImport");
        }
    }

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

    protected class JXMsgRspnSchemaWireParsersCFLabel extends CFLabel {
        public JXMsgRspnSchemaWireParsersCFLabel() {
            super();
            setText("JXMsgRspnSchemaWireParsers");
        }
    }

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

    protected class JXMsgRspnSchemaXsdElementListCFLabel extends CFLabel {
        public JXMsgRspnSchemaXsdElementListCFLabel() {
            super();
            setText("JXMsgRspnSchemaXsdElementList");
        }
    }

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

    protected class JXMsgRspnSchemaXsdSpecCFLabel extends CFLabel {
        public JXMsgRspnSchemaXsdSpecCFLabel() {
            super();
            setText("JXMsgRspnSchemaXsdSpec");
        }
    }

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

    protected ICFInternetLicenseObj javafxLookupDefaultLicenseObj = null;
    protected DefaultLicenseCFLabel javafxLabelLookupDefaultLicense = null;
    protected DefaultLicenseCFReferenceEditor javafxReferenceLookupDefaultLicense = 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 ExtendCFCoreCFLabel javafxLabelExtendCFCore = null;
    protected ExtendCFCoreEditor javafxEditorExtendCFCore = null;
    protected CopyrightPeriodCFLabel javafxLabelCopyrightPeriod = null;
    protected CopyrightPeriodEditor javafxEditorCopyrightPeriod = null;
    protected CopyrightHolderCFLabel javafxLabelCopyrightHolder = null;
    protected CopyrightHolderEditor javafxEditorCopyrightHolder = null;
    protected PublishURICFLabel javafxLabelPublishURI = null;
    protected PublishURIEditor javafxEditorPublishURI = null;
    protected JSchemaObjImportCFLabel javafxLabelJSchemaObjImport = null;
    protected JSchemaObjImportEditor javafxEditorJSchemaObjImport = null;
    protected JSchemaObjInterfaceCFLabel javafxLabelJSchemaObjInterface = null;
    protected JSchemaObjInterfaceEditor javafxEditorJSchemaObjInterface = null;
    protected JSchemaObjMembersCFLabel javafxLabelJSchemaObjMembers = null;
    protected JSchemaObjMembersEditor javafxEditorJSchemaObjMembers = null;
    protected JSchemaObjImplementationCFLabel javafxLabelJSchemaObjImplementation = null;
    protected JSchemaObjImplementationEditor javafxEditorJSchemaObjImplementation = null;
    protected JDb2LUWSchemaObjMembersCFLabel javafxLabelJDb2LUWSchemaObjMembers = null;
    protected JDb2LUWSchemaObjMembersEditor javafxEditorJDb2LUWSchemaObjMembers = null;
    protected JDb2LUWSchemaObjImplCFLabel javafxLabelJDb2LUWSchemaObjImpl = null;
    protected JDb2LUWSchemaObjImplEditor javafxEditorJDb2LUWSchemaObjImpl = null;
    protected JDb2LUWSchemaObjImportCFLabel javafxLabelJDb2LUWSchemaObjImport = null;
    protected JDb2LUWSchemaObjImportEditor javafxEditorJDb2LUWSchemaObjImport = null;
    protected JMSSqlSchemaObjMembersCFLabel javafxLabelJMSSqlSchemaObjMembers = null;
    protected JMSSqlSchemaObjMembersEditor javafxEditorJMSSqlSchemaObjMembers = null;
    protected JMSSqlSchemaObjImplCFLabel javafxLabelJMSSqlSchemaObjImpl = null;
    protected JMSSqlSchemaObjImplEditor javafxEditorJMSSqlSchemaObjImpl = null;
    protected JMSSqlSchemaObjImportCFLabel javafxLabelJMSSqlSchemaObjImport = null;
    protected JMSSqlSchemaObjImportEditor javafxEditorJMSSqlSchemaObjImport = null;
    protected JMySqlSchemaObjMembersCFLabel javafxLabelJMySqlSchemaObjMembers = null;
    protected JMySqlSchemaObjMembersEditor javafxEditorJMySqlSchemaObjMembers = null;
    protected JMySqlSchemaObjImplCFLabel javafxLabelJMySqlSchemaObjImpl = null;
    protected JMySqlSchemaObjImplEditor javafxEditorJMySqlSchemaObjImpl = null;
    protected JMySqlSchemaObjImportCFLabel javafxLabelJMySqlSchemaObjImport = null;
    protected JMySqlSchemaObjImportEditor javafxEditorJMySqlSchemaObjImport = null;
    protected JOracleSchemaObjMembersCFLabel javafxLabelJOracleSchemaObjMembers = null;
    protected JOracleSchemaObjMembersEditor javafxEditorJOracleSchemaObjMembers = null;
    protected JOracleSchemaObjImplCFLabel javafxLabelJOracleSchemaObjImpl = null;
    protected JOracleSchemaObjImplEditor javafxEditorJOracleSchemaObjImpl = null;
    protected JOracleSchemaObjImportCFLabel javafxLabelJOracleSchemaObjImport = null;
    protected JOracleSchemaObjImportEditor javafxEditorJOracleSchemaObjImport = null;
    protected JPgSqlSchemaObjMembersCFLabel javafxLabelJPgSqlSchemaObjMembers = null;
    protected JPgSqlSchemaObjMembersEditor javafxEditorJPgSqlSchemaObjMembers = null;
    protected JPgSqlSchemaObjImplCFLabel javafxLabelJPgSqlSchemaObjImpl = null;
    protected JPgSqlSchemaObjImplEditor javafxEditorJPgSqlSchemaObjImpl = null;
    protected JPgSqlSchemaObjImportCFLabel javafxLabelJPgSqlSchemaObjImport = null;
    protected JPgSqlSchemaObjImportEditor javafxEditorJPgSqlSchemaObjImport = null;
    protected JSybaseSchemaObjMembersCFLabel javafxLabelJSybaseSchemaObjMembers = null;
    protected JSybaseSchemaObjMembersEditor javafxEditorJSybaseSchemaObjMembers = null;
    protected JSybaseSchemaObjImplCFLabel javafxLabelJSybaseSchemaObjImpl = null;
    protected JSybaseSchemaObjImplEditor javafxEditorJSybaseSchemaObjImpl = null;
    protected JSybaseSchemaObjImportCFLabel javafxLabelJSybaseSchemaObjImport = null;
    protected JSybaseSchemaObjImportEditor javafxEditorJSybaseSchemaObjImport = null;
    protected JRamSchemaObjMembersCFLabel javafxLabelJRamSchemaObjMembers = null;
    protected JRamSchemaObjMembersEditor javafxEditorJRamSchemaObjMembers = null;
    protected JRamSchemaObjImplCFLabel javafxLabelJRamSchemaObjImpl = null;
    protected JRamSchemaObjImplEditor javafxEditorJRamSchemaObjImpl = null;
    protected JRamSchemaObjImportCFLabel javafxLabelJRamSchemaObjImport = null;
    protected JRamSchemaObjImportEditor javafxEditorJRamSchemaObjImport = null;
    protected JXMsgSchemaImportCFLabel javafxLabelJXMsgSchemaImport = null;
    protected JXMsgSchemaImportEditor javafxEditorJXMsgSchemaImport = null;
    protected JXMsgSchemaFormattersCFLabel javafxLabelJXMsgSchemaFormatters = null;
    protected JXMsgSchemaFormattersEditor javafxEditorJXMsgSchemaFormatters = null;
    protected JXMsgClientSchemaImportCFLabel javafxLabelJXMsgClientSchemaImport = null;
    protected JXMsgClientSchemaImportEditor javafxEditorJXMsgClientSchemaImport = null;
    protected JXMsgClientSchemaBodyCFLabel javafxLabelJXMsgClientSchemaBody = null;
    protected JXMsgClientSchemaBodyEditor javafxEditorJXMsgClientSchemaBody = null;
    protected JXMsgRqstSchemaBodyCFLabel javafxLabelJXMsgRqstSchemaBody = null;
    protected JXMsgRqstSchemaBodyEditor javafxEditorJXMsgRqstSchemaBody = null;
    protected JXMsgRqstSchemaImportCFLabel javafxLabelJXMsgRqstSchemaImport = null;
    protected JXMsgRqstSchemaImportEditor javafxEditorJXMsgRqstSchemaImport = null;
    protected JXMsgRqstSchemaWireParsersCFLabel javafxLabelJXMsgRqstSchemaWireParsers = null;
    protected JXMsgRqstSchemaWireParsersEditor javafxEditorJXMsgRqstSchemaWireParsers = null;
    protected JXMsgRqstSchemaXsdSpecCFLabel javafxLabelJXMsgRqstSchemaXsdSpec = null;
    protected JXMsgRqstSchemaXsdSpecEditor javafxEditorJXMsgRqstSchemaXsdSpec = null;
    protected JXMsgRqstSchemaXsdElementListCFLabel javafxLabelJXMsgRqstSchemaXsdElementList = null;
    protected JXMsgRqstSchemaXsdElementListEditor javafxEditorJXMsgRqstSchemaXsdElementList = null;
    protected JXMsgRspnSchemaBodyCFLabel javafxLabelJXMsgRspnSchemaBody = null;
    protected JXMsgRspnSchemaBodyEditor javafxEditorJXMsgRspnSchemaBody = null;
    protected JXMsgRspnSchemaImportCFLabel javafxLabelJXMsgRspnSchemaImport = null;
    protected JXMsgRspnSchemaImportEditor javafxEditorJXMsgRspnSchemaImport = null;
    protected JXMsgRspnSchemaWireParsersCFLabel javafxLabelJXMsgRspnSchemaWireParsers = null;
    protected JXMsgRspnSchemaWireParsersEditor javafxEditorJXMsgRspnSchemaWireParsers = null;
    protected JXMsgRspnSchemaXsdElementListCFLabel javafxLabelJXMsgRspnSchemaXsdElementList = null;
    protected JXMsgRspnSchemaXsdElementListEditor javafxEditorJXMsgRspnSchemaXsdElementList = null;
    protected JXMsgRspnSchemaXsdSpecCFLabel javafxLabelJXMsgRspnSchemaXsdSpec = null;
    protected JXMsgRspnSchemaXsdSpecEditor javafxEditorJXMsgRspnSchemaXsdSpec = null;

    public CFBamJavaFXSchemaDefAttrPane(ICFFormManager formManager, ICFBamJavaFXSchema argSchema,
            ICFBamSchemaDefObj 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;
        setJavaFXFocusAsSchemaDef(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 = getJavaFXLabelLookupDefaultLicense();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

        reference = getJavaFXReferenceLookupDefaultLicense();
        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 = getJavaFXLabelExtendCFCore();
        setHalignment(label, HPos.LEFT);
        add(label, 0, gridRow);

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

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

        gridRow++;

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

        ctrl = getJavaFXEditorJXMsgRspnSchemaXsdSpec();
        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 ICFBamSchemaDefObj)) {
            super.setJavaFXFocus(value);
        } else {
            throw CFLib.getDefaultExceptionFactory().newUnsupportedClassException(getClass(), S_ProcName, "value",
                    value, "ICFBamSchemaDefObj");
        }
        populateFields();
        adjustComponentEnableStates();
    }

    public ICFBamSchemaDefObj getJavaFXFocusAsSchemaDef() {
        return ((ICFBamSchemaDefObj) getJavaFXFocus());
    }

    public void setJavaFXFocusAsSchemaDef(ICFBamSchemaDefObj value) {
        setJavaFXFocus(value);
    }

    public ICFInternetLicenseObj getJavaFXLookupDefaultLicenseObj() {
        return (javafxLookupDefaultLicenseObj);
    }

    public void setJavaFXLookupDefaultLicenseObj(ICFInternetLicenseObj value) {
        javafxLookupDefaultLicenseObj = value;
    }

    public CFLabel getJavaFXLabelLookupDefaultLicense() {
        if (javafxLabelLookupDefaultLicense == null) {
            javafxLabelLookupDefaultLicense = new DefaultLicenseCFLabel();
        }
        return (javafxLabelLookupDefaultLicense);
    }

    public CFReferenceEditor getJavaFXReferenceLookupDefaultLicense() {
        if (javafxReferenceLookupDefaultLicense == null) {
            javafxReferenceLookupDefaultLicense = new DefaultLicenseCFReferenceEditor();
        }
        return (javafxReferenceLookupDefaultLicense);
    }

    public void setJavaFXReferenceLookupDefaultLicense(DefaultLicenseCFReferenceEditor value) {
        javafxReferenceLookupDefaultLicense = 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 ExtendCFCoreCFLabel getJavaFXLabelExtendCFCore() {
        if (javafxLabelExtendCFCore == null) {
            javafxLabelExtendCFCore = new ExtendCFCoreCFLabel();
        }
        return (javafxLabelExtendCFCore);
    }

    public void setJavaFXLabelExtendCFCore(ExtendCFCoreCFLabel value) {
        javafxLabelExtendCFCore = value;
    }

    public ExtendCFCoreEditor getJavaFXEditorExtendCFCore() {
        if (javafxEditorExtendCFCore == null) {
            javafxEditorExtendCFCore = new ExtendCFCoreEditor();
        }
        return (javafxEditorExtendCFCore);
    }

    public void setJavaFXEditorExtendCFCore(ExtendCFCoreEditor value) {
        javafxEditorExtendCFCore = value;
    }

    public CopyrightPeriodCFLabel getJavaFXLabelCopyrightPeriod() {
        if (javafxLabelCopyrightPeriod == null) {
            javafxLabelCopyrightPeriod = new CopyrightPeriodCFLabel();
        }
        return (javafxLabelCopyrightPeriod);
    }

    public void setJavaFXLabelCopyrightPeriod(CopyrightPeriodCFLabel value) {
        javafxLabelCopyrightPeriod = value;
    }

    public CopyrightPeriodEditor getJavaFXEditorCopyrightPeriod() {
        if (javafxEditorCopyrightPeriod == null) {
            javafxEditorCopyrightPeriod = new CopyrightPeriodEditor();
        }
        return (javafxEditorCopyrightPeriod);
    }

    public void setJavaFXEditorCopyrightPeriod(CopyrightPeriodEditor value) {
        javafxEditorCopyrightPeriod = value;
    }

    public CopyrightHolderCFLabel getJavaFXLabelCopyrightHolder() {
        if (javafxLabelCopyrightHolder == null) {
            javafxLabelCopyrightHolder = new CopyrightHolderCFLabel();
        }
        return (javafxLabelCopyrightHolder);
    }

    public void setJavaFXLabelCopyrightHolder(CopyrightHolderCFLabel value) {
        javafxLabelCopyrightHolder = value;
    }

    public CopyrightHolderEditor getJavaFXEditorCopyrightHolder() {
        if (javafxEditorCopyrightHolder == null) {
            javafxEditorCopyrightHolder = new CopyrightHolderEditor();
        }
        return (javafxEditorCopyrightHolder);
    }

    public void setJavaFXEditorCopyrightHolder(CopyrightHolderEditor value) {
        javafxEditorCopyrightHolder = value;
    }

    public PublishURICFLabel getJavaFXLabelPublishURI() {
        if (javafxLabelPublishURI == null) {
            javafxLabelPublishURI = new PublishURICFLabel();
        }
        return (javafxLabelPublishURI);
    }

    public void setJavaFXLabelPublishURI(PublishURICFLabel value) {
        javafxLabelPublishURI = value;
    }

    public PublishURIEditor getJavaFXEditorPublishURI() {
        if (javafxEditorPublishURI == null) {
            javafxEditorPublishURI = new PublishURIEditor();
        }
        return (javafxEditorPublishURI);
    }

    public void setJavaFXEditorPublishURI(PublishURIEditor value) {
        javafxEditorPublishURI = value;
    }

    public JSchemaObjImportCFLabel getJavaFXLabelJSchemaObjImport() {
        if (javafxLabelJSchemaObjImport == null) {
            javafxLabelJSchemaObjImport = new JSchemaObjImportCFLabel();
        }
        return (javafxLabelJSchemaObjImport);
    }

    public void setJavaFXLabelJSchemaObjImport(JSchemaObjImportCFLabel value) {
        javafxLabelJSchemaObjImport = value;
    }

    public JSchemaObjImportEditor getJavaFXEditorJSchemaObjImport() {
        if (javafxEditorJSchemaObjImport == null) {
            javafxEditorJSchemaObjImport = new JSchemaObjImportEditor();
        }
        return (javafxEditorJSchemaObjImport);
    }

    public void setJavaFXEditorJSchemaObjImport(JSchemaObjImportEditor value) {
        javafxEditorJSchemaObjImport = value;
    }

    public JSchemaObjInterfaceCFLabel getJavaFXLabelJSchemaObjInterface() {
        if (javafxLabelJSchemaObjInterface == null) {
            javafxLabelJSchemaObjInterface = new JSchemaObjInterfaceCFLabel();
        }
        return (javafxLabelJSchemaObjInterface);
    }

    public void setJavaFXLabelJSchemaObjInterface(JSchemaObjInterfaceCFLabel value) {
        javafxLabelJSchemaObjInterface = value;
    }

    public JSchemaObjInterfaceEditor getJavaFXEditorJSchemaObjInterface() {
        if (javafxEditorJSchemaObjInterface == null) {
            javafxEditorJSchemaObjInterface = new JSchemaObjInterfaceEditor();
        }
        return (javafxEditorJSchemaObjInterface);
    }

    public void setJavaFXEditorJSchemaObjInterface(JSchemaObjInterfaceEditor value) {
        javafxEditorJSchemaObjInterface = value;
    }

    public JSchemaObjMembersCFLabel getJavaFXLabelJSchemaObjMembers() {
        if (javafxLabelJSchemaObjMembers == null) {
            javafxLabelJSchemaObjMembers = new JSchemaObjMembersCFLabel();
        }
        return (javafxLabelJSchemaObjMembers);
    }

    public void setJavaFXLabelJSchemaObjMembers(JSchemaObjMembersCFLabel value) {
        javafxLabelJSchemaObjMembers = value;
    }

    public JSchemaObjMembersEditor getJavaFXEditorJSchemaObjMembers() {
        if (javafxEditorJSchemaObjMembers == null) {
            javafxEditorJSchemaObjMembers = new JSchemaObjMembersEditor();
        }
        return (javafxEditorJSchemaObjMembers);
    }

    public void setJavaFXEditorJSchemaObjMembers(JSchemaObjMembersEditor value) {
        javafxEditorJSchemaObjMembers = value;
    }

    public JSchemaObjImplementationCFLabel getJavaFXLabelJSchemaObjImplementation() {
        if (javafxLabelJSchemaObjImplementation == null) {
            javafxLabelJSchemaObjImplementation = new JSchemaObjImplementationCFLabel();
        }
        return (javafxLabelJSchemaObjImplementation);
    }

    public void setJavaFXLabelJSchemaObjImplementation(JSchemaObjImplementationCFLabel value) {
        javafxLabelJSchemaObjImplementation = value;
    }

    public JSchemaObjImplementationEditor getJavaFXEditorJSchemaObjImplementation() {
        if (javafxEditorJSchemaObjImplementation == null) {
            javafxEditorJSchemaObjImplementation = new JSchemaObjImplementationEditor();
        }
        return (javafxEditorJSchemaObjImplementation);
    }

    public void setJavaFXEditorJSchemaObjImplementation(JSchemaObjImplementationEditor value) {
        javafxEditorJSchemaObjImplementation = value;
    }

    public JDb2LUWSchemaObjMembersCFLabel getJavaFXLabelJDb2LUWSchemaObjMembers() {
        if (javafxLabelJDb2LUWSchemaObjMembers == null) {
            javafxLabelJDb2LUWSchemaObjMembers = new JDb2LUWSchemaObjMembersCFLabel();
        }
        return (javafxLabelJDb2LUWSchemaObjMembers);
    }

    public void setJavaFXLabelJDb2LUWSchemaObjMembers(JDb2LUWSchemaObjMembersCFLabel value) {
        javafxLabelJDb2LUWSchemaObjMembers = value;
    }

    public JDb2LUWSchemaObjMembersEditor getJavaFXEditorJDb2LUWSchemaObjMembers() {
        if (javafxEditorJDb2LUWSchemaObjMembers == null) {
            javafxEditorJDb2LUWSchemaObjMembers = new JDb2LUWSchemaObjMembersEditor();
        }
        return (javafxEditorJDb2LUWSchemaObjMembers);
    }

    public void setJavaFXEditorJDb2LUWSchemaObjMembers(JDb2LUWSchemaObjMembersEditor value) {
        javafxEditorJDb2LUWSchemaObjMembers = value;
    }

    public JDb2LUWSchemaObjImplCFLabel getJavaFXLabelJDb2LUWSchemaObjImpl() {
        if (javafxLabelJDb2LUWSchemaObjImpl == null) {
            javafxLabelJDb2LUWSchemaObjImpl = new JDb2LUWSchemaObjImplCFLabel();
        }
        return (javafxLabelJDb2LUWSchemaObjImpl);
    }

    public void setJavaFXLabelJDb2LUWSchemaObjImpl(JDb2LUWSchemaObjImplCFLabel value) {
        javafxLabelJDb2LUWSchemaObjImpl = value;
    }

    public JDb2LUWSchemaObjImplEditor getJavaFXEditorJDb2LUWSchemaObjImpl() {
        if (javafxEditorJDb2LUWSchemaObjImpl == null) {
            javafxEditorJDb2LUWSchemaObjImpl = new JDb2LUWSchemaObjImplEditor();
        }
        return (javafxEditorJDb2LUWSchemaObjImpl);
    }

    public void setJavaFXEditorJDb2LUWSchemaObjImpl(JDb2LUWSchemaObjImplEditor value) {
        javafxEditorJDb2LUWSchemaObjImpl = value;
    }

    public JDb2LUWSchemaObjImportCFLabel getJavaFXLabelJDb2LUWSchemaObjImport() {
        if (javafxLabelJDb2LUWSchemaObjImport == null) {
            javafxLabelJDb2LUWSchemaObjImport = new JDb2LUWSchemaObjImportCFLabel();
        }
        return (javafxLabelJDb2LUWSchemaObjImport);
    }

    public void setJavaFXLabelJDb2LUWSchemaObjImport(JDb2LUWSchemaObjImportCFLabel value) {
        javafxLabelJDb2LUWSchemaObjImport = value;
    }

    public JDb2LUWSchemaObjImportEditor getJavaFXEditorJDb2LUWSchemaObjImport() {
        if (javafxEditorJDb2LUWSchemaObjImport == null) {
            javafxEditorJDb2LUWSchemaObjImport = new JDb2LUWSchemaObjImportEditor();
        }
        return (javafxEditorJDb2LUWSchemaObjImport);
    }

    public void setJavaFXEditorJDb2LUWSchemaObjImport(JDb2LUWSchemaObjImportEditor value) {
        javafxEditorJDb2LUWSchemaObjImport = value;
    }

    public JMSSqlSchemaObjMembersCFLabel getJavaFXLabelJMSSqlSchemaObjMembers() {
        if (javafxLabelJMSSqlSchemaObjMembers == null) {
            javafxLabelJMSSqlSchemaObjMembers = new JMSSqlSchemaObjMembersCFLabel();
        }
        return (javafxLabelJMSSqlSchemaObjMembers);
    }

    public void setJavaFXLabelJMSSqlSchemaObjMembers(JMSSqlSchemaObjMembersCFLabel value) {
        javafxLabelJMSSqlSchemaObjMembers = value;
    }

    public JMSSqlSchemaObjMembersEditor getJavaFXEditorJMSSqlSchemaObjMembers() {
        if (javafxEditorJMSSqlSchemaObjMembers == null) {
            javafxEditorJMSSqlSchemaObjMembers = new JMSSqlSchemaObjMembersEditor();
        }
        return (javafxEditorJMSSqlSchemaObjMembers);
    }

    public void setJavaFXEditorJMSSqlSchemaObjMembers(JMSSqlSchemaObjMembersEditor value) {
        javafxEditorJMSSqlSchemaObjMembers = value;
    }

    public JMSSqlSchemaObjImplCFLabel getJavaFXLabelJMSSqlSchemaObjImpl() {
        if (javafxLabelJMSSqlSchemaObjImpl == null) {
            javafxLabelJMSSqlSchemaObjImpl = new JMSSqlSchemaObjImplCFLabel();
        }
        return (javafxLabelJMSSqlSchemaObjImpl);
    }

    public void setJavaFXLabelJMSSqlSchemaObjImpl(JMSSqlSchemaObjImplCFLabel value) {
        javafxLabelJMSSqlSchemaObjImpl = value;
    }

    public JMSSqlSchemaObjImplEditor getJavaFXEditorJMSSqlSchemaObjImpl() {
        if (javafxEditorJMSSqlSchemaObjImpl == null) {
            javafxEditorJMSSqlSchemaObjImpl = new JMSSqlSchemaObjImplEditor();
        }
        return (javafxEditorJMSSqlSchemaObjImpl);
    }

    public void setJavaFXEditorJMSSqlSchemaObjImpl(JMSSqlSchemaObjImplEditor value) {
        javafxEditorJMSSqlSchemaObjImpl = value;
    }

    public JMSSqlSchemaObjImportCFLabel getJavaFXLabelJMSSqlSchemaObjImport() {
        if (javafxLabelJMSSqlSchemaObjImport == null) {
            javafxLabelJMSSqlSchemaObjImport = new JMSSqlSchemaObjImportCFLabel();
        }
        return (javafxLabelJMSSqlSchemaObjImport);
    }

    public void setJavaFXLabelJMSSqlSchemaObjImport(JMSSqlSchemaObjImportCFLabel value) {
        javafxLabelJMSSqlSchemaObjImport = value;
    }

    public JMSSqlSchemaObjImportEditor getJavaFXEditorJMSSqlSchemaObjImport() {
        if (javafxEditorJMSSqlSchemaObjImport == null) {
            javafxEditorJMSSqlSchemaObjImport = new JMSSqlSchemaObjImportEditor();
        }
        return (javafxEditorJMSSqlSchemaObjImport);
    }

    public void setJavaFXEditorJMSSqlSchemaObjImport(JMSSqlSchemaObjImportEditor value) {
        javafxEditorJMSSqlSchemaObjImport = value;
    }

    public JMySqlSchemaObjMembersCFLabel getJavaFXLabelJMySqlSchemaObjMembers() {
        if (javafxLabelJMySqlSchemaObjMembers == null) {
            javafxLabelJMySqlSchemaObjMembers = new JMySqlSchemaObjMembersCFLabel();
        }
        return (javafxLabelJMySqlSchemaObjMembers);
    }

    public void setJavaFXLabelJMySqlSchemaObjMembers(JMySqlSchemaObjMembersCFLabel value) {
        javafxLabelJMySqlSchemaObjMembers = value;
    }

    public JMySqlSchemaObjMembersEditor getJavaFXEditorJMySqlSchemaObjMembers() {
        if (javafxEditorJMySqlSchemaObjMembers == null) {
            javafxEditorJMySqlSchemaObjMembers = new JMySqlSchemaObjMembersEditor();
        }
        return (javafxEditorJMySqlSchemaObjMembers);
    }

    public void setJavaFXEditorJMySqlSchemaObjMembers(JMySqlSchemaObjMembersEditor value) {
        javafxEditorJMySqlSchemaObjMembers = value;
    }

    public JMySqlSchemaObjImplCFLabel getJavaFXLabelJMySqlSchemaObjImpl() {
        if (javafxLabelJMySqlSchemaObjImpl == null) {
            javafxLabelJMySqlSchemaObjImpl = new JMySqlSchemaObjImplCFLabel();
        }
        return (javafxLabelJMySqlSchemaObjImpl);
    }

    public void setJavaFXLabelJMySqlSchemaObjImpl(JMySqlSchemaObjImplCFLabel value) {
        javafxLabelJMySqlSchemaObjImpl = value;
    }

    public JMySqlSchemaObjImplEditor getJavaFXEditorJMySqlSchemaObjImpl() {
        if (javafxEditorJMySqlSchemaObjImpl == null) {
            javafxEditorJMySqlSchemaObjImpl = new JMySqlSchemaObjImplEditor();
        }
        return (javafxEditorJMySqlSchemaObjImpl);
    }

    public void setJavaFXEditorJMySqlSchemaObjImpl(JMySqlSchemaObjImplEditor value) {
        javafxEditorJMySqlSchemaObjImpl = value;
    }

    public JMySqlSchemaObjImportCFLabel getJavaFXLabelJMySqlSchemaObjImport() {
        if (javafxLabelJMySqlSchemaObjImport == null) {
            javafxLabelJMySqlSchemaObjImport = new JMySqlSchemaObjImportCFLabel();
        }
        return (javafxLabelJMySqlSchemaObjImport);
    }

    public void setJavaFXLabelJMySqlSchemaObjImport(JMySqlSchemaObjImportCFLabel value) {
        javafxLabelJMySqlSchemaObjImport = value;
    }

    public JMySqlSchemaObjImportEditor getJavaFXEditorJMySqlSchemaObjImport() {
        if (javafxEditorJMySqlSchemaObjImport == null) {
            javafxEditorJMySqlSchemaObjImport = new JMySqlSchemaObjImportEditor();
        }
        return (javafxEditorJMySqlSchemaObjImport);
    }

    public void setJavaFXEditorJMySqlSchemaObjImport(JMySqlSchemaObjImportEditor value) {
        javafxEditorJMySqlSchemaObjImport = value;
    }

    public JOracleSchemaObjMembersCFLabel getJavaFXLabelJOracleSchemaObjMembers() {
        if (javafxLabelJOracleSchemaObjMembers == null) {
            javafxLabelJOracleSchemaObjMembers = new JOracleSchemaObjMembersCFLabel();
        }
        return (javafxLabelJOracleSchemaObjMembers);
    }

    public void setJavaFXLabelJOracleSchemaObjMembers(JOracleSchemaObjMembersCFLabel value) {
        javafxLabelJOracleSchemaObjMembers = value;
    }

    public JOracleSchemaObjMembersEditor getJavaFXEditorJOracleSchemaObjMembers() {
        if (javafxEditorJOracleSchemaObjMembers == null) {
            javafxEditorJOracleSchemaObjMembers = new JOracleSchemaObjMembersEditor();
        }
        return (javafxEditorJOracleSchemaObjMembers);
    }

    public void setJavaFXEditorJOracleSchemaObjMembers(JOracleSchemaObjMembersEditor value) {
        javafxEditorJOracleSchemaObjMembers = value;
    }

    public JOracleSchemaObjImplCFLabel getJavaFXLabelJOracleSchemaObjImpl() {
        if (javafxLabelJOracleSchemaObjImpl == null) {
            javafxLabelJOracleSchemaObjImpl = new JOracleSchemaObjImplCFLabel();
        }
        return (javafxLabelJOracleSchemaObjImpl);
    }

    public void setJavaFXLabelJOracleSchemaObjImpl(JOracleSchemaObjImplCFLabel value) {
        javafxLabelJOracleSchemaObjImpl = value;
    }

    public JOracleSchemaObjImplEditor getJavaFXEditorJOracleSchemaObjImpl() {
        if (javafxEditorJOracleSchemaObjImpl == null) {
            javafxEditorJOracleSchemaObjImpl = new JOracleSchemaObjImplEditor();
        }
        return (javafxEditorJOracleSchemaObjImpl);
    }

    public void setJavaFXEditorJOracleSchemaObjImpl(JOracleSchemaObjImplEditor value) {
        javafxEditorJOracleSchemaObjImpl = value;
    }

    public JOracleSchemaObjImportCFLabel getJavaFXLabelJOracleSchemaObjImport() {
        if (javafxLabelJOracleSchemaObjImport == null) {
            javafxLabelJOracleSchemaObjImport = new JOracleSchemaObjImportCFLabel();
        }
        return (javafxLabelJOracleSchemaObjImport);
    }

    public void setJavaFXLabelJOracleSchemaObjImport(JOracleSchemaObjImportCFLabel value) {
        javafxLabelJOracleSchemaObjImport = value;
    }

    public JOracleSchemaObjImportEditor getJavaFXEditorJOracleSchemaObjImport() {
        if (javafxEditorJOracleSchemaObjImport == null) {
            javafxEditorJOracleSchemaObjImport = new JOracleSchemaObjImportEditor();
        }
        return (javafxEditorJOracleSchemaObjImport);
    }

    public void setJavaFXEditorJOracleSchemaObjImport(JOracleSchemaObjImportEditor value) {
        javafxEditorJOracleSchemaObjImport = value;
    }

    public JPgSqlSchemaObjMembersCFLabel getJavaFXLabelJPgSqlSchemaObjMembers() {
        if (javafxLabelJPgSqlSchemaObjMembers == null) {
            javafxLabelJPgSqlSchemaObjMembers = new JPgSqlSchemaObjMembersCFLabel();
        }
        return (javafxLabelJPgSqlSchemaObjMembers);
    }

    public void setJavaFXLabelJPgSqlSchemaObjMembers(JPgSqlSchemaObjMembersCFLabel value) {
        javafxLabelJPgSqlSchemaObjMembers = value;
    }

    public JPgSqlSchemaObjMembersEditor getJavaFXEditorJPgSqlSchemaObjMembers() {
        if (javafxEditorJPgSqlSchemaObjMembers == null) {
            javafxEditorJPgSqlSchemaObjMembers = new JPgSqlSchemaObjMembersEditor();
        }
        return (javafxEditorJPgSqlSchemaObjMembers);
    }

    public void setJavaFXEditorJPgSqlSchemaObjMembers(JPgSqlSchemaObjMembersEditor value) {
        javafxEditorJPgSqlSchemaObjMembers = value;
    }

    public JPgSqlSchemaObjImplCFLabel getJavaFXLabelJPgSqlSchemaObjImpl() {
        if (javafxLabelJPgSqlSchemaObjImpl == null) {
            javafxLabelJPgSqlSchemaObjImpl = new JPgSqlSchemaObjImplCFLabel();
        }
        return (javafxLabelJPgSqlSchemaObjImpl);
    }

    public void setJavaFXLabelJPgSqlSchemaObjImpl(JPgSqlSchemaObjImplCFLabel value) {
        javafxLabelJPgSqlSchemaObjImpl = value;
    }

    public JPgSqlSchemaObjImplEditor getJavaFXEditorJPgSqlSchemaObjImpl() {
        if (javafxEditorJPgSqlSchemaObjImpl == null) {
            javafxEditorJPgSqlSchemaObjImpl = new JPgSqlSchemaObjImplEditor();
        }
        return (javafxEditorJPgSqlSchemaObjImpl);
    }

    public void setJavaFXEditorJPgSqlSchemaObjImpl(JPgSqlSchemaObjImplEditor value) {
        javafxEditorJPgSqlSchemaObjImpl = value;
    }

    public JPgSqlSchemaObjImportCFLabel getJavaFXLabelJPgSqlSchemaObjImport() {
        if (javafxLabelJPgSqlSchemaObjImport == null) {
            javafxLabelJPgSqlSchemaObjImport = new JPgSqlSchemaObjImportCFLabel();
        }
        return (javafxLabelJPgSqlSchemaObjImport);
    }

    public void setJavaFXLabelJPgSqlSchemaObjImport(JPgSqlSchemaObjImportCFLabel value) {
        javafxLabelJPgSqlSchemaObjImport = value;
    }

    public JPgSqlSchemaObjImportEditor getJavaFXEditorJPgSqlSchemaObjImport() {
        if (javafxEditorJPgSqlSchemaObjImport == null) {
            javafxEditorJPgSqlSchemaObjImport = new JPgSqlSchemaObjImportEditor();
        }
        return (javafxEditorJPgSqlSchemaObjImport);
    }

    public void setJavaFXEditorJPgSqlSchemaObjImport(JPgSqlSchemaObjImportEditor value) {
        javafxEditorJPgSqlSchemaObjImport = value;
    }

    public JSybaseSchemaObjMembersCFLabel getJavaFXLabelJSybaseSchemaObjMembers() {
        if (javafxLabelJSybaseSchemaObjMembers == null) {
            javafxLabelJSybaseSchemaObjMembers = new JSybaseSchemaObjMembersCFLabel();
        }
        return (javafxLabelJSybaseSchemaObjMembers);
    }

    public void setJavaFXLabelJSybaseSchemaObjMembers(JSybaseSchemaObjMembersCFLabel value) {
        javafxLabelJSybaseSchemaObjMembers = value;
    }

    public JSybaseSchemaObjMembersEditor getJavaFXEditorJSybaseSchemaObjMembers() {
        if (javafxEditorJSybaseSchemaObjMembers == null) {
            javafxEditorJSybaseSchemaObjMembers = new JSybaseSchemaObjMembersEditor();
        }
        return (javafxEditorJSybaseSchemaObjMembers);
    }

    public void setJavaFXEditorJSybaseSchemaObjMembers(JSybaseSchemaObjMembersEditor value) {
        javafxEditorJSybaseSchemaObjMembers = value;
    }

    public JSybaseSchemaObjImplCFLabel getJavaFXLabelJSybaseSchemaObjImpl() {
        if (javafxLabelJSybaseSchemaObjImpl == null) {
            javafxLabelJSybaseSchemaObjImpl = new JSybaseSchemaObjImplCFLabel();
        }
        return (javafxLabelJSybaseSchemaObjImpl);
    }

    public void setJavaFXLabelJSybaseSchemaObjImpl(JSybaseSchemaObjImplCFLabel value) {
        javafxLabelJSybaseSchemaObjImpl = value;
    }

    public JSybaseSchemaObjImplEditor getJavaFXEditorJSybaseSchemaObjImpl() {
        if (javafxEditorJSybaseSchemaObjImpl == null) {
            javafxEditorJSybaseSchemaObjImpl = new JSybaseSchemaObjImplEditor();
        }
        return (javafxEditorJSybaseSchemaObjImpl);
    }

    public void setJavaFXEditorJSybaseSchemaObjImpl(JSybaseSchemaObjImplEditor value) {
        javafxEditorJSybaseSchemaObjImpl = value;
    }

    public JSybaseSchemaObjImportCFLabel getJavaFXLabelJSybaseSchemaObjImport() {
        if (javafxLabelJSybaseSchemaObjImport == null) {
            javafxLabelJSybaseSchemaObjImport = new JSybaseSchemaObjImportCFLabel();
        }
        return (javafxLabelJSybaseSchemaObjImport);
    }

    public void setJavaFXLabelJSybaseSchemaObjImport(JSybaseSchemaObjImportCFLabel value) {
        javafxLabelJSybaseSchemaObjImport = value;
    }

    public JSybaseSchemaObjImportEditor getJavaFXEditorJSybaseSchemaObjImport() {
        if (javafxEditorJSybaseSchemaObjImport == null) {
            javafxEditorJSybaseSchemaObjImport = new JSybaseSchemaObjImportEditor();
        }
        return (javafxEditorJSybaseSchemaObjImport);
    }

    public void setJavaFXEditorJSybaseSchemaObjImport(JSybaseSchemaObjImportEditor value) {
        javafxEditorJSybaseSchemaObjImport = value;
    }

    public JRamSchemaObjMembersCFLabel getJavaFXLabelJRamSchemaObjMembers() {
        if (javafxLabelJRamSchemaObjMembers == null) {
            javafxLabelJRamSchemaObjMembers = new JRamSchemaObjMembersCFLabel();
        }
        return (javafxLabelJRamSchemaObjMembers);
    }

    public void setJavaFXLabelJRamSchemaObjMembers(JRamSchemaObjMembersCFLabel value) {
        javafxLabelJRamSchemaObjMembers = value;
    }

    public JRamSchemaObjMembersEditor getJavaFXEditorJRamSchemaObjMembers() {
        if (javafxEditorJRamSchemaObjMembers == null) {
            javafxEditorJRamSchemaObjMembers = new JRamSchemaObjMembersEditor();
        }
        return (javafxEditorJRamSchemaObjMembers);
    }

    public void setJavaFXEditorJRamSchemaObjMembers(JRamSchemaObjMembersEditor value) {
        javafxEditorJRamSchemaObjMembers = value;
    }

    public JRamSchemaObjImplCFLabel getJavaFXLabelJRamSchemaObjImpl() {
        if (javafxLabelJRamSchemaObjImpl == null) {
            javafxLabelJRamSchemaObjImpl = new JRamSchemaObjImplCFLabel();
        }
        return (javafxLabelJRamSchemaObjImpl);
    }

    public void setJavaFXLabelJRamSchemaObjImpl(JRamSchemaObjImplCFLabel value) {
        javafxLabelJRamSchemaObjImpl = value;
    }

    public JRamSchemaObjImplEditor getJavaFXEditorJRamSchemaObjImpl() {
        if (javafxEditorJRamSchemaObjImpl == null) {
            javafxEditorJRamSchemaObjImpl = new JRamSchemaObjImplEditor();
        }
        return (javafxEditorJRamSchemaObjImpl);
    }

    public void setJavaFXEditorJRamSchemaObjImpl(JRamSchemaObjImplEditor value) {
        javafxEditorJRamSchemaObjImpl = value;
    }

    public JRamSchemaObjImportCFLabel getJavaFXLabelJRamSchemaObjImport() {
        if (javafxLabelJRamSchemaObjImport == null) {
            javafxLabelJRamSchemaObjImport = new JRamSchemaObjImportCFLabel();
        }
        return (javafxLabelJRamSchemaObjImport);
    }

    public void setJavaFXLabelJRamSchemaObjImport(JRamSchemaObjImportCFLabel value) {
        javafxLabelJRamSchemaObjImport = value;
    }

    public JRamSchemaObjImportEditor getJavaFXEditorJRamSchemaObjImport() {
        if (javafxEditorJRamSchemaObjImport == null) {
            javafxEditorJRamSchemaObjImport = new JRamSchemaObjImportEditor();
        }
        return (javafxEditorJRamSchemaObjImport);
    }

    public void setJavaFXEditorJRamSchemaObjImport(JRamSchemaObjImportEditor value) {
        javafxEditorJRamSchemaObjImport = value;
    }

    public JXMsgSchemaImportCFLabel getJavaFXLabelJXMsgSchemaImport() {
        if (javafxLabelJXMsgSchemaImport == null) {
            javafxLabelJXMsgSchemaImport = new JXMsgSchemaImportCFLabel();
        }
        return (javafxLabelJXMsgSchemaImport);
    }

    public void setJavaFXLabelJXMsgSchemaImport(JXMsgSchemaImportCFLabel value) {
        javafxLabelJXMsgSchemaImport = value;
    }

    public JXMsgSchemaImportEditor getJavaFXEditorJXMsgSchemaImport() {
        if (javafxEditorJXMsgSchemaImport == null) {
            javafxEditorJXMsgSchemaImport = new JXMsgSchemaImportEditor();
        }
        return (javafxEditorJXMsgSchemaImport);
    }

    public void setJavaFXEditorJXMsgSchemaImport(JXMsgSchemaImportEditor value) {
        javafxEditorJXMsgSchemaImport = value;
    }

    public JXMsgSchemaFormattersCFLabel getJavaFXLabelJXMsgSchemaFormatters() {
        if (javafxLabelJXMsgSchemaFormatters == null) {
            javafxLabelJXMsgSchemaFormatters = new JXMsgSchemaFormattersCFLabel();
        }
        return (javafxLabelJXMsgSchemaFormatters);
    }

    public void setJavaFXLabelJXMsgSchemaFormatters(JXMsgSchemaFormattersCFLabel value) {
        javafxLabelJXMsgSchemaFormatters = value;
    }

    public JXMsgSchemaFormattersEditor getJavaFXEditorJXMsgSchemaFormatters() {
        if (javafxEditorJXMsgSchemaFormatters == null) {
            javafxEditorJXMsgSchemaFormatters = new JXMsgSchemaFormattersEditor();
        }
        return (javafxEditorJXMsgSchemaFormatters);
    }

    public void setJavaFXEditorJXMsgSchemaFormatters(JXMsgSchemaFormattersEditor value) {
        javafxEditorJXMsgSchemaFormatters = value;
    }

    public JXMsgClientSchemaImportCFLabel getJavaFXLabelJXMsgClientSchemaImport() {
        if (javafxLabelJXMsgClientSchemaImport == null) {
            javafxLabelJXMsgClientSchemaImport = new JXMsgClientSchemaImportCFLabel();
        }
        return (javafxLabelJXMsgClientSchemaImport);
    }

    public void setJavaFXLabelJXMsgClientSchemaImport(JXMsgClientSchemaImportCFLabel value) {
        javafxLabelJXMsgClientSchemaImport = value;
    }

    public JXMsgClientSchemaImportEditor getJavaFXEditorJXMsgClientSchemaImport() {
        if (javafxEditorJXMsgClientSchemaImport == null) {
            javafxEditorJXMsgClientSchemaImport = new JXMsgClientSchemaImportEditor();
        }
        return (javafxEditorJXMsgClientSchemaImport);
    }

    public void setJavaFXEditorJXMsgClientSchemaImport(JXMsgClientSchemaImportEditor value) {
        javafxEditorJXMsgClientSchemaImport = value;
    }

    public JXMsgClientSchemaBodyCFLabel getJavaFXLabelJXMsgClientSchemaBody() {
        if (javafxLabelJXMsgClientSchemaBody == null) {
            javafxLabelJXMsgClientSchemaBody = new JXMsgClientSchemaBodyCFLabel();
        }
        return (javafxLabelJXMsgClientSchemaBody);
    }

    public void setJavaFXLabelJXMsgClientSchemaBody(JXMsgClientSchemaBodyCFLabel value) {
        javafxLabelJXMsgClientSchemaBody = value;
    }

    public JXMsgClientSchemaBodyEditor getJavaFXEditorJXMsgClientSchemaBody() {
        if (javafxEditorJXMsgClientSchemaBody == null) {
            javafxEditorJXMsgClientSchemaBody = new JXMsgClientSchemaBodyEditor();
        }
        return (javafxEditorJXMsgClientSchemaBody);
    }

    public void setJavaFXEditorJXMsgClientSchemaBody(JXMsgClientSchemaBodyEditor value) {
        javafxEditorJXMsgClientSchemaBody = value;
    }

    public JXMsgRqstSchemaBodyCFLabel getJavaFXLabelJXMsgRqstSchemaBody() {
        if (javafxLabelJXMsgRqstSchemaBody == null) {
            javafxLabelJXMsgRqstSchemaBody = new JXMsgRqstSchemaBodyCFLabel();
        }
        return (javafxLabelJXMsgRqstSchemaBody);
    }

    public void setJavaFXLabelJXMsgRqstSchemaBody(JXMsgRqstSchemaBodyCFLabel value) {
        javafxLabelJXMsgRqstSchemaBody = value;
    }

    public JXMsgRqstSchemaBodyEditor getJavaFXEditorJXMsgRqstSchemaBody() {
        if (javafxEditorJXMsgRqstSchemaBody == null) {
            javafxEditorJXMsgRqstSchemaBody = new JXMsgRqstSchemaBodyEditor();
        }
        return (javafxEditorJXMsgRqstSchemaBody);
    }

    public void setJavaFXEditorJXMsgRqstSchemaBody(JXMsgRqstSchemaBodyEditor value) {
        javafxEditorJXMsgRqstSchemaBody = value;
    }

    public JXMsgRqstSchemaImportCFLabel getJavaFXLabelJXMsgRqstSchemaImport() {
        if (javafxLabelJXMsgRqstSchemaImport == null) {
            javafxLabelJXMsgRqstSchemaImport = new JXMsgRqstSchemaImportCFLabel();
        }
        return (javafxLabelJXMsgRqstSchemaImport);
    }

    public void setJavaFXLabelJXMsgRqstSchemaImport(JXMsgRqstSchemaImportCFLabel value) {
        javafxLabelJXMsgRqstSchemaImport = value;
    }

    public JXMsgRqstSchemaImportEditor getJavaFXEditorJXMsgRqstSchemaImport() {
        if (javafxEditorJXMsgRqstSchemaImport == null) {
            javafxEditorJXMsgRqstSchemaImport = new JXMsgRqstSchemaImportEditor();
        }
        return (javafxEditorJXMsgRqstSchemaImport);
    }

    public void setJavaFXEditorJXMsgRqstSchemaImport(JXMsgRqstSchemaImportEditor value) {
        javafxEditorJXMsgRqstSchemaImport = value;
    }

    public JXMsgRqstSchemaWireParsersCFLabel getJavaFXLabelJXMsgRqstSchemaWireParsers() {
        if (javafxLabelJXMsgRqstSchemaWireParsers == null) {
            javafxLabelJXMsgRqstSchemaWireParsers = new JXMsgRqstSchemaWireParsersCFLabel();
        }
        return (javafxLabelJXMsgRqstSchemaWireParsers);
    }

    public void setJavaFXLabelJXMsgRqstSchemaWireParsers(JXMsgRqstSchemaWireParsersCFLabel value) {
        javafxLabelJXMsgRqstSchemaWireParsers = value;
    }

    public JXMsgRqstSchemaWireParsersEditor getJavaFXEditorJXMsgRqstSchemaWireParsers() {
        if (javafxEditorJXMsgRqstSchemaWireParsers == null) {
            javafxEditorJXMsgRqstSchemaWireParsers = new JXMsgRqstSchemaWireParsersEditor();
        }
        return (javafxEditorJXMsgRqstSchemaWireParsers);
    }

    public void setJavaFXEditorJXMsgRqstSchemaWireParsers(JXMsgRqstSchemaWireParsersEditor value) {
        javafxEditorJXMsgRqstSchemaWireParsers = value;
    }

    public JXMsgRqstSchemaXsdSpecCFLabel getJavaFXLabelJXMsgRqstSchemaXsdSpec() {
        if (javafxLabelJXMsgRqstSchemaXsdSpec == null) {
            javafxLabelJXMsgRqstSchemaXsdSpec = new JXMsgRqstSchemaXsdSpecCFLabel();
        }
        return (javafxLabelJXMsgRqstSchemaXsdSpec);
    }

    public void setJavaFXLabelJXMsgRqstSchemaXsdSpec(JXMsgRqstSchemaXsdSpecCFLabel value) {
        javafxLabelJXMsgRqstSchemaXsdSpec = value;
    }

    public JXMsgRqstSchemaXsdSpecEditor getJavaFXEditorJXMsgRqstSchemaXsdSpec() {
        if (javafxEditorJXMsgRqstSchemaXsdSpec == null) {
            javafxEditorJXMsgRqstSchemaXsdSpec = new JXMsgRqstSchemaXsdSpecEditor();
        }
        return (javafxEditorJXMsgRqstSchemaXsdSpec);
    }

    public void setJavaFXEditorJXMsgRqstSchemaXsdSpec(JXMsgRqstSchemaXsdSpecEditor value) {
        javafxEditorJXMsgRqstSchemaXsdSpec = value;
    }

    public JXMsgRqstSchemaXsdElementListCFLabel getJavaFXLabelJXMsgRqstSchemaXsdElementList() {
        if (javafxLabelJXMsgRqstSchemaXsdElementList == null) {
            javafxLabelJXMsgRqstSchemaXsdElementList = new JXMsgRqstSchemaXsdElementListCFLabel();
        }
        return (javafxLabelJXMsgRqstSchemaXsdElementList);
    }

    public void setJavaFXLabelJXMsgRqstSchemaXsdElementList(JXMsgRqstSchemaXsdElementListCFLabel value) {
        javafxLabelJXMsgRqstSchemaXsdElementList = value;
    }

    public JXMsgRqstSchemaXsdElementListEditor getJavaFXEditorJXMsgRqstSchemaXsdElementList() {
        if (javafxEditorJXMsgRqstSchemaXsdElementList == null) {
            javafxEditorJXMsgRqstSchemaXsdElementList = new JXMsgRqstSchemaXsdElementListEditor();
        }
        return (javafxEditorJXMsgRqstSchemaXsdElementList);
    }

    public void setJavaFXEditorJXMsgRqstSchemaXsdElementList(JXMsgRqstSchemaXsdElementListEditor value) {
        javafxEditorJXMsgRqstSchemaXsdElementList = value;
    }

    public JXMsgRspnSchemaBodyCFLabel getJavaFXLabelJXMsgRspnSchemaBody() {
        if (javafxLabelJXMsgRspnSchemaBody == null) {
            javafxLabelJXMsgRspnSchemaBody = new JXMsgRspnSchemaBodyCFLabel();
        }
        return (javafxLabelJXMsgRspnSchemaBody);
    }

    public void setJavaFXLabelJXMsgRspnSchemaBody(JXMsgRspnSchemaBodyCFLabel value) {
        javafxLabelJXMsgRspnSchemaBody = value;
    }

    public JXMsgRspnSchemaBodyEditor getJavaFXEditorJXMsgRspnSchemaBody() {
        if (javafxEditorJXMsgRspnSchemaBody == null) {
            javafxEditorJXMsgRspnSchemaBody = new JXMsgRspnSchemaBodyEditor();
        }
        return (javafxEditorJXMsgRspnSchemaBody);
    }

    public void setJavaFXEditorJXMsgRspnSchemaBody(JXMsgRspnSchemaBodyEditor value) {
        javafxEditorJXMsgRspnSchemaBody = value;
    }

    public JXMsgRspnSchemaImportCFLabel getJavaFXLabelJXMsgRspnSchemaImport() {
        if (javafxLabelJXMsgRspnSchemaImport == null) {
            javafxLabelJXMsgRspnSchemaImport = new JXMsgRspnSchemaImportCFLabel();
        }
        return (javafxLabelJXMsgRspnSchemaImport);
    }

    public void setJavaFXLabelJXMsgRspnSchemaImport(JXMsgRspnSchemaImportCFLabel value) {
        javafxLabelJXMsgRspnSchemaImport = value;
    }

    public JXMsgRspnSchemaImportEditor getJavaFXEditorJXMsgRspnSchemaImport() {
        if (javafxEditorJXMsgRspnSchemaImport == null) {
            javafxEditorJXMsgRspnSchemaImport = new JXMsgRspnSchemaImportEditor();
        }
        return (javafxEditorJXMsgRspnSchemaImport);
    }

    public void setJavaFXEditorJXMsgRspnSchemaImport(JXMsgRspnSchemaImportEditor value) {
        javafxEditorJXMsgRspnSchemaImport = value;
    }

    public JXMsgRspnSchemaWireParsersCFLabel getJavaFXLabelJXMsgRspnSchemaWireParsers() {
        if (javafxLabelJXMsgRspnSchemaWireParsers == null) {
            javafxLabelJXMsgRspnSchemaWireParsers = new JXMsgRspnSchemaWireParsersCFLabel();
        }
        return (javafxLabelJXMsgRspnSchemaWireParsers);
    }

    public void setJavaFXLabelJXMsgRspnSchemaWireParsers(JXMsgRspnSchemaWireParsersCFLabel value) {
        javafxLabelJXMsgRspnSchemaWireParsers = value;
    }

    public JXMsgRspnSchemaWireParsersEditor getJavaFXEditorJXMsgRspnSchemaWireParsers() {
        if (javafxEditorJXMsgRspnSchemaWireParsers == null) {
            javafxEditorJXMsgRspnSchemaWireParsers = new JXMsgRspnSchemaWireParsersEditor();
        }
        return (javafxEditorJXMsgRspnSchemaWireParsers);
    }

    public void setJavaFXEditorJXMsgRspnSchemaWireParsers(JXMsgRspnSchemaWireParsersEditor value) {
        javafxEditorJXMsgRspnSchemaWireParsers = value;
    }

    public JXMsgRspnSchemaXsdElementListCFLabel getJavaFXLabelJXMsgRspnSchemaXsdElementList() {
        if (javafxLabelJXMsgRspnSchemaXsdElementList == null) {
            javafxLabelJXMsgRspnSchemaXsdElementList = new JXMsgRspnSchemaXsdElementListCFLabel();
        }
        return (javafxLabelJXMsgRspnSchemaXsdElementList);
    }

    public void setJavaFXLabelJXMsgRspnSchemaXsdElementList(JXMsgRspnSchemaXsdElementListCFLabel value) {
        javafxLabelJXMsgRspnSchemaXsdElementList = value;
    }

    public JXMsgRspnSchemaXsdElementListEditor getJavaFXEditorJXMsgRspnSchemaXsdElementList() {
        if (javafxEditorJXMsgRspnSchemaXsdElementList == null) {
            javafxEditorJXMsgRspnSchemaXsdElementList = new JXMsgRspnSchemaXsdElementListEditor();
        }
        return (javafxEditorJXMsgRspnSchemaXsdElementList);
    }

    public void setJavaFXEditorJXMsgRspnSchemaXsdElementList(JXMsgRspnSchemaXsdElementListEditor value) {
        javafxEditorJXMsgRspnSchemaXsdElementList = value;
    }

    public JXMsgRspnSchemaXsdSpecCFLabel getJavaFXLabelJXMsgRspnSchemaXsdSpec() {
        if (javafxLabelJXMsgRspnSchemaXsdSpec == null) {
            javafxLabelJXMsgRspnSchemaXsdSpec = new JXMsgRspnSchemaXsdSpecCFLabel();
        }
        return (javafxLabelJXMsgRspnSchemaXsdSpec);
    }

    public void setJavaFXLabelJXMsgRspnSchemaXsdSpec(JXMsgRspnSchemaXsdSpecCFLabel value) {
        javafxLabelJXMsgRspnSchemaXsdSpec = value;
    }

    public JXMsgRspnSchemaXsdSpecEditor getJavaFXEditorJXMsgRspnSchemaXsdSpec() {
        if (javafxEditorJXMsgRspnSchemaXsdSpec == null) {
            javafxEditorJXMsgRspnSchemaXsdSpec = new JXMsgRspnSchemaXsdSpecEditor();
        }
        return (javafxEditorJXMsgRspnSchemaXsdSpec);
    }

    public void setJavaFXEditorJXMsgRspnSchemaXsdSpec(JXMsgRspnSchemaXsdSpecEditor value) {
        javafxEditorJXMsgRspnSchemaXsdSpec = value;
    }

    public void populateFields() {
        ICFBamSchemaDefObj popObj;
        ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
        if (focus != null) {
            popObj = (ICFBamSchemaDefObj) (focus.getEdit());
            if (popObj == null) {
                popObj = focus;
            }
        } else {
            popObj = null;
        }
        if (getPaneMode() == CFPane.PaneMode.Unknown) {
            popObj = null;
        }
        if (popObj == null) {
            javafxLookupDefaultLicenseObj = null;
        } else {
            javafxLookupDefaultLicenseObj = (ICFInternetLicenseObj) popObj
                    .getOptionalLookupDefaultLicense(javafxIsInitializing);
        }
        if (javafxReferenceLookupDefaultLicense != null) {
            javafxReferenceLookupDefaultLicense.setReferencedObject(javafxLookupDefaultLicenseObj);
        }

        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) {
            getJavaFXEditorExtendCFCore().setBooleanValue(null);
        } else {
            getJavaFXEditorExtendCFCore().setBooleanValue(popObj.getRequiredExtendCFCore());
        }

        if (popObj == null) {
            getJavaFXEditorCopyrightPeriod().setStringValue(null);
        } else {
            getJavaFXEditorCopyrightPeriod().setStringValue(popObj.getRequiredCopyrightPeriod());
        }

        if (popObj == null) {
            getJavaFXEditorCopyrightHolder().setStringValue(null);
        } else {
            getJavaFXEditorCopyrightHolder().setStringValue(popObj.getRequiredCopyrightHolder());
        }

        if (popObj == null) {
            getJavaFXEditorPublishURI().setStringValue(null);
        } else {
            getJavaFXEditorPublishURI().setStringValue(popObj.getRequiredPublishURI());
        }

        if (popObj == null) {
            getJavaFXEditorJSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJSchemaObjImport().setTextValue(popObj.getOptionalJSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJSchemaObjInterface().setTextValue(null);
        } else {
            getJavaFXEditorJSchemaObjInterface().setTextValue(popObj.getOptionalJSchemaObjInterface());
        }

        if (popObj == null) {
            getJavaFXEditorJSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJSchemaObjMembers().setTextValue(popObj.getOptionalJSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJSchemaObjImplementation().setTextValue(null);
        } else {
            getJavaFXEditorJSchemaObjImplementation().setTextValue(popObj.getOptionalJSchemaObjImplementation());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWSchemaObjMembers().setTextValue(popObj.getOptionalJDb2LUWSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWSchemaObjImpl().setTextValue(popObj.getOptionalJDb2LUWSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJDb2LUWSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJDb2LUWSchemaObjImport().setTextValue(popObj.getOptionalJDb2LUWSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlSchemaObjMembers().setTextValue(popObj.getOptionalJMSSqlSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlSchemaObjImpl().setTextValue(popObj.getOptionalJMSSqlSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJMSSqlSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJMSSqlSchemaObjImport().setTextValue(popObj.getOptionalJMSSqlSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlSchemaObjMembers().setTextValue(popObj.getOptionalJMySqlSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlSchemaObjImpl().setTextValue(popObj.getOptionalJMySqlSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJMySqlSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJMySqlSchemaObjImport().setTextValue(popObj.getOptionalJMySqlSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJOracleSchemaObjMembers().setTextValue(popObj.getOptionalJOracleSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJOracleSchemaObjImpl().setTextValue(popObj.getOptionalJOracleSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJOracleSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJOracleSchemaObjImport().setTextValue(popObj.getOptionalJOracleSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlSchemaObjMembers().setTextValue(popObj.getOptionalJPgSqlSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlSchemaObjImpl().setTextValue(popObj.getOptionalJPgSqlSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJPgSqlSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJPgSqlSchemaObjImport().setTextValue(popObj.getOptionalJPgSqlSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseSchemaObjMembers().setTextValue(popObj.getOptionalJSybaseSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseSchemaObjImpl().setTextValue(popObj.getOptionalJSybaseSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJSybaseSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJSybaseSchemaObjImport().setTextValue(popObj.getOptionalJSybaseSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJRamSchemaObjMembers().setTextValue(null);
        } else {
            getJavaFXEditorJRamSchemaObjMembers().setTextValue(popObj.getOptionalJRamSchemaObjMembers());
        }

        if (popObj == null) {
            getJavaFXEditorJRamSchemaObjImpl().setTextValue(null);
        } else {
            getJavaFXEditorJRamSchemaObjImpl().setTextValue(popObj.getOptionalJRamSchemaObjImpl());
        }

        if (popObj == null) {
            getJavaFXEditorJRamSchemaObjImport().setTextValue(null);
        } else {
            getJavaFXEditorJRamSchemaObjImport().setTextValue(popObj.getOptionalJRamSchemaObjImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgSchemaImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgSchemaImport().setTextValue(popObj.getOptionalJXMsgSchemaImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgSchemaFormatters().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgSchemaFormatters().setTextValue(popObj.getOptionalJXMsgSchemaFormatters());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgClientSchemaImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgClientSchemaImport().setTextValue(popObj.getOptionalJXMsgClientSchemaImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgClientSchemaBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgClientSchemaBody().setTextValue(popObj.getOptionalJXMsgClientSchemaBody());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstSchemaBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstSchemaBody().setTextValue(popObj.getOptionalJXMsgRqstSchemaBody());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstSchemaImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstSchemaImport().setTextValue(popObj.getOptionalJXMsgRqstSchemaImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstSchemaWireParsers().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstSchemaWireParsers()
                    .setTextValue(popObj.getOptionalJXMsgRqstSchemaWireParsers());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstSchemaXsdSpec().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstSchemaXsdSpec().setTextValue(popObj.getOptionalJXMsgRqstSchemaXsdSpec());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRqstSchemaXsdElementList().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRqstSchemaXsdElementList()
                    .setTextValue(popObj.getOptionalJXMsgRqstSchemaXsdElementList());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnSchemaBody().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnSchemaBody().setTextValue(popObj.getOptionalJXMsgRspnSchemaBody());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnSchemaImport().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnSchemaImport().setTextValue(popObj.getOptionalJXMsgRspnSchemaImport());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnSchemaWireParsers().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnSchemaWireParsers()
                    .setTextValue(popObj.getOptionalJXMsgRspnSchemaWireParsers());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnSchemaXsdElementList().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnSchemaXsdElementList()
                    .setTextValue(popObj.getOptionalJXMsgRspnSchemaXsdElementList());
        }

        if (popObj == null) {
            getJavaFXEditorJXMsgRspnSchemaXsdSpec().setTextValue(null);
        } else {
            getJavaFXEditorJXMsgRspnSchemaXsdSpec().setTextValue(popObj.getOptionalJXMsgRspnSchemaXsdSpec());
        }
    }

    public void postFields() {
        final String S_ProcName = "postFields";
        ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
        ICFBamSchemaDefEditObj editObj;
        if (focus != null) {
            editObj = (ICFBamSchemaDefEditObj) (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");
        }

        javafxLookupDefaultLicenseObj = (ICFInternetLicenseObj) (javafxReferenceLookupDefaultLicense
                .getReferencedObject());
        editObj.setOptionalLookupDefaultLicense(javafxLookupDefaultLicenseObj);

        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.setRequiredExtendCFCore(getJavaFXEditorExtendCFCore().getBooleanValue());

        editObj.setRequiredCopyrightPeriod(getJavaFXEditorCopyrightPeriod().getStringValue());

        editObj.setRequiredCopyrightHolder(getJavaFXEditorCopyrightHolder().getStringValue());

        editObj.setRequiredPublishURI(getJavaFXEditorPublishURI().getStringValue());

        editObj.setOptionalJSchemaObjImport(getJavaFXEditorJSchemaObjImport().getTextValue());

        editObj.setOptionalJSchemaObjInterface(getJavaFXEditorJSchemaObjInterface().getTextValue());

        editObj.setOptionalJSchemaObjMembers(getJavaFXEditorJSchemaObjMembers().getTextValue());

        editObj.setOptionalJSchemaObjImplementation(getJavaFXEditorJSchemaObjImplementation().getTextValue());

        editObj.setOptionalJDb2LUWSchemaObjMembers(getJavaFXEditorJDb2LUWSchemaObjMembers().getTextValue());

        editObj.setOptionalJDb2LUWSchemaObjImpl(getJavaFXEditorJDb2LUWSchemaObjImpl().getTextValue());

        editObj.setOptionalJDb2LUWSchemaObjImport(getJavaFXEditorJDb2LUWSchemaObjImport().getTextValue());

        editObj.setOptionalJMSSqlSchemaObjMembers(getJavaFXEditorJMSSqlSchemaObjMembers().getTextValue());

        editObj.setOptionalJMSSqlSchemaObjImpl(getJavaFXEditorJMSSqlSchemaObjImpl().getTextValue());

        editObj.setOptionalJMSSqlSchemaObjImport(getJavaFXEditorJMSSqlSchemaObjImport().getTextValue());

        editObj.setOptionalJMySqlSchemaObjMembers(getJavaFXEditorJMySqlSchemaObjMembers().getTextValue());

        editObj.setOptionalJMySqlSchemaObjImpl(getJavaFXEditorJMySqlSchemaObjImpl().getTextValue());

        editObj.setOptionalJMySqlSchemaObjImport(getJavaFXEditorJMySqlSchemaObjImport().getTextValue());

        editObj.setOptionalJOracleSchemaObjMembers(getJavaFXEditorJOracleSchemaObjMembers().getTextValue());

        editObj.setOptionalJOracleSchemaObjImpl(getJavaFXEditorJOracleSchemaObjImpl().getTextValue());

        editObj.setOptionalJOracleSchemaObjImport(getJavaFXEditorJOracleSchemaObjImport().getTextValue());

        editObj.setOptionalJPgSqlSchemaObjMembers(getJavaFXEditorJPgSqlSchemaObjMembers().getTextValue());

        editObj.setOptionalJPgSqlSchemaObjImpl(getJavaFXEditorJPgSqlSchemaObjImpl().getTextValue());

        editObj.setOptionalJPgSqlSchemaObjImport(getJavaFXEditorJPgSqlSchemaObjImport().getTextValue());

        editObj.setOptionalJSybaseSchemaObjMembers(getJavaFXEditorJSybaseSchemaObjMembers().getTextValue());

        editObj.setOptionalJSybaseSchemaObjImpl(getJavaFXEditorJSybaseSchemaObjImpl().getTextValue());

        editObj.setOptionalJSybaseSchemaObjImport(getJavaFXEditorJSybaseSchemaObjImport().getTextValue());

        editObj.setOptionalJRamSchemaObjMembers(getJavaFXEditorJRamSchemaObjMembers().getTextValue());

        editObj.setOptionalJRamSchemaObjImpl(getJavaFXEditorJRamSchemaObjImpl().getTextValue());

        editObj.setOptionalJRamSchemaObjImport(getJavaFXEditorJRamSchemaObjImport().getTextValue());

        editObj.setOptionalJXMsgSchemaImport(getJavaFXEditorJXMsgSchemaImport().getTextValue());

        editObj.setOptionalJXMsgSchemaFormatters(getJavaFXEditorJXMsgSchemaFormatters().getTextValue());

        editObj.setOptionalJXMsgClientSchemaImport(getJavaFXEditorJXMsgClientSchemaImport().getTextValue());

        editObj.setOptionalJXMsgClientSchemaBody(getJavaFXEditorJXMsgClientSchemaBody().getTextValue());

        editObj.setOptionalJXMsgRqstSchemaBody(getJavaFXEditorJXMsgRqstSchemaBody().getTextValue());

        editObj.setOptionalJXMsgRqstSchemaImport(getJavaFXEditorJXMsgRqstSchemaImport().getTextValue());

        editObj.setOptionalJXMsgRqstSchemaWireParsers(getJavaFXEditorJXMsgRqstSchemaWireParsers().getTextValue());

        editObj.setOptionalJXMsgRqstSchemaXsdSpec(getJavaFXEditorJXMsgRqstSchemaXsdSpec().getTextValue());

        editObj.setOptionalJXMsgRqstSchemaXsdElementList(
                getJavaFXEditorJXMsgRqstSchemaXsdElementList().getTextValue());

        editObj.setOptionalJXMsgRspnSchemaBody(getJavaFXEditorJXMsgRspnSchemaBody().getTextValue());

        editObj.setOptionalJXMsgRspnSchemaImport(getJavaFXEditorJXMsgRspnSchemaImport().getTextValue());

        editObj.setOptionalJXMsgRspnSchemaWireParsers(getJavaFXEditorJXMsgRspnSchemaWireParsers().getTextValue());

        editObj.setOptionalJXMsgRspnSchemaXsdElementList(
                getJavaFXEditorJXMsgRspnSchemaXsdElementList().getTextValue());

        editObj.setOptionalJXMsgRspnSchemaXsdSpec(getJavaFXEditorJXMsgRspnSchemaXsdSpec().getTextValue());
    }

    public void setPaneMode(CFPane.PaneMode value) {
        final String S_ProcName = "setPaneMode";
        CFPane.PaneMode oldValue = getPaneMode();
        if (oldValue == value) {
            return;
        }
        ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
        if ((value != CFPane.PaneMode.Unknown) && (value != CFPane.PaneMode.View)) {
            if (focus == null) {
                throw CFLib.getDefaultExceptionFactory().newNullArgumentException(getClass(), S_ProcName, 0,
                        "javaFXFocus");
            }
        }
        ICFBamSchemaDefEditObj editObj;
        if (focus != null) {
            editObj = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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 = (ICFBamSchemaDefEditObj) 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) {
            ICFBamSchemaDefObj focus = getJavaFXFocusAsSchemaDef();
            if (focus == null) {
                isEditing = false;
            } else if (null == focus.getEdit()) {
                isEditing = false;
            }
        }
        if (javafxReferenceLookupDefaultLicense != null) {
            javafxReferenceLookupDefaultLicense.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 (javafxEditorExtendCFCore != null) {
            javafxEditorExtendCFCore.setDisable(!isEditing);
        }
        if (javafxEditorCopyrightPeriod != null) {
            javafxEditorCopyrightPeriod.setDisable(!isEditing);
        }
        if (javafxEditorCopyrightHolder != null) {
            javafxEditorCopyrightHolder.setDisable(!isEditing);
        }
        if (javafxEditorPublishURI != null) {
            javafxEditorPublishURI.setDisable(!isEditing);
        }
        if (javafxEditorJSchemaObjImport != null) {
            javafxEditorJSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJSchemaObjInterface != null) {
            javafxEditorJSchemaObjInterface.setDisable(!isEditing);
        }
        if (javafxEditorJSchemaObjMembers != null) {
            javafxEditorJSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJSchemaObjImplementation != null) {
            javafxEditorJSchemaObjImplementation.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWSchemaObjMembers != null) {
            javafxEditorJDb2LUWSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWSchemaObjImpl != null) {
            javafxEditorJDb2LUWSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJDb2LUWSchemaObjImport != null) {
            javafxEditorJDb2LUWSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlSchemaObjMembers != null) {
            javafxEditorJMSSqlSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlSchemaObjImpl != null) {
            javafxEditorJMSSqlSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJMSSqlSchemaObjImport != null) {
            javafxEditorJMSSqlSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlSchemaObjMembers != null) {
            javafxEditorJMySqlSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlSchemaObjImpl != null) {
            javafxEditorJMySqlSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJMySqlSchemaObjImport != null) {
            javafxEditorJMySqlSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJOracleSchemaObjMembers != null) {
            javafxEditorJOracleSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJOracleSchemaObjImpl != null) {
            javafxEditorJOracleSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJOracleSchemaObjImport != null) {
            javafxEditorJOracleSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlSchemaObjMembers != null) {
            javafxEditorJPgSqlSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlSchemaObjImpl != null) {
            javafxEditorJPgSqlSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJPgSqlSchemaObjImport != null) {
            javafxEditorJPgSqlSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseSchemaObjMembers != null) {
            javafxEditorJSybaseSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseSchemaObjImpl != null) {
            javafxEditorJSybaseSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJSybaseSchemaObjImport != null) {
            javafxEditorJSybaseSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJRamSchemaObjMembers != null) {
            javafxEditorJRamSchemaObjMembers.setDisable(!isEditing);
        }
        if (javafxEditorJRamSchemaObjImpl != null) {
            javafxEditorJRamSchemaObjImpl.setDisable(!isEditing);
        }
        if (javafxEditorJRamSchemaObjImport != null) {
            javafxEditorJRamSchemaObjImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgSchemaImport != null) {
            javafxEditorJXMsgSchemaImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgSchemaFormatters != null) {
            javafxEditorJXMsgSchemaFormatters.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgClientSchemaImport != null) {
            javafxEditorJXMsgClientSchemaImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgClientSchemaBody != null) {
            javafxEditorJXMsgClientSchemaBody.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstSchemaBody != null) {
            javafxEditorJXMsgRqstSchemaBody.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstSchemaImport != null) {
            javafxEditorJXMsgRqstSchemaImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstSchemaWireParsers != null) {
            javafxEditorJXMsgRqstSchemaWireParsers.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstSchemaXsdSpec != null) {
            javafxEditorJXMsgRqstSchemaXsdSpec.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRqstSchemaXsdElementList != null) {
            javafxEditorJXMsgRqstSchemaXsdElementList.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnSchemaBody != null) {
            javafxEditorJXMsgRspnSchemaBody.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnSchemaImport != null) {
            javafxEditorJXMsgRspnSchemaImport.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnSchemaWireParsers != null) {
            javafxEditorJXMsgRspnSchemaWireParsers.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnSchemaXsdElementList != null) {
            javafxEditorJXMsgRspnSchemaXsdElementList.setDisable(!isEditing);
        }
        if (javafxEditorJXMsgRspnSchemaXsdSpec != null) {
            javafxEditorJXMsgRspnSchemaXsdSpec.setDisable(!isEditing);
        }
    }
}