From: Jean-Philippe Bruyère Date: Sat, 3 Feb 2018 05:24:28 +0000 (+0100) Subject: cairo mesh pattern, docker tests X-Git-Tag: 0.6.0~11 X-Git-Url: https://git.osiis.dedyn.io/?a=commitdiff_plain;h=11e428d0a8933bca79f0b674d5b10590be60dbbd;p=jp%2Fcrow.git cairo mesh pattern, docker tests --- diff --git a/Default.style b/Default.style index 0db6a08a..07689b50 100644 --- a/Default.style +++ b/Default.style @@ -88,6 +88,13 @@ ToolWindow { Width = 150; Height = 150; } +DocksView { + AllowDrop = true; +} +DockingView { + Focusable = true; + AllowDrag = true; +} FileDialog { Template = #Crow.FileDialog.template; Focusable = true; diff --git a/Templates/DockingView.template b/Templates/DockingView.template new file mode 100755 index 00000000..0a3b4e01 --- /dev/null +++ b/Templates/DockingView.template @@ -0,0 +1,24 @@ + + + + + + + + + + + + diff --git a/src/GraphicObjects/DockingView.cs b/src/GraphicObjects/DockingView.cs new file mode 100644 index 00000000..db11c08d --- /dev/null +++ b/src/GraphicObjects/DockingView.cs @@ -0,0 +1,166 @@ +// +// DockingView.cs +// +// Author: +// Jean-Philippe Bruyère +// +// Copyright (c) 2013-2017 Jean-Philippe Bruyère +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +using System; + +namespace Crow +{ + public class DockingView : Window + { + #region CTOR + public DockingView () : base () + { + } + #endregion + + bool isDocked = false; + Alignment docking = Alignment.Center; + + Point lastMousePos; //last known mouse pos in this control + Point undockingMousePosOrig; //mouse pos when docking was donne, use for undocking on mouse move + Rectangle savedSlot; //last undocked slot recalled when view is undocked + bool wasResizable; + + public DocksView docker; + + public override void OnLayoutChanges (LayoutingType layoutType) + { + base.OnLayoutChanges (layoutType); + + if (isDocked) + return; + + if (docker == null) + return; + + Rectangle dvCliRect = docker.ClientRectangle; + + if (layoutType == LayoutingType.X) { + if (Slot.X < docker.DockingThreshold) + dock (Alignment.Left); + else if (Slot.Right > dvCliRect.Width - docker.DockingThreshold) + dock (Alignment.Right); + }else if (layoutType == LayoutingType.Y) { + if (Slot.Y < docker.DockingThreshold) + dock (Alignment.Top); + else if (Slot.Bottom > dvCliRect.Height - docker.DockingThreshold) + dock (Alignment.Bottom); + } + } + + public override void onMouseMove (object sender, MouseMoveEventArgs e) + { + lastMousePos = e.Position; + + if (this.HasFocus && e.Mouse.IsButtonDown (MouseButton.Left) && isDocked) { + if (docking == Alignment.Left) { + if (lastMousePos.X - undockingMousePosOrig.X > docker.DockingThreshold) + undock (); + } else if (docking == Alignment.Right) { + if (undockingMousePosOrig.X - lastMousePos.X > docker.DockingThreshold) + undock (); + } else if (docking == Alignment.Top) { + if (lastMousePos.Y - undockingMousePosOrig.Y > docker.DockingThreshold) + undock (); + } else if (docking == Alignment.Bottom) { + if (undockingMousePosOrig.Y - lastMousePos.Y > docker.DockingThreshold) + undock (); + } + return; + } + + base.onMouseMove (sender, e); + } + public override void onMouseDown (object sender, MouseButtonEventArgs e) + { + base.onMouseDown (sender, e); + + if (this.HasFocus && isDocked && e.Button == MouseButton.Left) + undockingMousePosOrig = lastMousePos; + } + +// protected override void onBorderMouseEnter (object sender, MouseMoveEventArgs e) +// { +// base.onBorderMouseEnter (sender, e); +// +// if (isDocked) { +// switch (docking) { +// case Alignment.Top: +// if (this.currentDirection != Window.Direction.S) +// onBorderMouseLeave (this, null); +// break; +// case Alignment.Left: +// if (this.currentDirection != Window.Direction.E) +// onBorderMouseLeave (this, null); +// break; +// case Alignment.TopLeft: +// break; +// case Alignment.Right: +// if (this.currentDirection != Window.Direction.W) +// onBorderMouseLeave (this, null); +// break; +// case Alignment.TopRight: +// break; +// case Alignment.Bottom: +// if (this.currentDirection != Window.Direction.N) +// onBorderMouseLeave (this, null); +// break; +// case Alignment.BottomLeft: +// break; +// case Alignment.BottomRight: +// break; +// case Alignment.Center: +// break; +// default: +// break; +// } +// } +// } + + void undock () { + docker.Undock(this); + + this.Left = savedSlot.Left; + this.Top = savedSlot.Top; + this.Width = savedSlot.Width; + this.Height = savedSlot.Height; + + isDocked = false; + Resizable = wasResizable; + } + void dock (Alignment align){ + this.Left = this.Top = 0; + isDocked = true; + docking = align; + undockingMousePosOrig = lastMousePos; + savedSlot = this.LastPaintedSlot; + wasResizable = Resizable; + Resizable = false; + + docker.Dock (this, align); + } + } +} + diff --git a/src/GraphicObjects/DocksView.cs b/src/GraphicObjects/DocksView.cs new file mode 100644 index 00000000..a93bdc78 --- /dev/null +++ b/src/GraphicObjects/DocksView.cs @@ -0,0 +1,91 @@ +// +// DocksView.cs +// +// Author: +// Jean-Philippe Bruyère +// +// Copyright (c) 2013-2017 Jean-Philippe Bruyère +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +using System; +using System.Xml.Serialization; +using System.ComponentModel; +using System.Collections.Generic; + +namespace Crow +{ + public class DocksView : Group + { + List childViews = new List(); + GenericStack rootStack = null; + + public override void AddChild (GraphicObject g) + { + DockingView dv = g as DockingView; + if (g == null) + throw new Exception ("DocksView accept only DockingView as child"); + base.AddChild (g); + childViews.Add (dv); + dv.docker = this; + } + public override void RemoveChild (GraphicObject child) + { + DockingView dv = child as DockingView; + if (child == null) + throw new Exception ("DocksView accept only DockingView as child"); + base.RemoveChild (child); + childViews.Remove (dv); + dv.docker = this; + } + public void Dock (DockingView dv, Alignment pos){ + switch (pos) { + case Alignment.Top: + if (rootStack?.Orientation != Orientation.Vertical) + this.Width = Measure.Stretched; + break; + case Alignment.Bottom: + this.Width = Measure.Stretched; + break; + case Alignment.Left: + this.Height = Measure.Stretched; + break; + case Alignment.Right: + this.Height = Measure.Stretched; + break; + } + } + public void Undock (DockingView dv){ + } + + int dockingThreshold; + + [XmlAttributeAttribute][DefaultValue(10)] + public virtual int DockingThreshold { + get { return dockingThreshold; } + set { + if (dockingThreshold == value) + return; + dockingThreshold = value; + NotifyValueChanged ("DockingThreshold", dockingThreshold); + + } + } + } +} + diff --git a/src/IML/Context.cs b/src/IML/Context.cs deleted file mode 100644 index 7c34745d..00000000 --- a/src/IML/Context.cs +++ /dev/null @@ -1,204 +0,0 @@ -// -// Context.cs -// -// Author: -// Jean-Philippe Bruyère -// -// Copyright (c) 2013-2017 Jean-Philippe Bruyère -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -using System; -using System.Collections.Generic; -using System.Reflection; -using System.Reflection.Emit; -using System.Xml; - -namespace Crow.IML -{ - public class DataSourceBinding { - public bool TwoWay; - public MemberAddress Source; - public string DataSourceMember; - } - /// - /// Context while parsing IML, this will store what's needed only while parsing and not during instancing - /// - public class Context - { - public XmlTextReader reader = null; - public Type RootType = null; - - public DynamicMethod dm = null; - public ILGenerator il = null; - //public SubNodeType curSubNodeType; - public NodeStack nodesStack = new NodeStack (); - - /// store addresses of named node for name resolution at end of parsing - public Dictionary> Names = new Dictionary>(); - /// Store non datasource binding (in tree and template) by origine and orig member - public Dictionary>> Bindings = - new Dictionary>>(); - /// Store binding with name in target, will be resolved at end of parsing - public List UnresolvedTargets = new List(); - - - public Context (Type rootType) - { - RootType = rootType; - dm = new DynamicMethod ("dyn_instantiator", - CompilerServices.TObject, new Type [] { typeof (Instantiator), typeof (Interface) }, true); - il = dm.GetILGenerator (256); - - il.DeclareLocal (typeof (GraphicObject)); - il.Emit (OpCodes.Nop); - //set local GraphicObject to root object - ConstructorInfo ci = rootType.GetConstructor ( - BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, - null, Type.EmptyTypes, null); - if (ci == null) - throw new Exception ("No default parameterless constructor found in " + rootType.Name); - il.Emit (OpCodes.Newobj, ci); - il.Emit (OpCodes.Stloc_0); - CompilerServices.emitSetCurInterface (il); - } - - public NodeAddress CurrentNodeAddress { - get { - Node[] n = nodesStack.ToArray (); - Array.Reverse (n); - return new NodeAddress(n); - } - } - public Type CurrentNodeType { - get { return nodesStack.Peek().CrowType; } - } - public void StorePropertyBinding(NodeAddress origNA, string origMember, NodeAddress destNA, string destMember){ - Dictionary> nodeBindings = null; - if (Bindings.ContainsKey (origNA)) - nodeBindings = Bindings [origNA]; - else { - nodeBindings = new Dictionary> (); - Bindings [origNA] = nodeBindings; - } - - if (!nodeBindings.ContainsKey (origMember)) - nodeBindings [origMember] = new List (); - nodeBindings [origMember].Add (new MemberAddress (destNA, destMember)); - } - public void StorePropertyBinding(BindingDefinition bindDef){ - if (bindDef.HasUnresolvedTargetName) { - UnresolvedTargets.Add (bindDef); - return; - } - StorePropertyBinding (bindDef.TargetNA, bindDef.TargetMember, bindDef.SourceNA, bindDef.SourceMember); - if (bindDef.TwoWay) - StorePropertyBinding (bindDef.SourceNA, bindDef.SourceMember, bindDef.TargetNA, bindDef.TargetMember); - } - public void StoreCurrentName(string name){ - if (!Names.ContainsKey(name)) - Names[name] = new List(); - Names[name].Add(CurrentNodeAddress); - } - public void ResolveNamedTargets(){//TODO:methodinfo fetching is redundant with early parsing - foreach (BindingDefinition bd in UnresolvedTargets) { - if (bd.HasUnresolvedTargetName) { - try { - ResolveName (bd); - } catch (Exception ex) { - System.Diagnostics.Debug.WriteLine (ex.ToString ()); - continue; - } - } - - if (bd is EventBinding) { - emitHandlerMethodAddition (bd as EventBinding); - continue; - } - - MemberInfo miSource = bd.SourceMemberAddress.member; - if (miSource == null) - throw new Exception ("Source member '" + bd.SourceMember + "' not found"); - StorePropertyBinding (bd); - } - } - public void ResolveName (BindingDefinition bd){ - - if (!Names.ContainsKey (bd.TargetName)) - throw new Exception ("Target Name '" + bd.TargetName + "' not found"); - - NodeAddress resolvedNA = null; - foreach (NodeAddress na in Names[bd.TargetName]) { - bool naMatch = true; - for (int i = 0; i < bd.TargetNA.Count; i++) { - if (bd.TargetNA [i] != na [i]) { - naMatch = false; - break; - } - } - if (naMatch) { - resolvedNA = na; - break; - } - } - - if (resolvedNA == null) - throw new Exception ("Target Name '" + bd.TargetName + "' not found"); - - bd.ResolveTargetName (resolvedNA); - } - - /// - /// Emits cached delegate handler addition in the context of instantiator (ctx) - /// - public void emitCachedDelegateHandlerAddition(int index, EventInfo evt, NodeAddress address = null){ - il.Emit(OpCodes.Ldloc_0);//load ref to current graphic object - CompilerServices.emitGetInstance (il, address); - il.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack - il.Emit(OpCodes.Ldfld, CompilerServices.fiCachedDel); - il.Emit(OpCodes.Ldc_I4, index);//load delegate index - il.Emit(OpCodes.Callvirt, CompilerServices.miGetDelegateListItem); - il.Emit(OpCodes.Callvirt, evt.AddMethod);//call add event - } - /// - /// Emits the handler method addition, done at end of parsing, Loc_0 is root node instance - /// - /// Bd. - /// passed as arg to prevent refetching it for the 3rd time - public void emitHandlerMethodAddition(EventBinding bd){ - //fetch source instance with address for handler addition (as 1st arg of handler.add) - il.Emit (OpCodes.Ldloc_0);//push root - CompilerServices.emitGetInstance (il, bd.SourceNA); - - //load handlerType of sourceEvent to create handler delegate (1st arg) - il.Emit (OpCodes.Ldtoken, bd.SourceEvent.EventHandlerType); - il.Emit (OpCodes.Call, CompilerServices.miGetTypeFromHandle); - //load target the where the method is defined (2nd arg) - il.Emit (OpCodes.Ldloc_0); - CompilerServices.emitGetInstance (il, bd.TargetNA); - //load methodInfo (3rd arg) - il.Emit (OpCodes.Ldstr, bd.TargetMember); - - il.Emit (OpCodes.Callvirt, CompilerServices.miCreateDel); - - il.Emit (OpCodes.Callvirt, bd.SourceEvent.AddMethod);//call add event - } - - } -} \ No newline at end of file diff --git a/src/IML/IMLContext.cs b/src/IML/IMLContext.cs new file mode 100644 index 00000000..c8527087 --- /dev/null +++ b/src/IML/IMLContext.cs @@ -0,0 +1,204 @@ +// +// Context.cs +// +// Author: +// Jean-Philippe Bruyère +// +// Copyright (c) 2013-2017 Jean-Philippe Bruyère +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. + +using System; +using System.Collections.Generic; +using System.Reflection; +using System.Reflection.Emit; +using System.Xml; + +namespace Crow.IML +{ + public class DataSourceBinding { + public bool TwoWay; + public MemberAddress Source; + public string DataSourceMember; + } + /// + /// Context while parsing IML, this will store what's needed only while parsing and not during instancing + /// + public class IMLContext + { + public XmlTextReader reader = null; + public Type RootType = null; + + public DynamicMethod dm = null; + public ILGenerator il = null; + //public SubNodeType curSubNodeType; + public NodeStack nodesStack = new NodeStack (); + + /// store addresses of named node for name resolution at end of parsing + public Dictionary> Names = new Dictionary>(); + /// Store non datasource binding (in tree and template) by origine and orig member + public Dictionary>> Bindings = + new Dictionary>>(); + /// Store binding with name in target, will be resolved at end of parsing + public List UnresolvedTargets = new List(); + + + public IMLContext (Type rootType) + { + RootType = rootType; + dm = new DynamicMethod ("dyn_instantiator", + CompilerServices.TObject, new Type [] { typeof (Instantiator), typeof (Interface) }, true); + il = dm.GetILGenerator (256); + + il.DeclareLocal (typeof (GraphicObject)); + il.Emit (OpCodes.Nop); + //set local GraphicObject to root object + ConstructorInfo ci = rootType.GetConstructor ( + BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public, + null, Type.EmptyTypes, null); + if (ci == null) + throw new Exception ("No default parameterless constructor found in " + rootType.Name); + il.Emit (OpCodes.Newobj, ci); + il.Emit (OpCodes.Stloc_0); + CompilerServices.emitSetCurInterface (il); + } + + public NodeAddress CurrentNodeAddress { + get { + Node[] n = nodesStack.ToArray (); + Array.Reverse (n); + return new NodeAddress(n); + } + } + public Type CurrentNodeType { + get { return nodesStack.Peek().CrowType; } + } + public void StorePropertyBinding(NodeAddress origNA, string origMember, NodeAddress destNA, string destMember){ + Dictionary> nodeBindings = null; + if (Bindings.ContainsKey (origNA)) + nodeBindings = Bindings [origNA]; + else { + nodeBindings = new Dictionary> (); + Bindings [origNA] = nodeBindings; + } + + if (!nodeBindings.ContainsKey (origMember)) + nodeBindings [origMember] = new List (); + nodeBindings [origMember].Add (new MemberAddress (destNA, destMember)); + } + public void StorePropertyBinding(BindingDefinition bindDef){ + if (bindDef.HasUnresolvedTargetName) { + UnresolvedTargets.Add (bindDef); + return; + } + StorePropertyBinding (bindDef.TargetNA, bindDef.TargetMember, bindDef.SourceNA, bindDef.SourceMember); + if (bindDef.TwoWay) + StorePropertyBinding (bindDef.SourceNA, bindDef.SourceMember, bindDef.TargetNA, bindDef.TargetMember); + } + public void StoreCurrentName(string name){ + if (!Names.ContainsKey(name)) + Names[name] = new List(); + Names[name].Add(CurrentNodeAddress); + } + public void ResolveNamedTargets(){//TODO:methodinfo fetching is redundant with early parsing + foreach (BindingDefinition bd in UnresolvedTargets) { + if (bd.HasUnresolvedTargetName) { + try { + ResolveName (bd); + } catch (Exception ex) { + System.Diagnostics.Debug.WriteLine (ex.ToString ()); + continue; + } + } + + if (bd is EventBinding) { + emitHandlerMethodAddition (bd as EventBinding); + continue; + } + + MemberInfo miSource = bd.SourceMemberAddress.member; + if (miSource == null) + throw new Exception ("Source member '" + bd.SourceMember + "' not found"); + StorePropertyBinding (bd); + } + } + public void ResolveName (BindingDefinition bd){ + + if (!Names.ContainsKey (bd.TargetName)) + throw new Exception ("Target Name '" + bd.TargetName + "' not found"); + + NodeAddress resolvedNA = null; + foreach (NodeAddress na in Names[bd.TargetName]) { + bool naMatch = true; + for (int i = 0; i < bd.TargetNA.Count; i++) { + if (bd.TargetNA [i] != na [i]) { + naMatch = false; + break; + } + } + if (naMatch) { + resolvedNA = na; + break; + } + } + + if (resolvedNA == null) + throw new Exception ("Target Name '" + bd.TargetName + "' not found"); + + bd.ResolveTargetName (resolvedNA); + } + + /// + /// Emits cached delegate handler addition in the context of instantiator (ctx) + /// + public void emitCachedDelegateHandlerAddition(int index, EventInfo evt, NodeAddress address = null){ + il.Emit(OpCodes.Ldloc_0);//load ref to current graphic object + CompilerServices.emitGetInstance (il, address); + il.Emit(OpCodes.Ldarg_0);//load ref to this instanciator onto the stack + il.Emit(OpCodes.Ldfld, CompilerServices.fiCachedDel); + il.Emit(OpCodes.Ldc_I4, index);//load delegate index + il.Emit(OpCodes.Callvirt, CompilerServices.miGetDelegateListItem); + il.Emit(OpCodes.Callvirt, evt.AddMethod);//call add event + } + /// + /// Emits the handler method addition, done at end of parsing, Loc_0 is root node instance + /// + /// Bd. + /// passed as arg to prevent refetching it for the 3rd time + public void emitHandlerMethodAddition(EventBinding bd){ + //fetch source instance with address for handler addition (as 1st arg of handler.add) + il.Emit (OpCodes.Ldloc_0);//push root + CompilerServices.emitGetInstance (il, bd.SourceNA); + + //load handlerType of sourceEvent to create handler delegate (1st arg) + il.Emit (OpCodes.Ldtoken, bd.SourceEvent.EventHandlerType); + il.Emit (OpCodes.Call, CompilerServices.miGetTypeFromHandle); + //load target the where the method is defined (2nd arg) + il.Emit (OpCodes.Ldloc_0); + CompilerServices.emitGetInstance (il, bd.TargetNA); + //load methodInfo (3rd arg) + il.Emit (OpCodes.Ldstr, bd.TargetMember); + + il.Emit (OpCodes.Callvirt, CompilerServices.miCreateDel); + + il.Emit (OpCodes.Callvirt, bd.SourceEvent.AddMethod);//call add event + } + + } +} \ No newline at end of file diff --git a/src/Mono.Cairo/MeshPattern.cs b/src/Mono.Cairo/MeshPattern.cs new file mode 100644 index 00000000..b14c709b --- /dev/null +++ b/src/Mono.Cairo/MeshPattern.cs @@ -0,0 +1,98 @@ +// +// Mono.Cairo.Pattern.cs +// +// Author: Jordi Mas (jordi@ximian.com) +// Hisham Mardam Bey (hisham.mardambey@gmail.com) +// (C) Ximian Inc, 2004. +// +// Copyright (C) 2004 Novell, Inc (http://www.novell.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +using System; + +namespace Cairo { + + public class MeshPattern : Pattern + { + internal MeshPattern (IntPtr handle, bool owned) : base (handle, owned) + { + } + + public MeshPattern () + : base (NativeMethods.cairo_pattern_create_mesh(), true) + { + } + + //no idea why this is here, the base one is identical, but we can't remove it now + public new Extend Extend { + set { NativeMethods.cairo_pattern_set_extend (Handle, value); } + get { return NativeMethods.cairo_pattern_get_extend (Handle); } + } + + public Filter Filter { + set { NativeMethods.cairo_pattern_set_filter (Handle, value); } + get { return NativeMethods.cairo_pattern_get_filter (Handle); } + } + + public void BeginPatch(){ + NativeMethods.cairo_mesh_pattern_begin_patch (Handle); + } + public void EndPatch(){ + NativeMethods.cairo_mesh_pattern_end_patch (Handle); + } + public void MoveTo(double x, double y){ + NativeMethods.cairo_mesh_pattern_move_to (Handle, x, y); + } + public void LineTo(double x, double y){ + NativeMethods.cairo_mesh_pattern_line_to (Handle, x, y); + } + public void CurveTo(double x1, double y1, double x2, double y2, double x3, double y3) + { + NativeMethods.cairo_mesh_pattern_curve_to (Handle, x1, y1, x2, y2, x3, y3); + } + public void SetControlPoint(uint point_num, double x, double y){ + NativeMethods.cairo_mesh_pattern_set_control_point (Handle, point_num, x, y); + } + public void SetCornerColorRGB(uint corner_num, double r, double g, double b){ + NativeMethods.cairo_mesh_pattern_set_corner_color_rgb (Handle, corner_num, r, g, b); + } + public void SetCornerColorRGBA(uint corner_num, double r, double g, double b, double a){ + NativeMethods.cairo_mesh_pattern_set_corner_color_rgba (Handle, corner_num, r, g, b, a); + } + public uint PatchCount { + get { + uint count = 0; + NativeMethods.cairo_mesh_pattern_get_patch_count(Handle, out count); + return count; + } + } + public Path GetPath(uint patch_num){ + return new Path(NativeMethods.cairo_mesh_pattern_get_path(Handle, patch_num)); + } + public void GetControlPoint(){ + } + public void GetCornerColorRGBA(){ + + } + } +} + diff --git a/src/Mono.Cairo/NativeMethods.cs b/src/Mono.Cairo/NativeMethods.cs index 8286e2c2..53501369 100644 --- a/src/Mono.Cairo/NativeMethods.cs +++ b/src/Mono.Cairo/NativeMethods.cs @@ -445,6 +445,51 @@ namespace Cairo [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] internal static extern Status cairo_pattern_status (IntPtr pattern); + + //mesh pattern + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern IntPtr cairo_pattern_create_mesh (); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_begin_patch (IntPtr pattern); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_end_patch (IntPtr pattern); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_move_to (IntPtr pattern, double x, double y); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_line_to (IntPtr pattern, double x, double y); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_curve_to (IntPtr pattern, double x1, double y1, + double x2, double y2, double x3, double y3); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_set_control_point (IntPtr pattern, uint point_num, double x, double y); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_set_corner_color_rgb (IntPtr pattern, uint corner_num, + double r, double g, double b); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern void cairo_mesh_pattern_set_corner_color_rgba (IntPtr pattern, uint corner_num, + double r, double g, double b, double a); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern Status cairo_mesh_pattern_get_patch_count (IntPtr pattern, out uint count); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern IntPtr cairo_mesh_pattern_get_path (IntPtr pattern, uint patch_num); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern Status cairo_mesh_pattern_get_control_point (IntPtr pattern, + uint patch_num, uint point_num, out double x, out double y); + + [DllImport (cairo, CallingConvention=CallingConvention.Cdecl)] + internal static extern Status cairo_mesh_pattern_get_corner_color_rgba (IntPtr pattern, + uint patch_num, uint point_num, out double r, out double g, out double b, out double a); #endregion #region PdfSurface diff --git a/src/Mono.Cairo/PatternType.cs b/src/Mono.Cairo/PatternType.cs index 002469ff..8fe2d85d 100644 --- a/src/Mono.Cairo/PatternType.cs +++ b/src/Mono.Cairo/PatternType.cs @@ -37,6 +37,8 @@ namespace Cairo { Surface, Linear, Radial, + Mesh, + RasterSource } }