/// <summary>
/// Method called after the schema set has been loaded and the DomNodeTypes have been created, but
/// before the DomNodeTypes have been frozen. This means that DomNodeType.SetIdAttribute, for example, has
/// not been called on the DomNodeTypes. Is called shortly before OnDomNodeTypesFrozen.</summary>
/// <param name="schemaSet">XML schema sets being loaded</param>
protected override void OnSchemaSetLoaded(XmlSchemaSet schemaSet)
{
foreach (XmlSchemaTypeCollection typeCollection in GetTypeCollections())
{
m_namespace = typeCollection.TargetNamespace;
m_typeCollection = typeCollection;
Schema.Initialize(typeCollection);
// register extensions
Schema.gameType.Type.Define(new ExtensionInfo<GameEditingContext>());
Schema.gameType.Type.Define(new ExtensionInfo<UniqueIdValidator>());
// Add required property descriptors to GameObject and OrcType so it can be edited
// with two column PropertyGrid.
// Note: this is programmatic approach: Decorate DomNode types with
// property descriptors.
// Alternatively schema annotations can used.
// However, programmatic approach is recommend because of type safety.
// Descriptors for armorType.
string general = "General".Localize();
var armorDescriptors = new PropertyDescriptorCollection(null);
armorDescriptors.Add(new AttributePropertyDescriptor(
"Name".Localize(),
Schema.armorType.nameAttribute,
general,
"Armor name".Localize(),
false
));
armorDescriptors.Add(new AttributePropertyDescriptor(
"Defense".Localize(),
Schema.armorType.defenseAttribute,
general,
"Armor defense".Localize(),
false,
new NumericEditor(typeof(int))
));
armorDescriptors.Add(new AttributePropertyDescriptor(
"Price".Localize(),
Schema.armorType.priceAttribute,
general,
"Armor price in gold".Localize(),
false,
new NumericEditor(typeof(int))
));
Schema.armorType.Type.SetTag(armorDescriptors);
// club type property descriptors.
var clubDescriptors = new PropertyDescriptorCollection(null);
clubDescriptors.Add(new AttributePropertyDescriptor(
"Spike".Localize(),
Schema.clubType.spikesAttribute,
general,
"Club Has Spikes".Localize(),
false,
new BoolEditor()
));
clubDescriptors.Add(new AttributePropertyDescriptor(
"Damage".Localize(),
Schema.clubType.DamageAttribute,
general,
"Amount of damage per strike".Localize(),
false,
new NumericEditor(typeof(int))
));
clubDescriptors.Add(new AttributePropertyDescriptor(
"Weight".Localize(),
Schema.clubType.wieghtAttribute,
general,
"Weight of the club".Localize(),
false,
new NumericEditor(typeof(float))
));
Schema.clubType.Type.SetTag(clubDescriptors);
var gobDescriptors = new PropertyDescriptorCollection(null);
gobDescriptors.Add(
new AttributePropertyDescriptor(
"Name".Localize(),
Schema.gameObjectType.nameAttribute,
null,
"Object name".Localize(),
false
));
// bool editor: shows checkBox instead of textual (true,false).
gobDescriptors.Add(
new AttributePropertyDescriptor(
"Visible".Localize(),
Schema.gameObjectType.visibleAttribute,
null,
"Show/Hide object in editor".Localize(),
false,
new BoolEditor()
));
// NumericTupleEditor can be used for vector values.
string xformCategory = "Transformation".Localize();
var transEditor =
new NumericTupleEditor(typeof(float), new string[] { "Tx", "Ty", "Tz" });
gobDescriptors.Add(
new AttributePropertyDescriptor(
"Translate".Localize(),
Schema.gameObjectType.translateAttribute,
xformCategory,
"Object's position".Localize(),
false,
transEditor
));
var scaleEditor =
new NumericTupleEditor(typeof(float), new string[] { "Sx", "Sy", "Sz" });
gobDescriptors.Add(
new AttributePropertyDescriptor(
"Scale".Localize(),
Schema.gameObjectType.scaleAttribute,
xformCategory,
"Object's scale".Localize(),
false,
scaleEditor
));
var rotationEditor =
new NumericTupleEditor(typeof(float), new string[] { "Rx", "Ry", "Rz" });
rotationEditor.ScaleFactor = 360.0f / (2.0f * (float)Math.PI); // Radians to Degrees
gobDescriptors.Add(
new AttributePropertyDescriptor(
"Rotation".Localize(),
Schema.gameObjectType.rotateAttribute,
xformCategory,
"Object's orientation".Localize(),
false,
rotationEditor
));
Schema.gameObjectType.Type.SetTag(gobDescriptors);
// Defines property descriptors for orcType.
var orcDescriptors = new PropertyDescriptorCollection(null);
string chCategory = "Character attributes".Localize();
// Bounded int editor: used for editing bounded int properties.
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Skill".Localize(),
Schema.orcType.skillAttribute,
chCategory,
"Skill".Localize(),
false,
new BoundedIntEditor(1,120)
));
// Bounded float editor: similar to bounded int editor
// but it operates on float instead.
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Weight".Localize(),
Schema.orcType.weightAttribute,
chCategory,
"Weight".Localize(),
false,
new BoundedFloatEditor(80, 400)
));
// store the value of enum as string.
LongEnumEditor emotionEditor = new LongEnumEditor(typeof(OrcEmotion));
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Emotion".Localize(),
Schema.orcType.emotionAttribute,
chCategory,
"Emotion".Localize(),
false,
emotionEditor
));
// FlagsUITypeEditor store flags as int.
// doesn't implement IPropertyEditor
FlagsUITypeEditor goalsEditor = new FlagsUITypeEditor(Enum.GetNames(typeof(OrcGoals)));
FlagsTypeConverter goalsConverter = new FlagsTypeConverter(Enum.GetNames(typeof(OrcGoals)));
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Goals".Localize(),
Schema.orcType.goalsAttribute,
chCategory,
"Goals".Localize(),
false,
goalsEditor,
goalsConverter
));
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Health".Localize(),
Schema.orcType.healthAttribute,
chCategory,
"Orc's health".Localize(),
false,
new NumericEditor(typeof(int))
));
//EmbeddedCollectionEditor edit children (edit, add, remove, move).
// note: EmbeddedCollectionEditor needs some work (effecienty and implementation issues).
var collectionEditor = new EmbeddedCollectionEditor();
// the following lambda's handles (add, remove, move ) items.
collectionEditor.GetItemInsertersFunc = (context)=>
{
var insertors
= new EmbeddedCollectionEditor.ItemInserter[1];
var list = context.GetValue() as IList<DomNode>;
if (list != null)
{
var childDescriptor
= context.Descriptor as ChildPropertyDescriptor;
if (childDescriptor != null)
{
insertors[0] = new EmbeddedCollectionEditor.ItemInserter(childDescriptor.ChildInfo.Type.Name,
delegate
{
DomNode node = new DomNode(childDescriptor.ChildInfo.Type);
if (node.Type.IdAttribute != null)
{
node.SetAttribute(node.Type.IdAttribute, node.Type.Name);
}
list.Add(node);
return node;
});
return insertors;
}
}
return EmptyArray<EmbeddedCollectionEditor.ItemInserter>.Instance;
};
collectionEditor.RemoveItemFunc = (context, item) =>
{
var list = context.GetValue() as IList<DomNode>;
if (list != null)
list.Remove(item.Cast<DomNode>());
};
collectionEditor.MoveItemFunc = (context, item, delta) =>
{
var list = context.GetValue() as IList<DomNode>;
if (list != null)
{
DomNode node = item.Cast<DomNode>();
int index = list.IndexOf(node);
int insertIndex = index + delta;
if (insertIndex < 0 || insertIndex >= list.Count)
return;
list.RemoveAt(index);
list.Insert(insertIndex, node);
}
};
string weaponCategory = "Weapons and Defense".Localize();
orcDescriptors.Add(
new ChildPropertyDescriptor(
"Armor".Localize(),
Schema.orcType.armorChild,
weaponCategory,
"Armors".Localize(),
false,
collectionEditor
));
orcDescriptors.Add(
new ChildPropertyDescriptor(
"Club".Localize(),
Schema.orcType.clubChild,
weaponCategory,
"Club".Localize(),
false,
collectionEditor
));
orcDescriptors.Add(
new ChildPropertyDescriptor(
"Orcs".Localize(),
Schema.orcType.orcChild,
"Children".Localize(),
"Orc children".Localize(),
false,
collectionEditor
));
string renderingCategory = "Rendering".Localize();
// color picker.
// note: ColorPickerEditor doesn't implement IPropertyEditor
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Skin".Localize(),
Schema.orcType.skinColorAttribute,
renderingCategory,
"Skin color".Localize(),
false,
new ColorPickerEditor(),
new IntColorConverter()
));
// file picker.
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Texture file".Localize(),
Schema.orcType.textureFileAttribute,
renderingCategory,
"Texture file".Localize(),
false,
new FileUriEditor("Texture file (*.dds)|*.dds")
));
// Edit matrix.
//NumericMatrixEditor
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Texture Transform".Localize(),
Schema.orcType.textureTransformAttribute,
renderingCategory,
"Texture Transform".Localize(),
false,
new NumericMatrixEditor()
));
// Edit array.
// ArrayEditor, need some work, it has some efficiency and implementation issues.
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Texture Array".Localize(),
Schema.orcType.textureArrayAttribute,
renderingCategory,
"Texture Array".Localize(),
false,
new ArrayEditor()
));
// readonly property,
// show datetime as readonly.
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Revision data".Localize(),
Schema.orcType.TextureRevDateAttribute,
renderingCategory,
"Texture revision data and time".Localize(),
true
));
// folder picker.
// FolderUriEditor and FolderBrowserDialogUITypeEditor
orcDescriptors.Add(
new AttributePropertyDescriptor(
"Resource Folder".Localize(),
Schema.orcType.resourceFolderAttribute,
renderingCategory,
"Resource folder".Localize(),
false,
new FolderUriEditor()
));
Schema.orcType.Type.SetTag(orcDescriptors);
// only one namespace
break;
}
}
/// <summary>
/// Finishes initializing component by adding palette information and defining module types</summary>
public virtual void Initialize()
{
// add palette info to annotation type, and register with palette
var annotationItem = new NodeTypePaletteItem(
Schema.annotationType.Type,
"Comment".Localize(),
"Create a moveable resizable comment on the circuit canvas".Localize(),
Resources.AnnotationImage);
m_paletteService.AddItem(
annotationItem, "Misc".Localize("abbreviation for miscellaneous"), this);
// define editable properties on annotation
Schema.annotationType.Type.SetTag(
new PropertyDescriptorCollection(
new PropertyDescriptor[] {
new AttributePropertyDescriptor(
"Text".Localize(),
Schema.annotationType.textAttribute,
null,
"Comment Text".Localize(),
false),
new AttributePropertyDescriptor(
"Background Color".Localize(), // name
Schema.annotationType.backcolorAttribute, //AttributeInfo
null, // category
"Comment's background color".Localize(), //description
false, //isReadOnly
new Sce.Atf.Controls.PropertyEditing.ColorEditor(), // editor
new Sce.Atf.Controls.PropertyEditing.IntColorConverter() // typeConverter
),
new AttributePropertyDescriptor(
"Foreground Color".Localize(), // name
Schema.annotationType.foreColorAttribute, //AttributeInfo
null, // category
"Comment's foreground color".Localize(), //description
false, //isReadOnly
new Sce.Atf.Controls.PropertyEditing.ColorEditor(), // editor
new Sce.Atf.Controls.PropertyEditing.IntColorConverter() // typeConverter
),
}));
// define module types
DefineModuleType(
new XmlQualifiedName("buttonType", Schema.NS),
"Button".Localize(),
"On/Off Button".Localize(),
Resources.ButtonImage,
EmptyArray<ElementType.Pin>.Instance,
new ElementType.Pin[]
{
new ElementType.Pin("Out".Localize(), BooleanPinTypeName, 0)
},
m_schemaLoader);
var lightType = DefineModuleType(
new XmlQualifiedName("lightType", Schema.NS),
"Light".Localize(),
"Light source".Localize(),
Resources.LightImage,
new ElementType.Pin[]
{
new ElementType.Pin("In".Localize(), BooleanPinTypeName, 0)
},
EmptyArray<ElementType.Pin>.Instance,
m_schemaLoader);
// define and add new attribute to light type.
var featuresAttribute = new AttributeInfo("features".Localize(), AttributeType.IntType);
featuresAttribute.DefaultValue = 3;
lightType.Define(featuresAttribute);
// create property descriptor for the above attribute.
FlagsUITypeEditor featuresEditor = new FlagsUITypeEditor(new[] { "ENERGY STAR", "High CRI" }, new[] { 1, 2 });
FlagsTypeConverter featuresConverter = new FlagsTypeConverter(new[] { "Energy Star", "High CRI" }, new[] { 1, 2 });
lightType.SetTag(
new PropertyDescriptorCollection(
new PropertyDescriptor[] {
new AttributePropertyDescriptor(
"Features".Localize(),
featuresAttribute,
null, //category
"Features".Localize(), //description
false,
featuresEditor,
featuresConverter) //is not read-only
}));
DomNodeType speakerNodeType = DefineModuleType(
new XmlQualifiedName("speakerType", Schema.NS),
"Speaker".Localize("an electronic speaker, for playing sounds"),
"Speaker".Localize("an electronic speaker, for playing sounds"),
Resources.SpeakerImage,
new ElementType.Pin[]
{
new ElementType.Pin("In".Localize(), FloatPinTypeName, 0),
},
EmptyArray<ElementType.Pin>.Instance,
m_schemaLoader);
var speakerManufacturerInfo = new AttributeInfo("Manufacturer".Localize(), AttributeType.StringType);
// add bass level attribute to demo/test BoundedFloatEditor()
float bassMin = -1;
float bassMax = 1;
var bassLevel = new AttributeInfo("bassLevel".Localize("bass level"), AttributeType.FloatType);
bassLevel.AddRule(new NumericMinRule(bassMin, true));
bassLevel.AddRule(new NumericMaxRule(bassMax, true));
bassLevel.DefaultValue = 0.1f;
//bassLevel.def
speakerNodeType.Define(bassLevel);
speakerNodeType.Define(speakerManufacturerInfo);
speakerNodeType.SetTag(
new PropertyDescriptorCollection(
new PropertyDescriptor[] {
new AttributePropertyDescriptor(
"Manufacturer".Localize(),
speakerManufacturerInfo,
null, //category
"Manufacturer".Localize(), //description
false),
new AttributePropertyDescriptor(
"Bass Level".Localize(),
bassLevel,
null, //category
"Bass Level".Localize(), //description
false,
new BoundedFloatEditor(bassMin,bassMax))
}));
DefineModuleType(
new XmlQualifiedName("soundType", Schema.NS),
"Sound".Localize(),
"Sound Player".Localize(),
Resources.SoundImage,
new ElementType.Pin[]
{
new ElementType.Pin("On".Localize(), "boolean", 0),
new ElementType.Pin("Reset".Localize(), "boolean", 1),
new ElementType.Pin("Pause".Localize(), "boolean", 2),
},
new ElementType.Pin[]
{
new ElementType.Pin("Out".Localize(), "float", 0),
},
m_schemaLoader);
DefineModuleType(
new XmlQualifiedName("andType", Schema.NS),
"And".Localize(),
"Logical AND".Localize(),
Resources.AndImage,
new ElementType.Pin[]
{
new ElementType.Pin("In1".Localize("input pin #1"), "boolean", 0),
new ElementType.Pin("In2".Localize("input pin #2"), "boolean", 1),
},
new ElementType.Pin[]
{
new ElementType.Pin("Out".Localize(), "boolean", 0),
},
m_schemaLoader);
DefineModuleType(
new XmlQualifiedName("orType", Schema.NS),
"Or".Localize(),
"Logical OR".Localize(),
Resources.OrImage,
new ElementType.Pin[]
{
new ElementType.Pin("In1".Localize("input pin #1"), "boolean", 0),
new ElementType.Pin("In2".Localize("input pin #2"), "boolean", 1),
},
new ElementType.Pin[]
{
new ElementType.Pin("Out".Localize(), "boolean", 0),
},
m_schemaLoader);
DefineModuleType(
new XmlQualifiedName("16To1MultiplexerType", Schema.NS),
"16-to-1 Multiplexer".Localize(),
"16-to-1 Multiplexer".Localize(),
Resources.AndImage,
new ElementType.Pin[]
{
new ElementType.Pin("In1".Localize("input pin #1"), "boolean", 0),
new ElementType.Pin("In2".Localize("input pin #2"), "boolean", 1),
new ElementType.Pin("In3".Localize(), "boolean", 2),
new ElementType.Pin("In4".Localize(), "boolean", 3),
new ElementType.Pin("In5".Localize(), "boolean", 4),
new ElementType.Pin("In6".Localize(), "boolean", 5),
new ElementType.Pin("In7".Localize(), "boolean", 6),
new ElementType.Pin("In8".Localize(), "boolean", 7),
new ElementType.Pin("In9".Localize(), "boolean", 8),
new ElementType.Pin("In10".Localize(), "boolean", 9),
new ElementType.Pin("In11".Localize(), "boolean", 10),
new ElementType.Pin("In12".Localize(), "boolean", 11),
new ElementType.Pin("In13".Localize(), "boolean", 12),
new ElementType.Pin("In14".Localize(), "boolean", 13),
new ElementType.Pin("In15".Localize(), "boolean", 14),
new ElementType.Pin("In16".Localize(), "boolean", 15),
new ElementType.Pin("Select1".Localize("The name of a pin on a circuit element"), "boolean", 16),
new ElementType.Pin("Select2".Localize("The name of a pin on a circuit element"), "boolean", 17),
new ElementType.Pin("Select3".Localize("The name of a pin on a circuit element"), "boolean", 18),
new ElementType.Pin("Select4".Localize("The name of a pin on a circuit element"), "boolean", 19),
},
new ElementType.Pin[]
{
new ElementType.Pin("Out".Localize(), "boolean", 0),
},
m_schemaLoader);
DefineModuleType(
new XmlQualifiedName("1To16DemultiplexerType", Schema.NS),
"1-to-16 Demultiplexer".Localize(),
"1-to-16 Demultiplexer".Localize(),
Resources.OrImage,
new ElementType.Pin[]
{
new ElementType.Pin("Data".Localize(), "boolean", 0),
new ElementType.Pin("Select1".Localize("The name of a pin on a circuit element"), "boolean", 1),
new ElementType.Pin("Select2".Localize("The name of a pin on a circuit element"), "boolean", 2),
new ElementType.Pin("Select3".Localize("The name of a pin on a circuit element"), "boolean", 3),
new ElementType.Pin("Select4".Localize("The name of a pin on a circuit element"), "boolean", 4),
},
new ElementType.Pin[]
{
new ElementType.Pin("Out1".Localize(), "boolean", 0),
new ElementType.Pin("Out2".Localize(), "boolean", 1),
new ElementType.Pin("Out3".Localize(), "boolean", 2),
new ElementType.Pin("Out4".Localize(), "boolean", 3),
new ElementType.Pin("Out5".Localize(), "boolean", 4),
new ElementType.Pin("Out6".Localize(), "boolean", 5),
new ElementType.Pin("Out7".Localize(), "boolean", 6),
new ElementType.Pin("Out8".Localize(), "boolean", 7),
new ElementType.Pin("Out9".Localize(), "boolean", 8),
new ElementType.Pin("Out10".Localize(), "boolean", 9),
new ElementType.Pin("Out11".Localize(), "boolean", 10),
new ElementType.Pin("Out12".Localize(), "boolean", 11),
new ElementType.Pin("Out13".Localize(), "boolean", 12),
new ElementType.Pin("Out14".Localize(), "boolean", 13),
new ElementType.Pin("Out15".Localize(), "boolean", 14),
new ElementType.Pin("Out16".Localize(), "boolean", 15),
},
m_schemaLoader);
}