public void BindElement(IDrawableContainer dc) {
			DrawableContainer container = dc as DrawableContainer;
			if (container != null && !boundContainers.Contains(container)) {
				boundContainers.Add(container);
				container.ChildrenChanged += delegate {
					UpdateFromBoundElements();
				};
				UpdateFromBoundElements();
			}
		}

 /// <summary>
 /// Wrapper for makeUndoable flag which was introduced later, will call AddElement with makeundoable set to true
 /// </summary>
 /// <param name="element">the new element</param>
 public void AddElement(IDrawableContainer element)
 {
     AddElement(element, true);
 }

 public void DeselectElement(IDrawableContainer container)
 {
     DrawableContainer element = container as DrawableContainer;
     element.HideGrippers();
     element.Selected = false;
     selectedElements.Remove(element);
     FieldAggregator.UnbindElement(element);
     if (MovingElementChanged != null) {
         MovingElementChanged(this, selectedElements);
     }
 }

 public AddElementMemento(Surface surface, IDrawableContainer drawableContainer)
 {
     _surface = surface;
     _drawableContainer = drawableContainer;
 }

		public DrawableContainerBoundsChangeMemento(IDrawableContainer drawableContainer) {
			listOfdrawableContainer = new List<IDrawableContainer>();
			listOfdrawableContainer.Add(drawableContainer);
			StoreBounds();
		}

		public void UnbindElement(IDrawableContainer dc) {
			if (boundContainers.Contains(dc)) {
				boundContainers.Remove(dc);
				UpdateFromBoundElements();
			}
		}

 /// <summary>
 /// Select the supplied element
 /// </summary>
 /// <param name="container"></param>
 public void SelectElement(IDrawableContainer container)
 {
     if (!selectedElements.Contains(container))
     {
         selectedElements.Add(container);
         container.ShowGrippers();
         container.Selected = true;
         FieldAggregator.BindElement(container);
         if (_movingElementChanged != null)
         {
             SurfaceElementEventArgs eventArgs = new SurfaceElementEventArgs();
             eventArgs.Elements = selectedElements;
             _movingElementChanged(this, eventArgs);
         }
         container.Invalidate();
     }
 }

 /// <summary>
 /// Count all the VISIBLE steplabels in the surface, up to the supplied one
 /// </summary>
 /// <param name="stopAtContainer">can be null, if not the counting stops here</param>
 /// <returns>number of steplabels before the supplied container</returns>
 public int CountStepLabels(IDrawableContainer stopAtContainer)
 {
     int number = 1;
     foreach (var possibleThis in _stepLabels)
     {
         if (possibleThis == stopAtContainer)
         {
             break;
         }
         if (IsOnSurface(possibleThis))
         {
             number++;
         }
     }
     return number;
 }

 /// <summary>
 /// Remove an element of the elements list
 /// </summary>
 /// <param name="elementToRemove">Element to remove</param>
 /// <param name="makeUndoable">flag specifying if the remove needs to be undoable</param>
 public void RemoveElement(IDrawableContainer elementToRemove, bool makeUndoable)
 {
     DeselectElement(elementToRemove);
     _elements.Remove(elementToRemove);
     DrawableContainer element = elementToRemove as DrawableContainer;
     if (element != null)
     {
         element.FieldChanged -= element_FieldChanged;
     }
     elementToRemove.PropertyChanged -= ElementPropertyChanged;
     // Do not dispose, the memento should!! element.Dispose();
     Invalidate();
     if (makeUndoable)
     {
         MakeUndoable(new DeleteElementMemento(this, elementToRemove), false);
     }
     _modified = true;
 }

 public bool IsOnSurface(IDrawableContainer container)
 {
     return _elements.Contains(container);
 }

 public void SelectElement(IDrawableContainer container)
 {
     DrawableContainer element = container as DrawableContainer;
     if(!selectedElements.Contains(element)) {
         selectedElements.Add(element);
         element.ShowGrippers();
         element.Selected = true;
         FieldAggregator.BindElement(element);
         if (MovingElementChanged != null) {
             MovingElementChanged(this, selectedElements);
         }
         element.Invalidate();
     }
 }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                Count--;
                LOG.Debug("Disposing surface!");
                if (_buffer != null)
                {
                    _buffer.Dispose();
                    _buffer = null;
                }
                if (_transparencyBackgroundBrush != null)
                {
                    _transparencyBackgroundBrush.Dispose();
                    _transparencyBackgroundBrush = null;
                }

                // Cleanup undo/redo stacks
                while (_undoStack != null && _undoStack.Count > 0)
                {
                    _undoStack.Pop().Dispose();
                }
                while (_redoStack != null && _redoStack.Count > 0)
                {
                    _redoStack.Pop().Dispose();
                }
                foreach (IDrawableContainer container in _elements)
                {
                    container.Dispose();
                }
                if (_undrawnElement != null)
                {
                    _undrawnElement.Dispose();
                    _undrawnElement = null;
                }
                if (_cropContainer != null)
                {
                    _cropContainer.Dispose();
                    _cropContainer = null;
                }
            }
            base.Dispose(disposing);
        }

 /// <summary>
 /// This method is called to confirm/cancel "confirmable" elements, like the crop-container.
 /// Called when pressing enter or using the "check" in the editor.
 /// </summary>
 /// <param name="confirm"></param>
 public void ConfirmSelectedConfirmableElements(bool confirm)
 {
     // create new collection so that we can iterate safely (selectedElements might change due with confirm/cancel)
     List<IDrawableContainer> selectedDCs = new List<IDrawableContainer>(selectedElements);
     foreach (IDrawableContainer dc in selectedDCs)
     {
         if (dc.Equals(_cropContainer))
         {
             DrawingMode = DrawingModes.None;
             // No undo memento for the cropcontainer itself, only for the effect
             RemoveElement(_cropContainer, false);
             if (confirm)
             {
                 ApplyCrop(_cropContainer.Bounds);
             }
             _cropContainer.Dispose();
             _cropContainer = null;
         }
     }
 }

 /// <summary>
 /// Deselect the specified element
 /// </summary>
 /// <param name="container"></param>
 public void DeselectElement(IDrawableContainer container)
 {
     container.HideGrippers();
     container.Selected = false;
     selectedElements.Remove(container);
     FieldAggregator.UnbindElement(container);
     if (_movingElementChanged != null)
     {
         SurfaceElementEventArgs eventArgs = new SurfaceElementEventArgs();
         eventArgs.Elements = selectedElements;
         _movingElementChanged(this, eventArgs);
     }
 }

		public void BindAndUpdateElement(IDrawableContainer dc) {
			UpdateElement(dc);
			BindElement(dc);
		}

		public ChangeFieldHolderMemento(IDrawableContainer drawableContainer, Field fieldToBeChanged) {
			this.drawableContainer = drawableContainer;
			this.fieldToBeChanged = fieldToBeChanged;
			oldValue = fieldToBeChanged.Value;
		}

        /// <summary>
        /// This event handler is called when someone presses the mouse on a surface.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SurfaceMouseDown(object sender, MouseEventArgs e)
        {
            _mouseStart = e.Location;

            // check contextmenu
            if (e.Button == MouseButtons.Right)
            {
                DrawableContainerList selectedList = null;
                if (selectedElements != null && selectedElements.Count > 0)
                {
                    selectedList = selectedElements;
                }
                else
                {
                    // Single element
                    IDrawableContainer rightClickedContainer = _elements.ClickableElementAt(_mouseStart.X, _mouseStart.Y);
                    if (rightClickedContainer != null)
                    {
                        selectedList = new DrawableContainerList(ID);
                        selectedList.Add(rightClickedContainer);
                    }
                }
                if (selectedList != null && selectedList.Count > 0)
                {
                    selectedList.ShowContextMenu(e, this);
                }
                return;
            }

            _mouseDown = true;
            _isSurfaceMoveMadeUndoable = false;

            if (_cropContainer != null && ((_undrawnElement == null) || (_undrawnElement != null && DrawingMode != DrawingModes.Crop)))
            {
                RemoveElement(_cropContainer, false);
                _cropContainer = null;
                _drawingElement = null;
            }

            if (_drawingElement == null && DrawingMode != DrawingModes.None)
            {
                if (_undrawnElement == null)
                {
                    DeselectAllElements();
                    if (_undrawnElement == null)
                    {
                        CreateUndrawnElement();
                    }
                }
                _drawingElement = _undrawnElement;
                // if a new element has been drawn, set location and register it
                if (_drawingElement != null)
                {
                    _drawingElement.Status = _undrawnElement.DefaultEditMode;
                    _drawingElement.PropertyChanged += ElementPropertyChanged;
                    if (!_drawingElement.HandleMouseDown(_mouseStart.X, _mouseStart.Y))
                    {
                        _drawingElement.Left = _mouseStart.X;
                        _drawingElement.Top = _mouseStart.Y;
                    }
                    AddElement(_drawingElement);
                    _drawingElement.Selected = true;
                }
                _undrawnElement = null;
            }
            else
            {
                // check whether an existing element was clicked
                // we save mouse down element separately from selectedElements (checked on mouse up),
                // since it could be moved around before it is actually selected
                _mouseDownElement = _elements.ClickableElementAt(_mouseStart.X, _mouseStart.Y);

                if (_mouseDownElement != null)
                {
                    _mouseDownElement.Status = EditStatus.MOVING;
                }
            }
        }

		public void UpdateElement(IDrawableContainer dc) {
			DrawableContainer container = dc as DrawableContainer;
			if (container == null) {
				return;
			}
			internalUpdateRunning = true;
			foreach(Field field in GetFields()) {
				if (container.HasField(field.FieldType) && field.HasValue) {
					//if(LOG.IsDebugEnabled) LOG.Debug("   "+field+ ": "+field.Value);
					container.SetFieldValue(field.FieldType, field.Value);
				}
			}
			internalUpdateRunning = false;
		}

        /// <summary>
        /// This event handle is called when the mouse button is unpressed
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void SurfaceMouseUp(object sender, MouseEventArgs e)
        {
            Point currentMouse = new Point(e.X, e.Y);

            _elements.Status = EditStatus.IDLE;
            if (_mouseDownElement != null)
            {
                _mouseDownElement.Status = EditStatus.IDLE;
            }
            _mouseDown = false;
            _mouseDownElement = null;
            if (DrawingMode == DrawingModes.None)
            {
                // check whether an existing element was clicked
                IDrawableContainer element = _elements.ClickableElementAt(currentMouse.X, currentMouse.Y);
                bool shiftModifier = (ModifierKeys & Keys.Shift) == Keys.Shift;
                if (element != null)
                {
                    element.Invalidate();
                    bool alreadySelected = selectedElements.Contains(element);
                    if (shiftModifier)
                    {
                        if (alreadySelected)
                        {
                            DeselectElement(element);
                        }
                        else
                        {
                            SelectElement(element);
                        }
                    }
                    else
                    {
                        if (!alreadySelected)
                        {
                            DeselectAllElements();
                            SelectElement(element);
                        }
                    }
                }
                else if (!shiftModifier)
                {
                    DeselectAllElements();
                }
            }

            if (selectedElements.Count > 0)
            {
                selectedElements.ShowGrippers();
                selectedElements.Selected = true;
            }

            if (_drawingElement != null)
            {
                if (!_drawingElement.InitContent())
                {
                    _elements.Remove(_drawingElement);
                    _drawingElement.Invalidate();
                }
                else
                {
                    _drawingElement.HandleMouseUp(currentMouse.X, currentMouse.Y);
                    _drawingElement.Invalidate();
                    if (Math.Abs(_drawingElement.Width) < 5 && Math.Abs(_drawingElement.Height) < 5)
                    {
                        _drawingElement.Width = 25;
                        _drawingElement.Height = 25;
                    }
                    SelectElement(_drawingElement);
                    _drawingElement.Selected = true;
                }
                _drawingElement = null;
            }
        }

 public DeleteElementMemento(Surface surface, IDrawableContainer drawableContainer)
 {
     this.surface = surface;
     this.drawableContainer = drawableContainer;
 }