public Component(ucss.uno.XComponentContext ctx, uno.Any[] args) {
     m_args = new Any[args.Length + 1];
     m_args[0] = new Any(typeof(ucss.uno.XComponentContext), ctx);
     for (int i = 0; i < args.Length; i ++) {
         m_args[i+1] = args[i];
     }
 }

 /// <summary>
 /// Allows index operations on the array.
 /// </summary>
 /// <param name="i">Index position in the array.</param>
 /// <returns>The element in the specified position.</returns>
 public byte this[Any<int, long, uint, ulong> i]
 {
     get
     {
         return default(byte);
     }
     set
     {
     }
 }

 /// <summary>
 /// Allows index operations on the array.
 /// </summary>
 /// <param name="i">Index position in the array.</param>
 /// <returns>The element in the specified position.</returns>
 public uint this[Any<int, long, uint, ulong> i]
 {
     get
     {
         return default(uint);
     }
     set
     {
     }
 }

 /// <summary>
 /// Allows index operations on the array.
 /// </summary>
 /// <param name="i">Index position in the array.</param>
 /// <returns>The element in the specified position.</returns>
 public short this[Any<int, long, uint, ulong> i]
 {
     get
     {
         return default(short);
     }
     set
     {
     }
 }

 /// <summary>
 /// Allows index operations on the array.
 /// </summary>
 /// <param name="i">Index position in the array.</param>
 /// <returns>The element in the specified position.</returns>
 public float this[Any<int, long, uint, ulong> i]
 {
     get
     {
         return default(float);
     }
     set
     {
     }
 }

 /// <summary>
 /// Allows index operations on the array.
 /// </summary>
 /// <param name="i">Index position in the array.</param>
 /// <returns>The element in the specified position.</returns>
 public double this[Any<int, long, uint, ulong> i]
 {
     get
     {
         return default(double);
     }
     set
     {
     }
 }

 /// <summary>
 /// Sets route definition that will be used on route change when no
 /// other route definition is matched.
 /// </summary>
 /// <param name="parms">
 /// Mapping information to be assigned to $route.current. If called with
 /// a string, the value maps to redirectTo.
 /// </param>
 public RouteProvider Otherwise(Any<String, MappingInformation> parms)
 {
     return default(RouteProvider);
 }

 /*
  * Transformation matrix is described by:
  * [ a c e ]
  * [ b d f ]
  * [ 0 0 1 ]
  */
 /// <summary>
 /// Multiplies the current transformation matrix with the matrix described by its arguments.
 /// Matrix is described by a 3x3 [ a c e // b d f // 0 0 1 ] (// means a matrix line break).
 /// </summary>
 /// <param name="a">m11: Horizontal scaling.</param>
 /// <param name="b">m12: Horizontal skewing.</param>
 /// <param name="c">m21: Vertical skewing.</param>
 /// <param name="d">m22: Vertical scaling.</param>
 /// <param name="e">dx: Horizontal moving.</param>
 /// <param name="f">dy: Vertical moving.</param>
 public virtual void Transform(Any<int, double> a, Any<int, double> b, Any<int, double> c,
                               Any<int, double> d, Any<int, double> e, Any<int, double> f)
 {
     return;
 }

 /// <summary>
 /// Draws (strokes) a given text at the given (x, y) position.
 /// </summary>
 /// <param name="text">
 /// The text to render using the current font, textAlign, textBaseline, and direction values.
 /// </param>
 /// <param name="x">The x axis of the coordinate for the text starting point.</param>
 /// <param name="y">The y axis of the coordinate for the text starting point.</param>
 public virtual void StrokeText(string text, Any<uint, int> x, Any<uint, int> y)
 {
     return;
 }

 /// <summary>
 /// Sets the current line dash pattern.
 /// </summary>
 /// <param name="segments">
 /// An Array. A list of numbers that specifies distances to alternately draw a line and a gap
 /// (in coordinate space units). If the number of elements in the array is odd, the elements
 /// of the array get copied and concatenated.
 /// For example, [5, 15, 25] will become [5, 15, 25, 5, 15, 25].
 /// </param>
 public virtual void SetLineDash(Any<double[], uint[], int[], IEnumerable<Any<double, uint, int>>> segments)
 {
     return;
 }

 /// <summary>
 /// Paints data from the given ImageData object onto the bitmap. If a dirty rectangle is provided,
 /// only the pixels from that rectangle are painted.
 /// </summary>
 /// <param name="imagedata">An imageData object containing the array of pixel values.</param>
 /// <param name="dx">
 /// Position offset in the target canvas context of the rectangle to be painted, relative to the
 /// rectangle in the origin image data.
 /// </param>
 /// <param name="dy">
 /// Position offset in the target canvas context of the rectangle to be painted, relative to the
 /// rectangle in the origin image data.
 /// </param>
 /// <param name="dirtyX">
 /// Position of the top left point of the rectangle to be painted, in the origin image data.
 /// Defaults to the top left of the whole image data.
 /// </param>
 /// <param name="dirtyY">
 /// Position of the top left point of the rectangle to be painted, in the origin image data.
 /// Defaults to the top left of the whole image data.
 /// </param>
 /// <param name="dirtyWidth">
 /// Width of the rectangle to be painted, in the origin image data. Defaults to the width of the image data.
 /// </param>
 /// <param name="dirtyHeight">
 /// Height of the rectangle to be painted, in the origin image data. Defaults to the height of the image data.
 /// </param>
 public virtual void PutImageData(ImageData imagedata, int dx, int dy, 
                                  Any<uint?, int?> dirtyX, Any<uint?, int?> dirtyY, 
                                  Any<uint?, int?> dirtyWidth, Any<uint?, int?> dirtyHeight)
 {
     return;
 }

 /// <summary>
 /// Creates a linear gradient along the line given by the coordinates represented by the parameters.
 /// </summary>
 /// <param name="x0">The x axis of the coordinate of the start point.</param>
 /// <param name="y0">The y axis of the coordinate of the start point.</param>
 /// <param name="x1">The x axis of the coordinate of the end point.</param>
 /// <param name="y1">The y axis of the coordinate of the end point.</param>
 /// <returns>A linear CanvasGradient initialized with the specified line.</returns>
 public virtual CanvasGradient CreateLinearGradient(Any<uint, int, double> x0, Any<uint, int, double> y0,
                                                    Any<uint, int, double> x1, Any<uint, int, double> y1)
 {
     return null;
 }

 /// <summary>
 /// Creates a new, blank ImageData object with the specified dimensions. All of the pixels in the
 /// new object are transparent black.
 /// </summary>
 /// <param name="width">The width to give the new ImageData object.</param>
 /// <param name="height">The height to give the new ImageData object.</param>
 /// <returns>
 /// A new ImageData object with the specified width and height. The new object is filled with
 /// transparent black pixels.
 /// </returns>
 public virtual ImageData CreateImageData(Any<uint, int> width, Any<uint, int> height)
 {
     return null;
 }

 /// <summary>
 /// Creates a new Int16Array of the specified length.
 /// </summary>
 /// <param name="length">Length of array to create</param>
 public Int16Array(Any<int, long, uint, ulong> length)
 {
 }

 /// <summary>
 /// Paints data from the given ImageData object onto the bitmap. If a dirty rectangle is provided,
 /// only the pixels from that rectangle are painted.
 /// </summary>
 /// <param name="imagedata">An imageData object containing the array of pixel values.</param>
 /// <param name="dx">
 /// Position offset in the target canvas context of the rectangle to be painted, relative to the
 /// rectangle in the origin image data.
 /// </param>
 /// <param name="dy">
 /// Position offset in the target canvas context of the rectangle to be painted, relative to the
 /// rectangle in the origin image data.
 /// </param>
 /// <param name="dirtyX">
 /// Position of the top left point of the rectangle to be painted, in the origin image data.
 /// Defaults to the top left of the whole image data.
 /// </param>
 /// <param name="dirtyY">
 /// Position of the top left point of the rectangle to be painted, in the origin image data.
 /// Defaults to the top left of the whole image data.
 /// </param>
 /// <param name="dirtyWidth">
 /// Width of the rectangle to be painted, in the origin image data. Defaults to the width of the image data.
 /// </param>
 /// <param name="dirtyHeight">
 /// Height of the rectangle to be painted, in the origin image data. Defaults to the height of the image data.
 /// </param>
 public virtual void PutImageData(ImageData imagedata, int dx, int dy, Any<uint?, int?> dirtyX = null,
                                  Any<uint?, int?> dirtyY = null, Any<uint?, int?> dirtyWidth = null,
                                  Any<uint?, int?> dirtyHeight = null)
 {
     return;
 }

 /// <summary>
 /// Reports whether or not the specified point is contained in the current path.
 /// </summary>
 /// <param name="path">A Path2D path to use.</param>
 /// <param name="x">The X coordinate of the point to check.</param>
 /// <param name="y">The Y coordinate of the point to check.</param>
 /// <param name="fillRule">
 /// The algorithm by which to determine if a point is inside a path or outside a path.
 /// </param>
 /// <returns>
 /// A Boolean, which is true if the specified point is contained in the current or specfied path,
 /// otherwise false.
 /// </returns>
 public virtual bool IsPointInPath(Path2D path, Any<uint, int, double> x, Any<uint, int, double> y,
                                   CanvasTypes.CanvasFillRule? fillRule)
 {
     return false;
 }

 /// <summary>
 /// Reports whether or not the specified point is inside the area contained by the stroking of a path.
 /// </summary>
 /// <param name="path">A Path2D path to use.</param>
 /// <param name="x">The X coordinate of the point to check.</param>
 /// <param name="y">The Y coordinate of the point to check.</param>
 /// <returns>
 /// A Boolean, which is true if the point is inside the area contained by the stroking of a path,
 /// otherwise false.
 /// </returns>
 public virtual bool IsPointInStroke(Path2D path, Any<uint, int, double> x, Any<uint, int, double> y)
 {
     return false;
 }

 /// <summary>
 /// Creates a pattern using the specified image (a CanvasImageSource). It repeats the source in the
 /// directions specified by the repetition argument. This method returns a CanvasPattern.
 /// </summary>
 /// <param name="image">
 /// A CanvasImageSource to be used as image to repeat. It can either be a:
 /// • HTMLImageElement (&lt;img>),
 /// • HTMLVideoElement (&lt;video>),
 /// • HTMLCanvasElement (&lt;canvas>),
 /// • CanvasRenderingContext2D,
 /// • ImageBitmap (c# object for now),
 /// • ImageData, or a
 /// • Blob.
 /// </param>
 /// <param name="repetition"></param>
 /// <returns>An opaque CanvasPattern object describing a pattern.</returns>
 /// <remarks>
 /// At the time of implementation, ImageBitmap had no documentation and Bridge.NET did not have
 /// it defined inside.
 /// </remarks>
 public virtual CanvasPattern CreatePattern(
     Any<ImageElement, VideoElement, CanvasElement, CanvasRenderingContext2D, object, ImageData, Blob> image,
     CanvasTypes.CanvasRepetitionTypes repetition)
 {
     return null;
 }

 /// <summary>
 /// Adds a scaling transformation to the canvas units by x horizontally and by y vertically.
 /// </summary>
 /// <param name="x">Scaling factor in the horizontal direction.</param>
 /// <param name="y">Scaling factor in the vertical direction.</param>
 public virtual void Scale(Any<int, double> x, Any<int, double> y)
 {
     return;
 }

 /// <summary>
 /// Creates a radial gradient along the line given by the coordinates represented by the parameters.
 /// </summary>
 /// <param name="x0">The x axis of the coordinate of the start circle.</param>
 /// <param name="y0">The y axis of the coordinate of the start circle.</param>
 /// <param name="r0">The radius of the start circle.</param>
 /// <param name="x1">The x axis of the coordinate of the end circle.</param>
 /// <param name="y1">The y axis of the coordinate of the end circle.</param>
 /// <param name="r1">The radius of the end circle.</param>
 /// <returns>A radial CanvasGradient initialized with the two specified circles.</returns>
 public virtual CanvasGradient CreateRadialGradient(
     Any<uint, int, double> x0, Any<uint, int, double> y0, Any<uint, int, double> r0,
     Any<uint, int, double> x1, Any<uint, int, double> y1, Any<uint, int, double> r1)
 {
     return null;
 }