public AimGraphic(IGraphic graphic, IAimAnnotationInstance annotationInstance, int shapeIdentifier)
			: base(graphic)
		{
			_annotationInstance = annotationInstance;
			_shapeIdentifier = shapeIdentifier;
			_graphic = graphic;
		}

		/// <summary>
		/// Constructs a new <see cref="ControlPointsGraphic"/> to control the given subject graphic.
		/// </summary>
		/// <param name="subject">The graphic to control.</param>
		public ControlPointsGraphic(IGraphic subject)
			: base(subject)
		{
			_stretchingToken = new CursorToken(CursorToken.SystemCursors.Cross);

			Initialize();
		}

 public AimGraphic(IGraphic graphic, aim_dotnet.ImageAnnotation imageAnnotation, int shapeIdentifier)
     : base(graphic)
 {
     _imageAnnotation = imageAnnotation;
     _shapeIdentifier = shapeIdentifier;
     _graphic = graphic;
 }

		/// <summary>
		/// Constructs a new <see cref="BoundableResizeControlGraphic"/>.
		/// </summary>
		/// <param name="fixedAspectRatio">The width to height aspect ratio that constrains the movement of the resize control points, or null if the movement should not be constrained.</param>
		/// <param name="subject">An <see cref="IBoundableGraphic"/> or an <see cref="IControlGraphic"/> chain whose subject is an <see cref="IBoundableGraphic"/>.</param>
		public BoundableResizeControlGraphic(float? fixedAspectRatio, IGraphic subject)
			: this(subject)
		{
			if (fixedAspectRatio.HasValue)
				Platform.CheckPositive(fixedAspectRatio.Value, "fixedAspectRatio");
			_fixedAspectRatio = fixedAspectRatio;
		}

		/// <summary>
		/// Constructs an instance of a <see cref="ContextMenuControlGraphic"/> with the specified initial context menu actions.
		/// </summary>
		/// <param name="namespace">The namespace to qualify the <paramref name="site"/>.</param>
		/// <param name="site">The action model site for the context menu (see <see cref="ActionPath.Site"/>).</param>
		/// <param name="actions">The set of actions on the context menu.</param>
		/// <param name="subject">The subject graphic.</param>
		public ContextMenuControlGraphic(string @namespace, string site, IActionSet actions, IGraphic subject)
			: base(subject)
		{
			_namespace = @namespace;
			_site = site;
			_actions = actions;
		}

		/// <summary>
		/// Initializes a new instance of <see cref="SpatialTransform"/>.
		/// </summary>
		public SpatialTransform(IGraphic ownerGraphic)
		{
			_ownerGraphic = ownerGraphic;
			_recalculationRequired = true;
			_updatingScaleParameters = false;
			Initialize();
		}

		/// <summary>
		/// Constructs a new <see cref="TextPlaceholderControlGraphic"/>.
		/// </summary>
		/// <param name="subject">An <see cref="ITextGraphic"/> or an <see cref="IControlGraphic"/> chain whose subject is an <see cref="ITextGraphic"/>.</param>
		public TextPlaceholderControlGraphic(IGraphic subject)
			: base(subject)
		{
			Platform.CheckExpectedType(base.Subject, typeof (ITextGraphic));

			Initialize();
		}

 public void RenderImage(IGraphic img, Vector2 pos)
 {
     Image ui = img.MakeImage();
     RenderCanvas.Children.Add(ui);
     Canvas.SetLeft(ui, pos.X);
     Canvas.SetTop(ui, pos.Y);
 }

	public override void AddToLayout(IGraphic trans)
	{
		int cWidth = Frame.Width;
		int cHeight = Frame.Height;
		int left = 0;	// WAA - Container.Origin.X;
		int numElements = Container.CountGraphics();
		int fixedHeight = (cHeight - ((numElements - 1) * fGap)) / (numElements);
		int collectiveHeight=0;
		bool normalize = false;

		// First figure out the collective height
		foreach (IGraphic g in Container.GraphicChildren)
			collectiveHeight += g.Frame.Height;
		collectiveHeight += fGap * (numElements - 1);

		if (collectiveHeight > cHeight)
			normalize = true;

		int currentY = 0; // WAA - Container.Origin.Y;

		foreach (IGraphic g in Container.GraphicChildren)
		{
			if (normalize)
			{
				g.ResizeTo(cWidth, fixedHeight);
			} else
			{
				g.ResizeTo(cWidth, g.Frame.Height);
			}

			g.MoveTo(left + fMargin, currentY);
			currentY = g.Frame.Bottom + fGap;
		}
	}

		/// <summary>
		/// Initializes a new instance of <see cref="MammographyImageSpatialTransform"/> with the specified image plane details.
		/// </summary>
		public MammographyImageSpatialTransform(IGraphic ownerGraphic, int rows, int columns, double pixelSpacingX, double pixelSpacingY, double pixelAspectRatioX, double pixelAspectRatioY, PatientOrientation patientOrientation, string laterality)
			: base(ownerGraphic, rows, columns, pixelSpacingX, pixelSpacingY, pixelAspectRatioX, pixelAspectRatioY)
		{
			// image coordinates are defined with X and Y being equivalent to the screen axes (right and down) and with Z = X cross Y (into the screen)

			Vector3D imagePosterior, imageHead, imageLeft; // patient orientation vectors in image space
			GetPatientOrientationVectors(patientOrientation, out imageHead, out imageLeft, out imagePosterior);

			// no adjustments if the posterior direction is not represented in the image
			if ((_imagePosterior = imagePosterior) != null)
			{
				Vector3D normativePosterior, normativeHead, normativeLeft; // normative patient orientation vectors in image space
				GetNormativeOrientationVectors(laterality, out normativeHead, out normativeLeft, out normativePosterior);

				// only do any adjustments if laterality implies a normative orientation for the posterior direction
				if (normativePosterior != null)
				{
					// check if the order of the patient vectors are flipped according to the normative vectors
					// we know we need to flip if the direction vector cross products have different signs
					if (imageHead != null)
						FlipX = _coreFlipX = Math.Sign(imagePosterior.Cross(imageHead).Z) != Math.Sign(normativePosterior.Cross(normativeHead).Z);
					else if (imageLeft != null)
						FlipX = _coreFlipX = Math.Sign(imagePosterior.Cross(imageLeft).Z) != Math.Sign(normativePosterior.Cross(normativeLeft).Z);

					// with flip normalized, just rotate to align the current posterior direction with the normative posterior
					var currentPosterior = GetCurrentPosteriorVector(_imagePosterior, SourceWidth, AdjustedSourceHeight, 0, 1, 1, _coreFlipX, false);
					var posteriorAngle = Math.Atan2(currentPosterior.Y, currentPosterior.X);
					var normativeAngle = Math.Atan2(normativePosterior.Y, normativePosterior.X);

					// compute required rotation, rounded to multiples of 90 degrees (PI/2 radians)
					RotationXY = _coreRotation = 90*((int) Math.Round((normativeAngle - posteriorAngle)*2/Math.PI));
				}
			}
		}

 public static XElement GraphicToXml(IGraphic g)
 {
     XElement node = new XElement("IS3Graphic",
         new XAttribute("DGObjID", g.DGObjID.ToString()),
         new XAttribute("Geometry",g.Geometry.ToJson()));
     return node;
 }

		public RemoveGraphicCommand(IGraphic graphic)
		{
			Platform.CheckForNullReference(graphic, "graphic");

			_graphic = graphic;
			Validate();
		}

        internal static IMarkup GraphicToIMarkup(IGraphic graphic)
        {
            if (graphic == null || graphic.ParentPresentationImage == null)
                return null;

            var markup = DoGraphicToIMarkup(graphic);

            if (markup != null)
            {
                var sopInstanceUid = string.Empty;
                var frameNumber = 1;

                try
                {
                    if (graphic.ParentPresentationImage is IImageSopProvider)
                    {
                        var imageSopProvider = graphic.ParentPresentationImage as IImageSopProvider;

                        sopInstanceUid = imageSopProvider.ImageSop.SopInstanceUid;
                        frameNumber = imageSopProvider.Frame.FrameNumber;
                    }
                    else if (!string.IsNullOrEmpty(graphic.ParentPresentationImage.Uid))
                        sopInstanceUid = graphic.ParentPresentationImage.Uid;
                }
                catch (Exception)
                {
                }
                markup.PresentationImageUid = sopInstanceUid;
                markup.FrameNumber = frameNumber;
                markup.IncludeInAnnotation = true;
                markup.GraphicHashcode = graphic.GetHashCode();
            }

            return markup;
        }

        public MainPresenter(IGraphic graphic, IFileManager manager, IMessageService messageService)
        {
            _manager = manager;
            _messageService = messageService;
            _graphic = graphic;

            _graphic.FileOpenClick += _graphic_FileOpenClick;
        }

		private static void Flash(IGraphic graphic)
		{
			if (graphic is IVectorGraphic)
			{
				DoFlashDelegate doFlashDelegate = DoFlash;
				doFlashDelegate.BeginInvoke((IVectorGraphic) graphic, SynchronizationContext.Current, delegate(IAsyncResult result) { doFlashDelegate.EndInvoke(result); }, null);
			}
		}

        public GraphicWindow(string title, int x, int y, int width, int height)
			:base(title,x,y,width,height)
		{
			fActiveGraphic = null;
			//fMouseTrackerGraphic = null;
            fChildList = new List<IGraphic>();
            fLayoutManager = LayoutManager.Empty;
        }

		public AddGraphicCommand(IGraphic graphic, GraphicCollection parentCollection)
		{
			Platform.CheckForNullReference(graphic, "graphic");
			Platform.CheckForNullReference(parentCollection, "parentCollection");

			_parentCollection = parentCollection;
			_graphic = graphic;
		}

		//public event System.EventHandler ValueChangedEvent;

		public TrackSlider(string name, IGraphic track, IGraphic thumb,
						Orientation orient,
						float min, float max, 
						float initialValue)
			: base(name, 0,0,0,0)
		{
			fTrackGraphic = track;
			fThumbGraphic = thumb;
			fOrientation = orient;

			fMin = min;
			fMax = max;
			fCurrentValue = initialValue;
			fPosition = initialValue;

			int yoffset = 0;
			int xoffset = 0;
			int trackyoffset = 0;
			int trackxoffset = 0;
	
			if ((track==null) || (thumb==null))
				return ;
		
			AddGraphic(fTrackGraphic, null);
			AddGraphic(fThumbGraphic, null);

			if (orient == Orientation.Horizontal)
			{
				// Must align thumb vertically with track.
				int midy = fTrackGraphic.Frame.Top + (fTrackGraphic.Frame.Height+1)/2;
				int thumbHeight = fThumbGraphic.Frame.Height+1;
				yoffset = midy - (thumbHeight / 2);
				xoffset = fTrackGraphic.Frame.Left;
			} 
			else
			{
				// Must align thumb horizontally with track.
				int midx = Frame.Left+(Frame.Width+1)/2;
				int thumbWidth = fThumbGraphic.Frame.Width+1;
				int trackWidth = fTrackGraphic.Frame.Width+1;
				xoffset = midx - (thumbWidth / 2);
				yoffset = fTrackGraphic.Frame.Top;

				trackxoffset = midx - (trackWidth/2);
				trackyoffset = fTrackGraphic.Frame.Top;
		
				fTrackGraphic.MoveTo(trackxoffset, trackyoffset);
			}
	
			fThumbGraphic.MoveTo(xoffset,yoffset);
			RectangleI newFrame = fTrackGraphic.Frame;
			//newFrame.Union(fThumbGraphic.Frame);
			Frame = newFrame;

            SetValue(initialValue, false);
		}

		public InsertGraphicCommand(IGraphic graphic, GraphicCollection parentCollection, int index)
		{
			Platform.CheckForNullReference(graphic, "graphic");
			Platform.CheckForNullReference(parentCollection, "parentCollection");
			Platform.CheckTrue(index >= 0, "Insert index positive");

			_parentCollection = parentCollection;
			_graphic = graphic;
			_index = index;
		}

 public MainMenu(IGraphic graphObject)
   : base(graphObject)
 {
   Buttons = new Dictionary<Button, ButtonParams>
               {
                 {
                   Button.NewGame, new ButtonParams
                                     {
                                       Image = Res.Buttons[Button.NewGame],
                                       Area = BuildButtonRect(Button.NewGame),
                                       Render = true
                                     }
                   },
                 {
                   Button.LoadGame, new ButtonParams
                                      {
                                        Image = Res.Buttons[Button.LoadGame],
                                        Area = BuildButtonRect(Button.LoadGame),
                                        Render = true
                                      }
                   },
                 {
                   Button.SmallScale, new ButtonParams
                                        {
                                          Image = Res.Buttons[Button.SmallScale],
                                          Area = BuildButtonRect(Button.SmallScale),
                                          Render = true
                                        }
                   },
                 {
                   Button.NormalScale, new ButtonParams
                                         {
                                           Image = Res.Buttons[Button.NormalScale],
                                           Area = BuildButtonRect(Button.NormalScale),
                                           Render = true
                                         }
                   },
                 {
                   Button.BigScale, new ButtonParams
                                      {
                                        Image = Res.Buttons[Button.BigScale],
                                        Area = BuildButtonRect(Button.BigScale),
                                        Render = true
                                      }
                   },
                 {
                   Button.Exit, new ButtonParams
                                  {
                                    Image = Res.Buttons[Button.Exit],
                                    Area = BuildButtonRect(Button.Exit),
                                    Render = true
                                  }
                   }
               };
 }