static internal extern Status GdipTranslateWorldTransform(IntPtr graphics, float dx, float dy, MatrixOrder order);

 public void MultiplyTransform(Matrix matrix, MatrixOrder order)
 {
     if (matrix == null)
     {
         throw new ArgumentNullException("matrix");
     }
     gradientTransform.Multiply(matrix, order);
     changed = true;
 }

 public void ScaleTransform(float sx, float sy, MatrixOrder order)
 {
     gradientTransform.Scale(sx, sy, order);
     changed = true;
 }

	public void TranslateTransform(float dx, float dy, MatrixOrder order)
			{
				lock(this)
				{
					if(transform == null)
					{
						transform = new Matrix();
					}
					transform.Translate(dx, dy, order);
					Modified();
				}
			}

 internal static extern GpStatus GdipMultiplyWorldTransform(GpGraphics graphics, GpMatrix matrix, MatrixOrder order);

 public void TranslateTransform(float tx, float ty, MatrixOrder order)
 {
     //Console.WriteLine ("Currently does not support anything but prepend mode");
     modelMatrix.Translate(tx, ty, order);
     applyModelView();
 }

	public void RotateTransform(float angle, MatrixOrder order)
			{
				lock(this)
				{
					if(transform == null)
					{
						transform = new Matrix();
					}
					transform.Rotate(angle, order);
					Modified();
				}
			}

 public void MultiplyTransform(Matrix matrix, MatrixOrder order)
 {
     if (matrix == null)
     {
         throw new ArgumentNullException("matrix");
     }
     int status = SafeNativeMethods.Gdip.GdipMultiplyPathGradientTransform(new HandleRef(this, base.NativeBrush), new HandleRef(matrix, matrix.nativeMatrix), order);
     if (status != 0)
     {
         throw SafeNativeMethods.Gdip.StatusException(status);
     }
 }

 public void TranslateTransform(float dx, float dy, MatrixOrder order)
 {
     int status = SafeNativeMethods.Gdip.GdipTranslatePathGradientTransform(new HandleRef(this, base.NativeBrush), dx, dy, order);
     if (status != 0)
     {
         throw SafeNativeMethods.Gdip.StatusException(status);
     }
 }

 internal static extern Status GdipScalePenTransform (IntPtr pen, float sx, float sy, MatrixOrder order);

 internal static extern Status GdipTranslatePenTransform (IntPtr pen, float dx, float dy, MatrixOrder order);

 internal static extern Status GdipRotatePenTransform (IntPtr pen, float angle, MatrixOrder order);

 internal static extern Status GdipMultiplyPenTransform (IntPtr pen, IntPtr matrix, MatrixOrder order);

 		internal static extern Status GdipScaleWorldTransform (IntPtr graphics, float sx, float sy, MatrixOrder order); 		

 public void RotateTransform(float angle, MatrixOrder order)
 {
     modelMatrix.Rotate(angle, order);
     applyModelView();
 }

 public void ScaleTransform(float sx, float sy, MatrixOrder order)
 {
     this._innerGraphics.ScaleTransform(sx, sy, order);
 }

 public void ScaleTransform(float sx, float sy, MatrixOrder order)
 {
     modelMatrix.Scale(sx,sy,order);
     applyModelView();
 }

 public void TranslateTransform(float dx, float dy, MatrixOrder order)
 {
     this._innerGraphics.TranslateTransform(dx, dy, order);
 }

	public void MultiplyTransform(Matrix matrix, MatrixOrder order)
			{
				lock(this)
				{
					if(transform == null)
					{
						transform = new Matrix();
					}
					transform.Multiply(matrix, order);
					Modified();
				}
			}

 internal static extern GpStatus GdipTranslatePenTransform(GpPen pen, float dx, float dy, MatrixOrder order);