/// <summary>
///
/// </summary>
/// <param name="drawobject"></param>
public void AddSelectedObject(IDrawObject drawobject)
{
DrawTools.DrawObjectBase obj = drawobject as DrawTools.DrawObjectBase;
RemoveSelectedObject(drawobject);
m_selection[drawobject] = true;
obj.Selected = true;
}
public BridgePoints(IDrawObject owner, UnitPointBulge point1, UnitPointBulge point2, double distance)
{
Owner = owner;
Point1 = point1;
Point2 = point2;
Distance = distance;
}
public void SetPositionInfo(UnitPoint unitpos)
{
PointF ptScreen = m_canvas.ToScreen(unitpos);
string screenPtInfo = string.Format(" screen:{0},{1},{2}", ptScreen.X, ptScreen.Y, m_canvas.Model.Zoom);
m_mousePosLabel.Text = unitpos.PosAsString() + screenPtInfo;
string s = string.Empty;
if (m_data.SelectedCount == 1 || m_canvas.NewObject != null)
{
IDrawObject obj = m_data.GetFirstSelected();
if (obj == null)
{
obj = m_canvas.NewObject;
}
if (obj != null)
{
s = obj.GetInfoAsString();
}
}
if (m_toolHint.Length > 0)
{
s = m_toolHint;
}
if (s != m_drawInfoLabel.Text)
{
m_drawInfoLabel.Text = s;
}
}
//通过鼠标当前坐标获取选中的图形
public List <IDrawObject> GetHitObjects(ICanvas canvas, UnitPoint point)
{
List <IDrawObject> selected = new List <IDrawObject>();
foreach (ICanvasLayer layer in m_layers)
{
if (layer.Visible == false)
{
continue;
}
foreach (IDrawObject drawobject in layer.Objects)
{
try
{
if (drawobject.PointInObject(canvas, point))
{
selected.Add(drawobject);
}
}
catch (Exception ex)
{ }
}
//如果选中该的元素有多个且包含地标则默认选择地标
if (selected.Count > 1)
{
IDrawObject obj = selected.FirstOrDefault(p => p.Id == "LandMark");
if (obj != null)
{
selected.Clear();
selected.Add(obj);
}
}
}
return(selected);
}
/// <summary>
/// 处理鼠标按下的绘图
/// </summary>
/// <param name="mouseunitpoint"></param>
/// <param name="snappoint"></param>
protected virtual void HandleMouseDownWhenDrawing(UnitPoint mouseunitpoint, ISnapPoint snappoint)
{
if (m_commandType != eCommandType.draw)
{
return;
}
if (m_newObject == null)
{
m_newObject = m_model.CreateObject(m_drawObjectId, mouseunitpoint, snappoint);
DoInvalidate(false, m_newObject.GetBoundingRect(m_canvaswrapper));
return;
}
eDrawObjectMouseDown result = m_newObject.OnMouseDown(m_canvaswrapper, mouseunitpoint, snappoint);
switch (result)
{
case eDrawObjectMouseDown.Done:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = null;
DoInvalidate(true);
break;
case eDrawObjectMouseDown.DoneRepeat:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null);
DoInvalidate(true);
break;
case eDrawObjectMouseDown.Continue:
break;
}
}
private float GetPercentInArcByPoint(IDrawObject drawObject, UnitPoint unitPoint)
{
ArcBase arcBase = (ArcBase)drawObject;
double angle = HitUtil.LineAngleR(arcBase.Center, unitPoint, 0);
return((float)(angle / (Math.PI * 2)));
}
public void SetPositionInfo(UnitPoint unitpos)
{
m_mousePosLabel.Text = unitpos.PosAsString();
string s = string.Empty;
if (m_data.SelectedCount == 1 || m_canvas.NewObject != null)
{
IDrawObject obj = m_data.GetFirstSelected();
if (obj == null)
{
obj = m_canvas.NewObject;
}
if (obj != null)
{
s = obj.GetInfoAsString();
}
}
if (m_toolHint.Length > 0)
{
s = m_toolHint;
}
if (s != m_drawInfoLabel.Text)
{
m_drawInfoLabel.Text = s;
}
}
public void InputDrawObject(IDrawObject selObject)
{
if (selObject != null)
{
m_DrawList.Add(selObject.Clone());
}
}
private float GetPercentInCircleByPoint(IDrawObject drawObject, UnitPoint unitPoint)
{
Circle circle = (Circle)drawObject;
double angle = HitUtil.LineAngleR(circle.Center, unitPoint, 0);
return((float)(angle / (Math.PI * 2)));
}
public MovingObject(IDrawObject drawObject, Point gridPosition, Point direction, int speed)
{
this.drawObject = drawObject;
this.pixelPosition = new Point(gridPosition.X * World.BLOCKSIZE, gridPosition.Y * World.BLOCKSIZE);
this.Direction = direction;
this.Speed = speed;
}
// constructors //
public MovingObject(IDrawObject drawObject, Point gridPosition)
{
this.drawObject = drawObject;
this.pixelPosition = new Point(gridPosition.X * World.BLOCKSIZE, gridPosition.Y * World.BLOCKSIZE);
this.Direction = new Point(0, 0);
this.Speed = 0;
}
/// <summary>
///
/// </summary>
/// <param name="angleSpace"></param>
/// <param name="count"></param>
private void AddArrayDrawObject(double angleSpace, int count)
{
List <IDrawObject> ldrawobjects = new List <IDrawObject>();
foreach (var item in drawObjects)
{
for (int i = 1; i < count; i++)
{
IDrawObject drawObject = item.Clone();
IDrawTranslation drawTranslation = drawObject as IDrawTranslation;
if (drawTranslation != null)
{
drawTranslation.DoRotate(RotateCenterUnitPoint, i * angleSpace, false);//默认逆时针
//drawTranslation.DoRotate(RotateCenterUnitPoint, ((i-1) * angleSpace+addAngle)-90, true);//默认逆时针
}
drawObject.GroupParam.FigureSN = ++GlobalModel.TotalDrawObjectCount;
ldrawobjects.Add(drawObject);
}
}
if (ldrawobjects.Count > 0)
{
uCCanvas.Model.AddObjectOnDrawing(ldrawobjects);
}
uCCanvas.Model.DrawingLayer.UpdateSN();
}
public void AddObjectOnRedoUndo(IDrawObject drawObject)
{
if (this.undoRedoBuffer.CanCapture)
{
this.undoRedoBuffer.AddCommand(new EditCommandAdd(drawObject));
}
this.DrawingLayer.AddObjectOnRedoUndo(drawObject);
}
/// <summary>
/// 指出目前的物件是否等於另一個具有相同型別的物件。
/// </summary>
/// <param name="other">要與這個物件相互比較的物件。</param>
/// <returns>如果目前的物件等於 other 參數，則為 true，否則為 false。</returns>
public bool Equals(IDrawObject other)
{
if (other == null)
{
return(false);
}
return(this.ID == other.ID);
}
private void CheckAllowedToDraw(IDrawObject drawObject, int tag)
{
for (int i = 0; i < expectNotToDraw.Count; i++)
{
// Whoops, did some attached actor forget to suppress its drawing registration?
Debug.Assert(!(ReferenceEquals(expectNotToDraw[i].drawObject, drawObject) && expectNotToDraw[i].tag == tag));
}
}
/// <summary>
/// Called on each bar update event (incoming tick)
/// </summary>
protected override void OnBarUpdate()
{
if (CurrentBar < Bars.Count - 1)
{
Value.Set(price);
return;
}
IHorizontalLine alertLine = null;
IDrawObject drawObject = DrawObjects["TriggerLine"];
if (drawObject != null && drawObject.DrawType == DrawType.HorizontalLine)
{
alertLine = (drawObject as IHorizontalLine);
}
if (showTriggerLine && alertLine == null)
{
alertLine = DrawHorizontalLine("TriggerLine", AutoScale, fixedPrice > 0 ? fixedPrice : Input[0], Plots[0].Pen.Color, Plots[0].Pen.DashStyle, (int)Plots[0].Pen.Width);
alertLine.Locked = false;
price = Instrument.MasterInstrument.Round2TickSize(alertLine.Y);
}
double lineVal = showTriggerLine ? Instrument.MasterInstrument.Round2TickSize(alertLine.Y) : price;
if (showTriggerLine && lineVal != price)
{
price = lineVal;
triggered = false;
triggerSet = false;
}
if (alertLine != null)
{
Plots[0].Pen.Color = alertLine.Pen.Color;
Plots[0].Pen.Width = alertLine.Pen.Width;
Plots[0].Pen.DashStyle = alertLine.Pen.DashStyle;
alertLine.Y = lineVal;
}
Value.Set(lineVal);
if (Historical || triggered)
{
return;
}
if (!triggerSet)
{
triggerOnGreaterThan = Input[0] >= price - (TickSize * 0.5) ? false : true;
triggerSet = true;
}
if ((triggerOnGreaterThan && Input[0] >= price - (TickSize * 0.5)) || (!triggerOnGreaterThan && Input[0] <= price + (TickSize * 0.5)))
{
triggered = true;
Alert(DateTime.Now.Millisecond.ToString(), Cbi.Priority.Medium, "Price level '" + price + "' hit!", Cbi.Core.InstallDir + @"\sounds\Alert4.wav", 0, Color.Yellow, Color.Black);
}
}
public void AddObject(IDrawObject drawobject)
{
if (m_objectMap.ContainsKey(drawobject))
return; // this should never happen
if (drawobject is DrawTools.DrawObjectBase)
((DrawTools.DrawObjectBase)drawobject).Layer = this;
m_objects.Add(drawobject);
m_objectMap[drawobject] = true;
}
/// <summary>
///
/// </summary>
/// <param name="drawobject"></param>
public void RemoveSelectedObject(IDrawObject drawobject)
{
if (m_selection.ContainsKey(drawobject))
{
DrawTools.DrawObjectBase obj = drawobject as DrawTools.DrawObjectBase;
obj.Selected = false;
m_selection.Remove(drawobject);
}
}
public void DebugExpectNotToDraw(IDrawObject drawObject, int tag)
{
Debug.Assert(!IsSorted);
#if DEBUG
expectNotToDraw.Add(new DrawingInfo {
drawObject = drawObject, tag = tag
});
#endif
}
public void SelectNewDrawObject(IDrawObject draw)
{
if (draw.Selected == false)
{
draw.Selected = true;
}
SelectedDrawObject = draw;
OnSelectDrawObjectChanged(draw);
}
public void AddNewDrawObject(IDrawObject draw)
{
GraphicsCollection.UnselectAll();
draw.Selected = true;
GraphicsCollection.Add(draw);
Capture = true;
Refresh();
SelectedDrawObject = draw;
OnAddDrawObject(draw);
}
/// <summary>
/// 撤销删除时添加图形到图形对象集合
/// </summary>
/// <param name="drawObject"></param>
public void AddObjectOnRedoUndo(IDrawObject drawObject)
{
this.Objects.Insert(drawObject.GroupParam.FigureSN - 1, drawObject);
GlobalModel.TotalDrawObjectCount += 1;
for (int i = drawObject.GroupParam.FigureSN; i < this.Objects.Count; i++)
{
this.Objects[i].GroupParam.FigureSN += 1;
}
this.UpdateSN();
}
public SnapPointBase(ICanvas canvas, IDrawObject owner, UnitPoint snappoint)
{
m_owner = owner;
m_snappoint = snappoint;
float size = (float)canvas.ToUnit(14);
m_boundingRect.X = (float)(snappoint.X - size / 2);
m_boundingRect.Y = (float)(snappoint.Y - size / 2);
m_boundingRect.Width = size;
m_boundingRect.Height = size;
}
/// <summary>
/// Krijgt het juiste object en voeg deze toe aan een lijst
/// </summary>
/// <param name="id"></param>
/// <param name="content"></param>
/// <param name="_position"></param>
/// <param name="CollisionList"></param>
/// <returns></returns>
public IDrawObject GetExactObject(int id, ContentManager content, Vector2 _position, List <ICollide> CollisionList)
{
IDrawObject currentObject = CreateObject(id, content, _position);
if (currentObject is ICollide)
{
CollisionList.Add((ICollide)currentObject);
}
return(currentObject);
}
public SnapPointBase(ICanvas canvas, IDrawObject owner, UnitPoint snappoint)
{
m_owner = owner;
m_snappoint = snappoint;
float size = (float)canvas.ToUnit(14);
m_boundingRect.X = (float)(snappoint.X - size / 2);
m_boundingRect.Y = (float)(snappoint.Y - size / 2);
m_boundingRect.Width = size;
m_boundingRect.Height = size;
}
public SnapPointBase(ICanvas canvas, IDrawObject drawObject, UnitPoint snapPoint)
{
this.owner = drawObject;
this.snapPoint = snapPoint;
float size = (float)canvas.ToUnit(14);
this.boundingRectangle.X = (float)(this.snapPoint.X - size / 2);
this.boundingRectangle.Y = (float)(this.snapPoint.Y - size / 2);
this.boundingRectangle.Width = size;
this.boundingRectangle.Height = size;
}
public void AddObject(ICanvasLayer layer, IDrawObject drawobject)
{
if (drawobject is DrawTools.IObjectEditInstance)
{
drawobject = ((DrawTools.IObjectEditInstance)drawobject).GetDrawObject();
}
if (m_undoBuffer.CanCapture)
{
m_undoBuffer.AddCommand(new EditCommandAdd(layer, drawobject));
}
((DrawingLayer)layer).AddObject(drawobject);
}
public void Add(IDrawObject drawObject, int tag, Position position, bool facingLeft, AnimationSet animationSet, Bounds worldZeroBounds)
{
Debug.Assert(!IsSorted); // <- We don't handle adding to the sorted list
bounds.Add(worldZeroBounds);
sortingInfo.Add(new SortingInfo {
animationSet = animationSet, position = position, facingLeft = facingLeft
});
drawingInfo.Add(new DrawingInfo {
drawObject = drawObject, tag = tag
});
}
public void AddObject(IDrawObject drawobject)
{
if (m_objectMap.ContainsKey(drawobject))
{
return; // this should never happen
}
if (drawobject is DrawTools.DrawObjectBase)
{
((DrawTools.DrawObjectBase)drawobject).Layer = this;
}
m_objects.Add(drawobject);
m_objectMap[drawobject] = true;
}
} /// <summary>
/// 在画布按照IDrawObject重画
/// </summary>
/// <param name="obj"></param>
void RepaintObject(IDrawObject obj)
{
if (obj == null)
{
return;
}
CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle);
RectangleF invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(dc, obj.GetBoundingRect(dc)));
obj.Draw(dc, invalidaterect);
dc.Graphics.Dispose();
dc.Dispose();
}
private void GetCircleLeadLineParams(IDrawObject drawObject, LineInOutParamsModel leadInOutParamsModel)
{
Circle circle = (Circle)drawObject;
double angle = HitUtil.LineAngleR(circle.Center, this.p2, 0);
leadInOutParamsModel.FigureTotalLength = (float)(angle / (Math.PI * 2));
this.p2 = HitUtil.PointOnCircle(circle.Center, circle.Radius, angle);
bool isInner;
leadInOutParamsModel.LineInAngle = DrawingOperationHelper.GetLeadLineAngleArc(this.p1, this.p2, circle.Center, circle.IsClockwise, out isInner);
leadInOutParamsModel.LineInLength = (float)HitUtil.Distance(this.p1, this.p2);
circle.IsInnerCut = isInner;
}
public void CopyObjects(UnitPoint point, List <IDrawObject> drawObjects)
{
List <IDrawObject> tempDrawObjects = new List <IDrawObject>();
foreach (IDrawObject drawObject in drawObjects)
{
IDrawObject tempDrawObject = drawObject.Clone();
tempDrawObjects.Add(tempDrawObject);
tempDrawObject.Move(point);
tempDrawObject.GroupParam.FigureSN = ++GlobalModel.TotalDrawObjectCount;
this.AddObjectOnDrawing(tempDrawObject);
}
}
/// <summary>Force two objects to be drawn in a given order. The objects do not have to be registered yet. DOES check if the objects overlap.</summary>
public void ForceDrawOrderDeferred(IDrawObject fromDrawObject, int fromTag, IDrawObject toDrawObject, int toTag)
{
Debug.Assert(!IsSorted);
forceDrawOrderDeferred.Add(new DeferredFromTo
{
from = new DrawingInfo {
drawObject = fromDrawObject, tag = fromTag
},
to = new DrawingInfo {
drawObject = toDrawObject, tag = toTag
}
});
}
public Symbol(IDrawObject owner, string txt, float relativeOffsetToLeft, float relativeOffSetToTop)
{
m_owner = owner;
m_txt = txt;
m_relativeOffSetToLeft = relativeOffsetToLeft;
m_relativeOffSetToTop = relativeOffSetToTop;
m_font = new Font("Calibri", 20, FontStyle.Regular, GraphicsUnit.Point);
m_strFormat = new StringFormat();
m_strFormat.Alignment = StringAlignment.Center;
m_strFormat.LineAlignment = StringAlignment.Center;
m_strBrush = Brushes.Black;
m_fillBrush = Brushes.Red;
}
public void PasteObjects(UnitPoint offset)
{
double x = offset.X - this.copyLastPoint.X;
double y = offset.Y - this.copyLastPoint.Y;
offset = new UnitPoint(x, y);
foreach (IDrawObject drawObject in this.copyObjectInClipBoard)
{
IDrawObject tempDrawObject = drawObject.Clone();
tempDrawObject.GroupParam.FigureSN = ++GlobalModel.TotalDrawObjectCount;
tempDrawObject.Move(offset);
this.AddObjectOnDrawing(tempDrawObject);
}
}
public static IDrawObject FindObjectTypeInList(IDrawObject caller, List <IDrawObject> drawObjects, Type type)
{
foreach (IDrawObject drawObject in drawObjects)
{
if (object.ReferenceEquals(caller, drawObject))
{
continue;
}
if (drawObject.GetType() == type)
{
return(drawObject);
}
}
return(null);
}
public void CommandEscape()
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
//if (m_editTool != null)
// m_editTool.Finished();
//m_editTool = null;
m_commandType = eCommandType.select;
//m_moveHelper.HandleCancelMove();
m_nodeMoveHelper.HandleCancelMove();
DoInvalidate(dirty);
//UpdateCursor();
}
/// <summary>
/// Replace object in specified place.
/// Used for Undo.
/// </summary>
public void Replace(int index, IDrawObject obj)
{
if (index >= 0 && index < graphicsList.Count)
{
graphicsList.RemoveAt(index);
graphicsList.Insert(index, obj);
}
}
/// <summary>
/// Insert object to specified place.
/// Used for Undo.
/// </summary>
public void Insert(int index, IDrawObject obj)
{
if ( index >= 0 && index < graphicsList.Count )
{
graphicsList.Insert(index, obj);
}
}
private void OnSelectDrawObjectChanged(IDrawObject draw)
{
if (SelectDrawObjectChanged != null)
SelectDrawObjectChanged(draw.Property, EventArgs.Empty);
}
public virtual void AddGraphic(IDrawObject item)
{
if (item.ParentLayer == this)
return;
if (item.ParentLayer != null)
{
item.ParentLayer.RemoveGraphic(item);
}
var depth = item.Depth;
var added = false;
for (int i = 0; i < _drawables.Count; i++)
{
if (_drawables[i].Depth > depth)
{
_drawables.Insert(i, item);
added = true;
break;
}
}
if (!added)
_drawables.Add(item);
item.ParentLayer = this;
}
public void AddObject(ICanvasLayer layer, IDrawObject drawobject)
{
if (drawobject is DrawTools.IObjectEditInstance)
drawobject = ((DrawTools.IObjectEditInstance)drawobject).GetDrawObject();
if (m_undoBuffer.CanCapture)
m_undoBuffer.AddCommand(new EditCommandAdd(layer, drawobject));
((DrawingLayer)layer).AddObject(drawobject);
}
public MidpointSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint)
: base(canvas, owner, snappoint)
{
}
public void CommandSelectEraserTool(string drawobjectid)
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
//if (m_editTool != null)
// m_editTool.Finished();
//m_editTool = null;
m_commandType = eCommandType.select;
//m_moveHelper.HandleCancelMove();
m_drawObjectId = drawobjectid;
m_nodeMoveHelper.HandleCancelMove();
DoInvalidate(dirty);
ispaste = false;
moving = false;
if(drawobjectid.Equals("Paste")){
ispaste = true;
}
//UpdateCursor();
}
/// <summary>
/// 指出目前的物件是否等於另一個具有相同型別的物件。
/// </summary>
/// <param name="other">要與這個物件相互比較的物件。</param>
/// <returns>如果目前的物件等於 other 參數，則為 true，否則為 false。</returns>
public bool Equals(IDrawObject other) {
if (other == null) {
return false;
}
return this.ID == other.ID;
}
protected virtual void HandleMouseDownWhenDrawing(UnitPoint mouseunitpoint, ISnapPoint snappoint)
{
if (m_commandType == eCommandType.draw)
{
if (m_newObject == null)
{
m_newObject = m_model.CreateObject(m_drawObjectId, mouseunitpoint, snappoint);
if (m_newObject.GetType().ToString().IndexOf("Module")>0)
{
eDrawObjectMouseDown result = m_newObject.OnMouseDown(m_canvaswrapper, mouseunitpoint, snappoint);
switch (result)
{
case eDrawObjectMouseDown.Done:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = null;
DoInvalidate(true);
break;
case eDrawObjectMouseDown.DoneRepeat:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null);
DoInvalidate(true);
break;
case eDrawObjectMouseDown.Continue:
break;
}
}
else DoInvalidate(false, m_newObject.GetBoundingRect(m_canvaswrapper));
}
else
{
if (m_newObject != null)
{
eDrawObjectMouseDown result = m_newObject.OnMouseDown(m_canvaswrapper, mouseunitpoint, snappoint);
switch (result)
{
case eDrawObjectMouseDown.Done:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = null;
DoInvalidate(true);
break;
case eDrawObjectMouseDown.DoneRepeat:
m_model.AddObject(m_model.ActiveLayer, m_newObject);
m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null);
DoInvalidate(true);
break;
case eDrawObjectMouseDown.Continue:
break;
}
}
}
}
}
void RepaintObject(IDrawObject obj)
{
if (obj == null)
return;
CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle);
RectangleF invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(dc, obj.GetBoundingRect(dc)));
obj.Draw(dc, invalidaterect);
dc.Graphics.Dispose();
dc.Dispose();
}
public EditCommandAdd(ICanvasLayer layer, IDrawObject obj)
{
m_object = obj;
m_layer = layer;
}
public virtual void RemoveGraphic(IDrawObject item)
{
_drawables.Remove(item);
item.ParentLayer = null;
}
public bool IsSelected(IDrawObject drawobject)
{
return m_selection.ContainsKey(drawobject);
}
private void OnAddDrawObject(IDrawObject draw)
{
if (AddDrawObject != null)
AddDrawObject(draw.Property, EventArgs.Empty);
}
public static IDrawObject FindObjectTypeInList(IDrawObject caller, List<IDrawObject> list, Type type)
{
foreach (IDrawObject obj in list)
{
if (object.ReferenceEquals(caller, obj))
continue;
if (obj.GetType() == type)
return obj;
}
return null;
}
public void CommandEscape()
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
if (m_editTool != null)
m_editTool.Finished();
m_editTool = null;
m_commandType = eCommandType.select;
m_moveHelper.HandleCancelMove();
m_nodeMoveHelper.HandleCancelMove();
if (this.Parent is DocumentForm){
DocumentForm temp = this.Parent as DocumentForm;
temp.SetHint("");
}
DoInvalidate(dirty);
UpdateCursor();
}
public static Boolean Draw(IDrawObject draw,Size oldSize,Point oldLocation,out Size newSize, out Point newLocation)
{
var result = false;
newSize = new Size(oldSize.Width, oldSize.Height);
newLocation = new Point(oldLocation.X, oldLocation.Y);
var dock = draw.Property.Dock;
var pagesize = new Size(newSize.Width, newSize.Height);
var page = ConfigToolContext.Instance.ToolViews.GetDrawArea().Schema;
if (page != null && page.Children.Count > 0)
{
var child = page.Children[0];
var tempsize = child.Properties.FirstOrDefault(p => p.Name == "Size");
if (tempsize != null)
{
pagesize = PropertyUtility.ParseToSize(tempsize.Value);
}
var draws = GetDockDraw(draw.Property.ZIndex);
var leftDraws = draws.Where(d => d.Property.Dock == DockEnum.Left.ToString()).ToList();
var topDraws = draws.Where(d => d.Property.Dock == DockEnum.Top.ToString()).ToList();
var rightDraws = draws.Where(d => d.Property.Dock == DockEnum.Right.ToString()).ToList();
var bottomDraws = draws.Where(d => d.Property.Dock == DockEnum.Bottom.ToString()).ToList();
var fillDraws = draws.Where(d => d.Property.Dock == DockEnum.Fill.ToString()).ToList();
if (draw.Property.Dock == DockEnum.Left.ToString())
{
newLocation.X = 0 + GetWidthByDraws(leftDraws);
newLocation.Y = 0 + GetHeightByDraws(topDraws);
newSize.Height = pagesize.Height - GetHeightByDraws(topDraws) - GetHeightByDraws(bottomDraws);
result = true;
}
else if (draw.Property.Dock == DockEnum.Top.ToString())
{
newLocation.X = 0 + GetWidthByDraws(leftDraws);
newLocation.Y = 0 + GetHeightByDraws(topDraws);
newSize.Width = pagesize.Width - GetWidthByDraws(leftDraws) - GetWidthByDraws(rightDraws);
result = true;
}
else if (draw.Property.Dock == DockEnum.Right.ToString())
{
newLocation.X = pagesize.Width - GetWidthByDraws(rightDraws) - oldSize.Width;
newLocation.Y = 0 + GetHeightByDraws(topDraws);
newSize.Height = pagesize.Height - GetHeightByDraws(topDraws) - GetHeightByDraws(bottomDraws);
result = true;
}
else if (draw.Property.Dock == DockEnum.Bottom.ToString())
{
newLocation.X = 0 + GetWidthByDraws(leftDraws);
newLocation.Y = pagesize.Height - GetHeightByDraws(bottomDraws) - oldSize.Height;
newSize.Width = pagesize.Width - GetWidthByDraws(leftDraws) - GetWidthByDraws(rightDraws);
result = true;
}
else if (draw.Property.Dock == DockEnum.Fill.ToString())
{
newLocation.X = 0 + GetWidthByDraws(leftDraws);
newLocation.Y = 0 + GetHeightByDraws(topDraws);
newSize.Width = pagesize.Width - GetWidthByDraws(leftDraws) - GetWidthByDraws(rightDraws);
newSize.Height = pagesize.Height - GetHeightByDraws(topDraws) - GetHeightByDraws(bottomDraws);
result = true;
}
}
return result;
}
public void AddDrawTool(string key, IDrawObject drawtool)
{
m_drawObjectTypes[key] = drawtool;
}
public void DrawObject(IDrawObject item)
{
var alpha = item.Alpha;
if (alpha < float.Epsilon)
return;
Alpha = item.Alpha;
Parallax = item.Parallax;
DrawMode = item.DrawMode;
if (item.HasShader)
{
var currentRenderTarget = _renderTarget;
// draw the item to the current buffer
var currentBuffer = GetNextShaderBuffer();
RenderTarget = currentBuffer;
Render.Device.Clear(Color.Transparent);
item.Draw(this);
StopSpriteBatch();
StopPrimitiveBatch();
// draw the current buffer to the next buffer using each shader
foreach (var shader in item.Shaders)
{
RenderTarget2D nextBuffer = GetNextShaderBuffer();
shader.Draw(_spriteBatch, currentBuffer, nextBuffer);
currentBuffer = nextBuffer;
}
// draw the result to the current render target
RenderTarget = currentRenderTarget;
Render.Device.SetRenderTarget(currentRenderTarget);
_spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
_spriteBatch.Draw(currentBuffer, currentRenderTarget.Bounds, currentBuffer.Bounds, Color.White);
_spriteBatch.End();
}
else
{
item.Draw(this);
}
}
public void AddSelectedObject(IDrawObject drawobject)
{
DrawTools.DrawObjectBase obj = drawobject as DrawTools.DrawObjectBase;
RemoveSelectedObject(drawobject);
m_selection[drawobject] = true;
obj.Selected = true;
}
public PerpendicularSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint)
: base(canvas, owner, snappoint)
{
}
public void RemoveSelectedObject(IDrawObject drawobject)
{
if (m_selection.ContainsKey(drawobject))
{
DrawTools.DrawObjectBase obj = drawobject as DrawTools.DrawObjectBase;
obj.Selected = false;
m_selection.Remove(drawobject);
}
}
public DivisionSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint)
: base(canvas, owner, snappoint)
{
}
