/// <summary>
/// Method that handles the Property XML element.
/// </summary>
/// <param name="attributes"></param>
private void ElementPropertyStart(XMLAttributes attributes)
{
// get property name
var propertyName = attributes.GetValueAsString(Property.NameXMLAttributeName);
// get property value string
var propertyValue = String.Empty;
if (attributes.Exists(Property.ValueXMLAttributeName))
{
propertyValue = attributes.GetValueAsString(Property.ValueXMLAttributeName);
}
// Short property
if (!String.IsNullOrEmpty(propertyValue))
{
d_stringItemName = String.Empty;
try
{
// need a window to be able to set properties!
if (d_stack.Count != 0)
{
// get current window being defined.
var curwindow = d_stack[d_stack.Count - 1].Item1;
var useit = true;
// if client defined a callback, call it and discover if we should
// set the property.
if (d_propertyCallback != null)
{
useit = d_propertyCallback(curwindow,
propertyName,
propertyValue,
d_userData);
}
// set the property as needed
if (useit)
{
curwindow.SetProperty(propertyName, propertyValue);
}
}
}
catch (Exception)
{
// Don't do anything here, but the error will have been logged.
}
}
// Long property
else
{
// Store name for later use
d_stringItemName = propertyName;
// reset the property value buffer
d_stringItemValue = String.Empty;
}
}
//! Function that handles the LookNFeel XML element.
private void elementLookNFeelStart(XMLAttributes attributes)
{
var lnf = new Scheme.LoadableUIElement();
lnf.filename = attributes.GetValueAsString(FilenameAttribute);
lnf.resourceGroup = attributes.GetValueAsString(ResourceGroupAttribute);
d_scheme.d_looknfeels.Add(lnf);
}
//! Function that handles the Font XML element.
private void elementFontStart(XMLAttributes attributes)
{
var font = new Scheme.LoadableUIElement();
font.name = attributes.GetValueAsString(NameAttribute);
font.filename = attributes.GetValueAsString(FilenameAttribute);
font.resourceGroup = attributes.GetValueAsString(ResourceGroupAttribute);
d_scheme.d_fonts.Add(font);
}
//! Function that handles the ImagesetFromImage XML element.
private void elementImagesetFromImageStart(XMLAttributes attributes)
{
var imageset = new Scheme.LoadableUIElement();
imageset.filename = attributes.GetValueAsString(FilenameAttribute);
imageset.name = attributes.GetValueAsString(NameAttribute, imageset.filename);
imageset.resourceGroup = attributes.GetValueAsString(ResourceGroupAttribute);
d_scheme.d_imagesetsFromImages.Add(imageset);
}
public override void ElementStart(string element, XMLAttributes attributes)
{
if (element == WindowAliasElement)
{
elementWindowAliasStart(attributes);
}
else if (element == ImagesetElement)
{
elementImagesetStart(attributes);
}
else if (element == ImagesetFromImageElement)
{
elementImagesetFromImageStart(attributes);
}
else if (element == FontElement)
{
elementFontStart(attributes);
}
else if (element == WindowSetElement)
{
elementWindowSetStart(attributes);
}
else if (element == WindowFactoryElement)
{
elementWindowFactoryStart(attributes);
}
else if (element == WindowRendererSetElement)
{
elementWindowRendererSetStart(attributes);
}
else if (element == WindowRendererFactoryElement)
{
elementWindowRendererFactoryStart(attributes);
}
else if (element == GUISchemeElement)
{
elementGUISchemeStart(attributes);
}
else if (element == FalagardMappingElement)
{
elementFalagardMappingStart(attributes);
}
else if (element == LookNFeelElement)
{
elementLookNFeelStart(attributes);
}
// anything else is a non-fatal error.
else
{
System.GetSingleton().Logger
.LogEvent("Scheme_xmlHandler::elementStart: Unknown element encountered: <" + element + ">",
LoggingLevel.Errors);
}
}
//! Function that handles the WindowRendererSet XML element.
private void elementWindowRendererSetStart(XMLAttributes attributes)
{
var module = new Scheme.UIModule
{
name = attributes.GetValueAsString(FilenameAttribute),
dynamicModule = null,
factoryModule = null
};
d_scheme.d_windowRendererModules.Add(module);
}
private void OnStartElement(XmlReader reader, XmlHandler handler)
{
var element = reader.Name;
var attributes = new XMLAttributes();
while (reader.MoveToNextAttribute())
{
attributes.Add(reader.Name, reader.Value);
}
handler.ElementStart(element, attributes);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="attributes"></param>
/// <param name="anim"></param>
public AnimationSubscriptionHandler(XMLAttributes attributes, Animation anim)
{
Logger.LogInsane("\tAdding subscription to event: " +
attributes.GetValueAsString(EventAttribute) +
" Action: " +
attributes.GetValueAsString(ActionAttribute));
anim.DefineAutoSubscription(attributes.GetValueAsString(EventAttribute),
attributes.GetValueAsString(ActionAttribute));
d_completed = true;
}
//! Function that handles the FalagardMapping XML element.
private void elementFalagardMappingStart(XMLAttributes attributes)
{
var fmap = new Scheme.FalagardMapping();
fmap.windowName = attributes.GetValueAsString(WindowTypeAttribute);
fmap.targetName = attributes.GetValueAsString(TargetTypeAttribute);
fmap.lookName = attributes.GetValueAsString(LookNFeelAttribute);
fmap.rendererName = attributes.GetValueAsString(WindowRendererAttribute);
fmap.effectName = attributes.GetValueAsString(RenderEffectAttribute);
d_scheme.d_falagardMappings.Add(fmap);
}
//! Function that handles the opening GUIScheme XML element.
private void elementGUISchemeStart(XMLAttributes attributes)
{
var name = attributes.GetValueAsString(NameAttribute);
var logger = System.GetSingleton().Logger;
logger.LogEvent("Started creation of Scheme from XML specification:");
logger.LogEvent("---- CEGUI GUIScheme name: " + name);
validateSchemeFileVersion(attributes);
// create empty scheme with desired name
d_scheme = new Scheme(name);
}
protected override void ElementStartLocal(string element, XMLAttributes attributes)
{
if (element == AnimationKeyFrameHandler.ElementName)
{
ChainedHandler = new AnimationKeyFrameHandler(attributes, _affector);
}
else
{
System.GetSingleton().Logger
.LogEvent(
"AnimationAffectorHandler.ElementStartLocal: " + "<" + element +
"> is invalid at this location.", LoggingLevel.Errors);
}
}
public const string GuiLayoutVersionAttribute = "version"; //!< Attribute name that stores the xml file version.
/// <summary>
/// Method that handles the opening GUILayout XML element.
/// </summary>
/// <param name="attributes"></param>
/// <remarks>
/// This method just checks the version attribute and there is no equivalent
/// elementGUILayoutEnd method, because it would be just NOOP anyways
/// </remarks>
private void ElementGUILayoutStart(XMLAttributes attributes)
{
var version = attributes.GetValueAsString(GuiLayoutVersionAttribute, "unknown");
if (version != NativeVersion)
{
throw new InvalidRequestException(
"You are attempting to load a layout of version '" + version +
"' but this CEGUI version is only meant to load layouts of " +
"version '" + NativeVersion + "'. Consider using the " +
"migrate.py script bundled with CEGUI Unified Editor to " +
"migrate your data.");
}
}
//! throw exception if file version is not supported.
private void validateSchemeFileVersion(XMLAttributes attrs)
{
var version = attrs.GetValueAsString(SchemeVersionAttribute, "unknown");
if (version == NativeVersion)
{
return;
}
throw new InvalidRequestException("You are attempting to load a GUI scheme of version '" + version +
"' but this CEGUI version is only meant to load GUI schemes of version '" +
NativeVersion + "'. Consider using the migrate.py script bundled with " +
"CEGUI Unified Editor to migrate your data.");
}
/// <summary>
/// Method that handles the opening Window XML element.
/// </summary>
/// <param name="attributes"></param>
private void ElementWindowStart(XMLAttributes attributes)
{
// get type of window to create
var windowType = attributes.GetValueAsString(Window.WindowTypeXMLAttributeName);
// get name for new window
var windowName = attributes.GetValueAsString(Window.WindowNameXMLAttributeName);
// attempt to create window
try
{
var wnd = WindowManager.GetSingleton().CreateWindow(windowType, windowName);
// add this window to the current parent (if any)
if (d_stack.Count != 0)
{
d_stack[d_stack.Count - 1].Item1.AddChild(wnd);
}
else
{
d_root = wnd;
}
// make this window the top of the stack
d_stack.Add(new Tuple <Window, bool>(wnd, true));
// tell it that it is being initialised
wnd.BeginInitialisation();
}
catch (AlreadyExistsException)
{
// delete all windows created
CleanupLoadedWindows();
// signal error - with more info about what we have done.
throw new InvalidRequestException("layout loading has been aborted since Window named '" + windowName +
"' already exists.");
}
catch (UnknownObjectException)
{
// delete all windows created
CleanupLoadedWindows();
// signal error - with more info about what we have done.
throw new InvalidRequestException(
"layout loading has been aborted since no WindowFactory is available for '" + windowType +
"' objects.");
}
}
// XML parsing helper functions.
private void ElementImagesetStart(XMLAttributes attributes)
{
// get name of the imageset.
string name = attributes.GetValueAsString(ImagesetNameAttribute);
// get name of the imageset.
s_imagesetType = attributes.GetValueAsString(ImagesetTypeAttribute, ImageTypeAttributeDefault);
// get texture image filename
string filename = attributes.GetValueAsString(ImagesetImageFileAttribute);
// get resource group to use for image file.
string resource_group = attributes.GetValueAsString(ImagesetResourceGroupAttribute);
var logger = System.GetSingleton().Logger;
logger.LogEvent("[ImageManager] Started creation of Imageset from XML specification:");
logger.LogEvent("[ImageManager] ---- CEGUI Imageset name: " + name);
logger.LogEvent("[ImageManager] ---- Source texture file: " + filename);
logger.LogEvent("[ImageManager] ---- Source texture resource group: " +
(String.IsNullOrEmpty(resource_group) ? "(Default)" : resource_group));
ValidateImagesetFileVersion(attributes);
var renderer = System.GetSingleton().GetRenderer();
// if the texture already exists,
if (renderer.IsTextureDefined(name))
{
System.GetSingleton().Logger
.LogEvent("[ImageManager] WARNING: Using existing texture: " + name);
s_texture = renderer.GetTexture(name);
}
else
{
// create texture from image
s_texture = renderer.CreateTexture(name, filename,
String.IsNullOrEmpty(resource_group)
? d_imagesetDefaultResourceGroup
: resource_group);
}
// set native resolution for imageset
s_nativeResolution = new Sizef(attributes.GetValueAsFloat(ImagesetNativeHorzResAttribute, 640),
attributes.GetValueAsFloat(ImagesetNativeVertResAttribute, 480));
// set auto-scaling as needed
s_autoScaled =
PropertyHelper.FromString <AutoScaledMode>(attributes.GetValueAsString(ImagesetAutoScaledAttribute,
"false"));
}
public AnimationKeyFrameHandler(XMLAttributes attributes, Affector affector)
{
//throw new NotImplementedException();
var progressionStr = attributes.GetValueAsString(ProgressionAttribute);
var logEvent = new StringBuilder("\t\tAdding KeyFrame at position: " +
attributes.GetValueAsString(PositionAttribute) +
" Value: " +
attributes.GetValueAsString(ValueAttribute));
if (!string.IsNullOrEmpty(progressionStr))
{
logEvent.Append(" Progression: " + attributes.GetValueAsString(ProgressionAttribute, ProgressionLinear));
}
Logger.LogInsane(logEvent.ToString());
KeyFrame.Progression progression;
if (progressionStr == ProgressionDiscrete)
{
progression = KeyFrame.Progression.Discrete;
}
else if (progressionStr == ProgressionQuadraticAccelerating)
{
progression = KeyFrame.Progression.QuadraticAccelerating;
}
else if (progressionStr == ProgressionQuadraticDecelerating)
{
progression = KeyFrame.Progression.QuadraticDecelerating;
}
else
{
progression = KeyFrame.Progression.Linear;
}
affector.CreateKeyFrame(
attributes.GetValueAsFloat(PositionAttribute),
attributes.GetValueAsString(ValueAttribute),
progression,
attributes.GetValueAsString(SourcePropertyAttribute));
if (affector.GetNumKeyFrames() == 1 && !string.IsNullOrEmpty(progressionStr))
{
System.GetSingleton().Logger
.LogEvent("WARNING: progression type specified for first keyframe in animation will be ignored.");
}
d_completed = true;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="attributes"></param>
public BitmapImage(XMLAttributes attributes)
: this(attributes.GetValueAsString(ImageNameAttribute),
System.GetSingleton().GetRenderer()
.GetTexture(attributes.GetValueAsString(ImageTextureAttribute)),
new Rectf(new Lunatics.Mathematics.Vector2(attributes.GetValueAsInteger(ImageXPosAttribute),
attributes.GetValueAsInteger(ImageYPosAttribute)),
new Sizef(attributes.GetValueAsInteger(ImageWidthAttribute),
attributes.GetValueAsInteger(ImageHeightAttribute))),
new Lunatics.Mathematics.Vector2(attributes.GetValueAsInteger(ImageXOffsetAttribute),
attributes.GetValueAsInteger(ImageYOffsetAttribute)),
PropertyHelper.FromString <AutoScaledMode>(attributes.GetValueAsString(ImageAutoScaledAttribute)),
new Sizef(attributes.GetValueAsInteger(ImageNativeHorzResAttribute, 640),
attributes.GetValueAsInteger(ImageNativeVertResAttribute, 480)))
{
}
/// <summary>
/// throw exception if file version is not supported.
/// </summary>
/// <param name="attrs"></param>
private void ValidateFontFileVersion(XMLAttributes attrs)
{
string version = (attrs.GetValueAsString(FontVersionAttribute, "unknown"));
if (version == NativeVersion)
{
return;
}
throw new InvalidRequestException(
"You are attempting to load a font of version '" + version + "' but " +
"this CEGUI version is only meant to load fonts of version '" +
NativeVersion + "'. Consider using the migrate.py script bundled with " +
"CEGUI Unified Editor to migrate your data.");
}
private void CreateFntFont(XMLAttributes attributes)
{
var name = attributes.GetValueAsString(FontNameAttribute);
var filename = attributes.GetValueAsString(FontFilenameAttribute);
var resourceGroup = attributes.GetValueAsString(FontResourceGroupAttribute);
Logger.LogInsane("---- CEGUI font name: " + name);
Logger.LogInsane("---- Font type: Fnt");
Logger.LogInsane("---- Source file: " + filename + " in resource group: " + (String.IsNullOrEmpty(resourceGroup) ? "(Default)" : resourceGroup));
_font = new FntFont(
name, filename, resourceGroup,
PropertyHelper.FromString <AutoScaledMode>(attributes.GetValueAsString(FontAutoScaledAttribute)),
new Sizef(attributes.GetValueAsFloat(FontNativeHorzResAttribute, 640.0f),
attributes.GetValueAsFloat(FontNativeVertResAttribute, 480.0f)));
}
// TODO ...
////! container type used to hold the images.
//typedef std::map<String, std::pair<Image*, ImageFactory*>,
// StringFastLessCompare
// CEGUI_MAP_ALLOC(String, Image*)> ImageMap;
////! ConstBaseIterator type definition.
//typedef ConstMapIterator<ImageMap> ImageIterator;
///*!
//\brief
// Return a ImageManager::ImageIterator object to iterate over the available
// Image objects.
//*/
//ImageIterator getIterator() const {
// return ImageIterator(d_images.begin(), d_images.end());
//}
// implement chained xml handler abstract interface
protected override void ElementStartLocal(string element, XMLAttributes attributes)
{
if (element == ImageElement)
{
ElementImageStart(attributes);
}
else if (element == ImagesetElement)
{
ElementImagesetStart(attributes);
}
else
{
System.GetSingleton().Logger.LogEvent(
"[ImageManager] Unknown XML element encountered: <" + element + ">", LoggingLevel.Errors);
}
}
public override void ElementStart(string element, XMLAttributes attributes)
{
// chained handler gets first crack at this element
if (ChainedHandler != null)
{
ChainedHandler.ElementStart(element, attributes);
// clean up if completed
if (ChainedHandler.Completed())
{
CleanupChainedHandler();
}
}
else
{
ElementStartLocal(element, attributes);
}
}
/// <summary>
/// document processing (only care about elements, schema validates format)
/// </summary>
/// <param name="element"></param>
/// <param name="attributes"></param>
public override void ElementStart(string element, XMLAttributes attributes)
{
// handle root GUILayoutElement element
if (element == GuiLayoutElement)
{
ElementGUILayoutStart(attributes);
}
// handle Window element (create window and make an entry on our "window stack")
else if (element == Window.WindowXMLElementName)
{
ElementWindowStart(attributes);
}
// handle AutoWindow element (get an auto child from the window on top of the "window stack")
else if (element == Window.AutoWindowXMLElementName)
{
ElementAutoWindowStart(attributes);
}
// handle UserString element (set user string for window at top of stack)
else if (element == Window.UserStringXMLElementName)
{
ElementUserStringStart(attributes);
}
// handle Property element (set property for window at top of stack)
else if (element == Property.XMLElementName)
{
ElementPropertyStart(attributes);
}
// handle layout import element (attach a layout to the window at the top of the stack)
else if (element == LayoutImportElement)
{
elementLayoutImportStart(attributes);
}
// handle event subscription element
else if (element == EventElement)
{
elementEventStart(attributes);
}
// anything else is an error which *should* have already been caught by XML validation
else
{
System.GetSingleton().Logger
.LogEvent(
"GuiLayoutXmlHandler::startElement - Unexpected data was found while parsing the gui-layout file: '" +
element + "' is unknown.", LoggingLevel.Errors);
}
}
/// <summary>
/// Method that handles the UserString XML element.
/// </summary>
/// <param name="attributes"></param>
private void ElementUserStringStart(XMLAttributes attributes)
{
// Get user string name
var userStringName = attributes.GetValueAsString(Window.UserStringNameXMLAttributeName);
// Get user string value
var userStringValue = String.Empty;
if (attributes.Exists(Window.UserStringValueXMLAttributeName))
{
userStringValue = attributes.GetValueAsString(Window.UserStringValueXMLAttributeName);
}
// Short user string
if (!String.IsNullOrEmpty(userStringValue))
{
d_stringItemName = null;
try
{
// need a window to be able to set properties!
if (d_stack.Count != 0)
{
// get current window being defined.
var curwindow = d_stack[d_stack.Count - 1].Item1;
curwindow.SetUserString(userStringName, userStringValue);
}
}
catch (Exception)
{
// Don't do anything here, but the error will have been logged.
}
}
// Long user string
else
{
// Store name for later use
d_stringItemName = userStringName;
// reset the property (user string) value buffer
d_stringItemValue = null;
}
}
public override void ElementStart(string element, XMLAttributes attributes)
{
// handle root Font element
if (element == FontElement)
{
ElementFontStart(attributes);
}
// handle a Mapping element
else if (element == MappingElement)
{
ElementMappingStart(attributes);
}
// anything else is a non-fatal error.
else
{
System.GetSingleton().Logger.LogEvent("Font_xmlHandler.ElementStart: " +
"Unknown element encountered: <" + element + ">",
LoggingLevel.Errors);
}
}
public Image Create(XMLAttributes attributes)
{
var name = attributes.GetValueAsString(ImageNameAttribute);
if (String.IsNullOrEmpty(name))
{
throw new InvalidRequestException("Invalid (empty) image name passed to create.");
}
if (d_images.ContainsKey(name))
{
throw new AlreadyExistsException("Image already exists: " + name);
}
if (!d_factories.ContainsKey(s_imagesetType))
{
throw new UnknownObjectException("Unknown Image type: " + s_imagesetType);
}
var factory = d_factories[s_imagesetType];
var image = factory.Create(attributes);
// sanity check that the created image uses the name specified in the
// attributes block
if (image.GetName() != name)
{
var message = "Factory for type: " + s_imagesetType + " created Image named: " + image.GetName() +
". Was expecting name: " + name;
factory.Destroy(image);
throw new InvalidRequestException(message);
}
d_images[name] = new Tuple <Image, ImageFactory>(image, factory);
System.GetSingleton().Logger
.LogEvent(String.Format("[ImageManager] Created image: '{0}' (0x{1:X8}) of type: {2}", name, image.GetHashCode(), s_imagesetType));
return(image);
}
private void ElementImageStart(XMLAttributes attributes)
{
var image_name = s_texture.GetName() + '/' + attributes.GetValueAsString(ImageNameAttribute);
if (IsDefined(image_name))
{
System.GetSingleton().Logger.LogEvent("[ImageManager] WARNING: Using existing image :" + image_name);
return;
}
XMLAttributes rwAttrs = attributes;
// rewrite the name attribute to include the texture name
rwAttrs.Add(ImageNameAttribute, image_name);
if (!rwAttrs.Exists(ImageTextureAttribute))
{
rwAttrs.Add(ImageTextureAttribute, s_texture.GetName());
}
if (!rwAttrs.Exists(ImagesetAutoScaledAttribute))
{
rwAttrs.Add(ImagesetAutoScaledAttribute, s_autoScaled.ToString());
}
if (!rwAttrs.Exists(ImagesetNativeHorzResAttribute))
{
rwAttrs.Add(ImagesetNativeHorzResAttribute,
s_nativeResolution.Width.ToString(CultureInfo.InvariantCulture));
}
if (!rwAttrs.Exists(ImagesetNativeVertResAttribute))
{
rwAttrs.Add(ImagesetNativeVertResAttribute,
s_nativeResolution.Height.ToString(CultureInfo.InvariantCulture));
}
DeleteChaniedHandler = false;
ChainedHandler = Create(rwAttrs);
}
/// <summary>
/// handles the opening Mapping XML element.
/// </summary>
/// <param name="attributes"></param>
private void ElementMappingStart(XMLAttributes attributes)
{
if (_font == null)
{
throw new InvalidRequestException("Attempt to access null object.");
}
// double-check font type just in case - report issues as 'soft' errors
if (_font.GetTypeName() != FontTypePixmap)
{
System.GetSingleton().Logger.LogEvent(
"Imageset_xmlHandler::elementMappingStart: <Mapping> element is " +
"only valid for Pixmap type fonts.", LoggingLevel.Errors);
}
else
{
((PixmapFont)_font).DefineMapping(
(char)attributes.GetValueAsInteger(MappingCodepointAttribute),
attributes.GetValueAsString(MappingImageAttribute),
attributes.GetValueAsFloat(MappingHorzAdvanceAttribute, -1.0f));
}
}
public AnimationDefinitionHandler(XMLAttributes attributes, string namePrefix)
{
_anim = null;
var animName = namePrefix + attributes.GetValueAsString(NameAttribute);
Logger.LogInsane(
"Defining animation named: " +
animName +
" Duration: " +
attributes.GetValueAsString(DurationAttribute) +
" Replay mode: " +
attributes.GetValueAsString(ReplayModeAttribute) +
" Auto start: " +
attributes.GetValueAsString(AutoStartAttribute, "false"));
_anim = AnimationManager.GetSingleton().CreateAnimation(animName);
_anim.SetDuration(attributes.GetValueAsFloat(DurationAttribute));
var replayMode = attributes.GetValueAsString(ReplayModeAttribute, ReplayModeLoop);
if (replayMode == ReplayModeOnce)
{
_anim.SetReplayMode(Animation.ReplayMode.Once);
}
else if (replayMode == ReplayModeBounce)
{
_anim.SetReplayMode(Animation.ReplayMode.Bounce);
}
else
{
_anim.SetReplayMode(Animation.ReplayMode.Loop);
}
_anim.SetAutoStart(attributes.GetValueAsBool(AutoStartAttribute));
}
//! Function that handles the WindowAlias XML element.
private void elementWindowAliasStart(XMLAttributes attributes)
{
throw new NotImplementedException();
}
protected override void ElementStartLocal(string element, XMLAttributes attributes)
{
System.GetSingleton().Logger.LogEvent(" [Image] Unknown XML tag encountered: " + element);
}
