using System;

using System.Net;

using System.Windows;

using System.Windows.Controls;

using System.Windows.Documents;

using System.Windows.Ink;

using System.Windows.Input;

using System.Windows.Media;

using System.Windows.Media.Animation;

using System.Windows.Shapes;

namespace Ecrion.Silverlight.Sample.Plugin

{

  public class Util

   {

      /// <summary>

      /// calculate inverse of a matrix

      /// </summary>

      /// <param name="matrix">matrix</param>

      /// <returns>matrix inverse</returns>

      public static Matrix Inverse(Matrix matrix)

       {

          Matrix result = Matrix.Identity;

          double m11 = matrix.M11;

          double m12 = matrix.M12;

          double m21 = matrix.M21;

          double m22 = matrix.M22;

          double offsetX = matrix.OffsetX;

          double offsetY = matrix.OffsetY;

          double det = m11 * m22 - m12 * m21;

          if (det == 0)

              return result; //return identity matrix

           result = new Matrix(m22 / det, -m12 / det, -m21 / det, m11 / det, (-m22 * offsetX + m21 * offsetY) / det, (m12 * offsetX - m11 * offsetY) / det);

          return result;

       }

      /// <summary>

      /// multiply to matrix

      /// </summary>

      /// <param name="firstMatrix">first matrix to multiply</param>

      /// <param name="secondMatrix">second matri to multiply</param>

      /// <returns>multiply result</returns>

      public static Matrix Multiply(Matrix firstMatrix, Matrix secondMatrix)

       {

          return new Matrix(firstMatrix.M11 * secondMatrix.M11 + firstMatrix.M12 * secondMatrix.M21,

                           firstMatrix.M11 * secondMatrix.M12 + firstMatrix.M12 * secondMatrix.M22,

                           firstMatrix.M21 * secondMatrix.M11 + firstMatrix.M22 * secondMatrix.M21,

                           firstMatrix.M21 * secondMatrix.M12 + firstMatrix.M22 * secondMatrix.M22,

                           firstMatrix.OffsetX * secondMatrix.M11 + firstMatrix.OffsetY * secondMatrix.M21 + secondMatrix.OffsetX,

                           firstMatrix.OffsetX * secondMatrix.M12 + firstMatrix.OffsetY * secondMatrix.M22 + secondMatrix.OffsetY);

       }

      /// <summary>

      /// invert a brush (solid brush or gradient brush)

      /// </summary>

      /// <param name="brush">brush to be inverted</param>

      /// <returns>inverted brush</returns>

      public static Brush BrushInvert(Brush brush)

       {

          Brush brushInvert = null;

          if (brush.GetType() == typeof(SolidColorBrush))

           {

              Color color = ((SolidColorBrush)brush).Color;

               color.A = 255;

               color.R = (byte)(255 - color.R);

               color.G = (byte)(255 - color.G);

               color.B = (byte)(255 - color.B);

               brushInvert = new SolidColorBrush(color);

               brushInvert.Opacity = brush.Opacity;

              return brushInvert;

           }

          if (brush.GetType() == typeof(LinearGradientBrush))

           {

              LinearGradientBrush linearGradientBrush = (LinearGradientBrush)brush;

              LinearGradientBrush linearGradientBrushInvert = new LinearGradientBrush();

               linearGradientBrushInvert.StartPoint = linearGradientBrush.StartPoint;

               linearGradientBrushInvert.EndPoint = linearGradientBrush.EndPoint;

               linearGradientBrushInvert.ColorInterpolationMode = linearGradientBrush.ColorInterpolationMode;

               linearGradientBrushInvert.MappingMode = linearGradientBrush.MappingMode;

               linearGradientBrushInvert.SpreadMethod = linearGradientBrush.SpreadMethod;

               linearGradientBrushInvert.Opacity = linearGradientBrush.Opacity;

               linearGradientBrushInvert.RelativeTransform = linearGradientBrush.RelativeTransform;

              foreach (GradientStop gradientStop in linearGradientBrush.GradientStops)

               {

                  GradientStop gradientStopInvert = new GradientStop();

                   gradientStopInvert.Offset = gradientStop.Offset;

                  Color color = new Color();

                   color.A = gradientStop.Color.A;

                   color.R = (byte)(255 - gradientStop.Color.R);

                   color.G = (byte)(255 - gradientStop.Color.G);

                   color.B = (byte)(255 - gradientStop.Color.B);

                   gradientStopInvert.Color = color;

                   linearGradientBrushInvert.GradientStops.Add(gradientStopInvert);

               }

              return linearGradientBrushInvert;

           }

          return new SolidColorBrush();

       }

      /// <summary>

      /// create brush clone

      /// </summary>

      /// <param name="brush">brush to be cloned</param>

      /// <returns>brush cloned</returns>

      public static Brush BrushClone(Brush brush)

       {

          if (brush.GetType() == typeof(SolidColorBrush))

           {

              SolidColorBrush brushClone = null;

              Color color = new Color();

               color.A = ((SolidColorBrush)brush).Color.A;

               color.R = ((SolidColorBrush)brush).Color.R;

               color.G = ((SolidColorBrush)brush).Color.G;

               color.B = ((SolidColorBrush)brush).Color.B;

               brushClone = new SolidColorBrush(color);

               brushClone.Opacity = brush.Opacity;

              return brushClone;

           }

          if (brush.GetType() == typeof(LinearGradientBrush))

           {

              LinearGradientBrush linearGradientBrush = (LinearGradientBrush)brush;

              LinearGradientBrush linearGradientBrushInvert = new LinearGradientBrush();

               linearGradientBrushInvert.StartPoint = linearGradientBrush.StartPoint;

               linearGradientBrushInvert.EndPoint = linearGradientBrush.EndPoint;

               linearGradientBrushInvert.ColorInterpolationMode = linearGradientBrush.ColorInterpolationMode;

               linearGradientBrushInvert.MappingMode = linearGradientBrush.MappingMode;

               linearGradientBrushInvert.SpreadMethod = linearGradientBrush.SpreadMethod;

               linearGradientBrushInvert.Opacity = linearGradientBrush.Opacity;

               linearGradientBrushInvert.RelativeTransform = linearGradientBrush.RelativeTransform;

              foreach (GradientStop gradientStop in linearGradientBrush.GradientStops)

               {

                  GradientStop gradientStopInvert = new GradientStop();

                   gradientStopInvert.Offset = gradientStop.Offset;

                  Color color = new Color();

                   color.A = gradientStop.Color.A;

                   color.R = gradientStop.Color.R;

                   color.G = gradientStop.Color.G;

                   color.B = gradientStop.Color.B;

                   gradientStopInvert.Color = color;

                   linearGradientBrushInvert.GradientStops.Add(gradientStopInvert);

               }

              return linearGradientBrushInvert;

           }

          return new SolidColorBrush(Colors.Yellow);

       }

   }

}