+2005-07-05 Iain McCoy <iain@mccoy.id.au>
+
+ * Mono.Windows.Serialization/XamlParser.cs,
+ Mono.Windows.Serialization/XamlWriter.cs,
+ Mono.Windows.Serialization/CodeWriter.cs: add support for delegate
+ properties and for events
+ * Mono.Windows.Serialization/XamlParser.cs,
+ Mono.Windows.Serialization/XamlWriter.cs,
+ Mono.Windows.Serialization/CodeWriter.cs,
+ Mono.Windows.Serialization/Mapper.cs: tighten up types so that Type
+ and PropertyInfo are passed instead of strings
+
2005-07-03 Iain McCoy <iain@mccoy.id.au>
* Mono.Windows.Serialization/XamlParser.cs: added support for Code
//
using System;
+using System.Reflection;
using System.IO;
using System.Collections;
using System.CodeDom;
// pushes: a CodeVariableReferenceExpression to the present
// instance
- public void CreateTopLevel(string parentName, string className)
+ public void CreateTopLevel(Type parent, string className)
{
- Type parent = Type.GetType(parentName);
int endNamespaceName = className.LastIndexOf(".");
string clrNamespace;
if (endNamespaceName < 0)
// bottom of stack holds CodeVariableReferenceExpression
// pushes a reference to the new current type
- public void CreateObject(string typeName)
+ public void CreateObject(Type type)
{
- Type type = Type.GetType(typeName);
string varName = Char.ToLower(type.Name[0]) + type.Name.Substring(1);
// make sure something sensible happens when class
// names start with a lowercase letter
// top of stack is a reference to an object
// pushes a reference to the property
- public void CreateProperty(string propertyName)
+ public void CreateProperty(PropertyInfo property)
{
CodePropertyReferenceExpression prop = new CodePropertyReferenceExpression(
(CodeExpression)objects[objects.Count - 1],
- propertyName);
+ property.Name);
objects.Add(prop);
}
+ // top of stack is a reference to an object
+ // pushes a reference to the event
+ public void CreateEvent(EventInfo evt)
+ {
+ CodeEventReferenceExpression expr = new CodeEventReferenceExpression(
+ (CodeExpression)objects[objects.Count - 1],
+ evt.Name);
+ objects.Add(expr);
+ }
+
// top of stack is a reference to an object
// pushes the name of the instance to attach to, the name of
// the property, and a reference to an object
- public void CreateAttachedProperty(string attachedTo, string propertyName, string typeName)
+ public void CreateAttachedProperty(Type attachedTo, string propertyName, Type propertyType)
{
- Type t = Type.GetType(typeName);
- Type typeAttachedTo = Type.GetType(attachedTo);
-
- string name = "temp";
- if (tempIndex != 0)
- name += tempIndex;
- CodeVariableDeclarationStatement decl = new CodeVariableDeclarationStatement(t, name);
+ string varName = "temp";
+ if (tempIndex != 0) {
+ varName += tempIndex;
+ tempIndex += 1;
+ }
+ CodeVariableDeclarationStatement decl = new CodeVariableDeclarationStatement(propertyType, varName);
constructor.Statements.Add(decl);
CodeMethodInvokeExpression call = new CodeMethodInvokeExpression(
- new CodeTypeReferenceExpression(typeAttachedTo),
+ new CodeTypeReferenceExpression(attachedTo),
"Set" + propertyName,
(CodeExpression)objects[objects.Count - 1],
- new CodeVariableReferenceExpression(name));
+ new CodeVariableReferenceExpression(varName));
objects.Add(call);
- objects.Add(new CodeVariableReferenceExpression(name));
+ objects.Add(new CodeVariableReferenceExpression(varName));
}
// pops 2 items: the name of the property, and the object to attach to
constructor.Statements.Add(call);
}
+ // top of stack is reference to an event
+ public void CreateEventDelegate(string functionName, Type eventDelegateType)
+ {
+ CodeExpression expr = new CodeObjectCreateExpression(
+ eventDelegateType,
+ new CodeMethodReferenceExpression(
+ new CodeThisReferenceExpression(),
+ functionName));
+ CodeAttachEventStatement attach = new CodeAttachEventStatement(
+ (CodeEventReferenceExpression)objects[objects.Count - 1],
+ expr);
+ constructor.Statements.Add(attach);
+
+ }
// top of stack is reference to a property
- public void CreatePropertyText(string text, string converter)
+ public void CreatePropertyDelegate(string functionName, Type propertyType)
{
- CreateAttachedPropertyText(text, converter);
+ CodeExpression expr = new CodeObjectCreateExpression(
+ propertyType,
+ new CodeMethodReferenceExpression(
+ new CodeThisReferenceExpression(),
+ functionName));
+ CodeAssignStatement assignment = new CodeAssignStatement(
+ (CodeExpression)objects[objects.Count - 1],
+ expr);
+ constructor.Statements.Add(assignment);
}
- public void CreateAttachedPropertyText(string text, string converter)
+ // top of stack is reference to a property
+ public void CreatePropertyText(string text, Type propertyType, Type converterType)
+ {
+ CreateAttachedPropertyText(text, propertyType, converterType);
+ }
+ // top of stack is reference to an attached property
+ public void CreateAttachedPropertyText(string text, Type propertyType, Type converterType)
{
CodeExpression expr = new CodePrimitiveExpression(text);
- if (converter != null) {
- Type t = Type.GetType(converter);
+ if (converterType != null) {
expr = new CodeCastExpression(
- new CodeTypeReference(typeof(int)),
+ new CodeTypeReference(propertyType),
new CodeMethodInvokeExpression(
- new CodeObjectCreateExpression(t),
+ new CodeObjectCreateExpression(converterType),
"ConvertFromString",
expr));
}
{
objects.RemoveAt(objects.Count - 1);
}
+
+ public void EndEvent()
+ {
+ objects.RemoveAt(objects.Count - 1);
+ }
public void Finish()
{
mappings[mapping.XmlNamespace] = mapping;
}
- public string Resolve(string clrNamespace, string classname)
+ public Type Resolve(string clrNamespace, string classname)
{
return ((Mapping)mappings[clrNamespace]).Resolve(classname);
}
get { return xmlNamespace; }
}
- public string Resolve(string className)
+ public Type Resolve(string className)
{
Assembly assembly = Assembly.Load(assemblyName);
Type type = assembly.GetType(clrNamespace + "." + className);
if (type == null) {
throw new MappingException(className, XmlNamespace);
} else {
- return type.AssemblyQualifiedName;
+ return type;
}
}
}
// the given type
bool isNameOfAncestorClass(string name, Type t)
{
+ if (name == "object")
+ return true;
while (t.BaseType != null) {
if (t.Name == name)
return true;
writer.CreateElementText(reader.Value);
} else if (currentState.type == CurrentType.AttachedProperty) {
DependencyProperty dp = (DependencyProperty)currentState.obj;
- writer.CreateAttachedPropertyText(reader.Value, getTypeConverter(dp.PropertyType));
+ writer.CreateAttachedPropertyText(reader.Value, dp.PropertyType,
+ getTypeConverter(dp.PropertyType));
} else {
PropertyInfo prop = (PropertyInfo)currentState.obj;
- writer.CreatePropertyText(reader.Value, getTypeConverter(prop.PropertyType));
+ writer.CreatePropertyText(reader.Value, prop.PropertyType,
+ getTypeConverter(prop.PropertyType));
}
}
- string getTypeConverter(Type fromType)
+ Type getTypeConverter(Type fromType)
{
// TODO: this business setting assembly is frankly
// grotesque. It should just be something along the
return null;
string converterName = "System.ComponentModel." + fromType.Name + "Converter,System.dll";
Type converter = assembly.GetType(converterName);
- return converter.AssemblyQualifiedName;
- // TODO: catch NullReferenceException and do something
- // cool
+ return converter;
+ // TODO: check if converter == null and do something cool
}
// preconditions: currentState.Type == Object
Type currentType = (Type)currentState.obj;
PropertyInfo prop = currentType.GetProperty(propertyName);
+
if (prop == null) {
Console.WriteLine("Property " + propertyName + " not found on " + currentType.Name);
return;
currentState.type = CurrentType.Property;
currentState.obj = prop;
- writer.CreateProperty(propertyName);
+ writer.CreateProperty(prop);
if (reader.HasAttributes) {
Console.WriteLine("Property node should not have attributes");
currentState.obj = dp;
currentState.type = CurrentType.AttachedProperty;
- writer.CreateAttachedProperty(typeAttachedTo.AssemblyQualifiedName,
- propertyName,
- dp.PropertyType.AssemblyQualifiedName);
+ writer.CreateAttachedProperty(typeAttachedTo, propertyName, dp.PropertyType);
}
void parseObjectElement()
{
- string parentName, objectName = null;
+ Type parent;
+ string objectName = null;
bool isEmpty = reader.IsEmptyElement;
- parentName = mapper.Resolve(reader.NamespaceURI, reader.Name);
+ parent = mapper.Resolve(reader.NamespaceURI, reader.Name);
objectName = reader.GetAttribute("Class", XAML_NAMESPACE);
- if (Type.GetType(parentName).GetInterface("System.Windows.Serialization.IAddChild") == null)
+ if (parent.GetInterface("System.Windows.Serialization.IAddChild") == null)
{} //TODO: throw exception
if (currentState == null) {
- createTopLevel(parentName, objectName);
+ createTopLevel(parent.AssemblyQualifiedName, objectName);
} else {
- addChild(parentName);
+ addChild(parent);
}
if (reader.MoveToFirstAttribute()) {
}
- if (isEmpty)
+ if (isEmpty) {
writer.EndObject();
+ pop();
+ }
+ }
+
+ void createTopLevel(string parentName, string objectName)
+ {
+ Type t = Type.GetType(parentName);
+ currentState = new ParserState();
+ currentState.type = CurrentType.Object;
+ currentState.obj = t;
+ if (objectName == null) {
+ objectName = "derived" + t.Name;
+ }
+ writer.CreateTopLevel(t, objectName);
}
+
+ void addChild(Type type)
+ {
+ writer.CreateObject(type);
+ oldStates.Add(currentState);
+ currentState = new ParserState();
+ currentState.type = CurrentType.Object;
+ currentState.obj = type;
+ }
+
void parseLocalPropertyAttribute()
{
string propertyName = reader.LocalName;
Type currentType = (Type)currentState.obj;
PropertyInfo prop = currentType.GetProperty(propertyName);
+ if (parsedAsEventProperty(currentType, propertyName))
+ return;
if (prop == null) {
Console.WriteLine("Property " + propertyName + " not found on " + currentType.Name);
return;
// TODO: throw exception
}
- writer.CreateProperty(propertyName);
- writer.CreatePropertyText(reader.Value, getTypeConverter(prop.PropertyType));
+ writer.CreateProperty(prop);
- parseEndElement();
+ if (prop.PropertyType.IsSubclassOf(typeof(Delegate)))
+ writer.CreatePropertyDelegate(reader.Value, prop.PropertyType);
+ else
+ writer.CreatePropertyText(reader.Value, prop.PropertyType, getTypeConverter(prop.PropertyType));
+
+ writer.EndProperty();
+ }
+
+ bool parsedAsEventProperty(Type currentType, string eventName)
+ {
+ EventInfo evt = currentType.GetEvent(eventName);
+ if (evt == null)
+ return false;
+ writer.CreateEvent(evt);
+ writer.CreateEventDelegate(reader.Value, evt.EventHandlerType);
+ writer.EndEvent();
+ return true;
}
+
void parseContextPropertyAttribute()
{
throw new NotImplementedException("parseContextPropertyAttribute");
else if (currentState.type == CurrentType.AttachedProperty)
writer.EndAttachedProperty();
+ pop();
+ }
+ void pop()
+ {
if (oldStates.Count == 0) {
currentState = null;
writer.Finish();
int lastIndex = oldStates.Count - 1;
currentState = (ParserState)oldStates[lastIndex];
oldStates.RemoveAt(lastIndex);
- }
- void createTopLevel(string parentName, string objectName)
- {
- Type t = Type.GetType(parentName);
- currentState = new ParserState();
- currentState.type = CurrentType.Object;
- currentState.obj = t;
- if (objectName == null) {
- objectName = "derived" + t.Name;
- }
- writer.CreateTopLevel(parentName, objectName);
}
- void addChild(string className)
- {
- writer.CreateObject(className);
- oldStates.Add(currentState);
- currentState = new ParserState();
- currentState.type = CurrentType.Object;
- currentState.obj = Type.GetType(className);
- }
}
}
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
+using System;
+using System.Reflection;
+
namespace Mono.Windows.Serialization {
public interface XamlWriter {
- void CreateTopLevel(string parentName, string className);
+ void CreateTopLevel(Type parent, string className);
- void CreateObject(string typeName);
+ void CreateObject(Type type);
void CreateElementText(string text);
void EndObject();
- void CreateProperty(string propertyName);
- void CreatePropertyText(string text, string converter);
+ void CreateProperty(PropertyInfo property);
+ void CreatePropertyText(string text, Type propertyType, Type converterType);
+ void CreatePropertyDelegate(string functionName, Type propertyType);
void EndProperty();
-
- void CreateAttachedProperty(string attachedTo, string propertyName, string typeName);
- void CreateAttachedPropertyText(string text, string converter);
+
+
+ void CreateEvent(EventInfo evt);
+ void CreateEventDelegate(string functionName, Type eventDelegateType);
+ void EndEvent();
+
+ void CreateAttachedProperty(Type attachedTo, string propertyName, Type propertyType);
+ void CreateAttachedPropertyText(string text, Type propertyType, Type converterType);
void EndAttachedProperty();
void CreateCode(string code);
+2005-07-05 Iain McCoy <iain@mccoy.id.au>
+
+ * README: describe the demo as it currently is
+ * demo/TestVocab/ConsoleWriter.cs: delegates demonstration
+ * demo/TestVocab/ConsoleApp.cs: events demonstration
+ * demo/test.xaml: include delegates and events in demonstration
+
2005-07-03 Iain McCoy <iain@mccoy.id.au>
* demo/Makefile: made more useful - just do "make run" and it should
all happen
make install
That will get everything compiled. There's a demo in the mcs/tools/xamlc/demo
-directory; to run it, cd into that directory and run make. Look at the
-resulting test.xaml.out file. That Makefile obviously has a sample invocation
-of xamlc.exe.
+directory; to run it, cd into that directory and do "make run". Stuff should
+happen, along the lines of a program test.exe being generated and run to
+produce this output:
+IT BEGINS!
+Hello World
+Goodbye.
+Goodbye.
+Goodbye.
+You should be able to see how that's made from the included test.xaml file
using System.Windows.Serialization;
namespace Xaml.TestVocab.Console {
+ public delegate void SomethingHappenedHandler();
public class ConsoleApp : IAddChild {
private ArrayList actions = new ArrayList();
+
+ public event SomethingHappenedHandler SomethingHappened;
+
public void AddText(string Text)
{
actions.Add(new ConsoleWriter(Text));
{
foreach (IConsoleAction action in actions) {
int reps = GetRepetitions((DependencyObject)action);
- for (int i = 0; i < reps; i++)
+ for (int i = 0; i < reps; i++) {
+ SomethingHappenedHandler s = SomethingHappened;
+ if (s != null)
+ s();
action.Run();
+ }
}
}
using System.Windows.Serialization;
namespace Xaml.TestVocab.Console {
+ public delegate string Filter(string s);
+
public class ConsoleWriter : DependencyObject, IAddChild, IConsoleAction {
string text;
+ private Filter filter;
public ConsoleWriter()
{
get { return text; }
set { text = value; }
}
+ public Filter Filter {
+ get { return Filter; }
+ set { filter = value; }
+ }
public void AddText(string text)
{
public void Run()
{
- System.Console.WriteLine(text);
+ Filter f = filter;
+ string s = text;
+ // apply filter, if it exists
+ if (f != null)
+ s = f(s);
+ System.Console.WriteLine(s);
}
}
}
<ConsoleApp xmlns="console"
xmlns:x="http://schemas.microsoft.com/winfx/xaml/2005"
- x:Class="DemoConsoleApp">
+ x:Class="DemoConsoleApp"
+ SomethingHappened="printHi">
<ConsoleWriter>IT BEGINS!</ConsoleWriter>
<ConsoleWriter Text="Hello World" />
+ <ConsoleWriter Text="I'm surrounded!" Filter="stringFilter" />
<ConsoleWriter>
<ConsoleApp.Repetitions>3</ConsoleApp.Repetitions>
<ConsoleWriter.Text>Goodbye.</ConsoleWriter.Text>
Xaml.TestVocab.Console.ConsoleApp c = new DemoConsoleApp();
c.Run();
}
+
+ private string stringFilter(string s)
+ {
+ return "YYY" + s + "ZZZ";
+ }
+
+ private void printHi()
+ {
+ //this code is run before every call to IConsoleAction.Run() by ConsoleApp,
+ //uncomment it to see that happening
+ //System.Console.WriteLine("Hi there, something's about to happen!");
+ }
]]></x:Code>
</ConsoleApp>
projects / mono.git / commitdiff