private void MinimizeWindow(IResizable window)
{
if (window != null)
{
window.Minimize();
}
}
private void CloseWindow(IResizable window)
{
if (window != null)
{
window.Close();
}
}
private void OnGrabHold(XRController controller)
{
switch (grab)
{
case GrabState.None:
grab = GrabState.One;
var hover = controller.GetComponent <OnHoverEventHandler>();
if (hover.Current != null)
{
grabbedObject = hover.Current;
}
else
{
if (MultiGrab)
{
grabbedObject = LayerManager.Instance.LayerHelper;
foreach (Layer layer in LayerManager.Instance.layers)
{
layer.transform.parent = LayerManager.Instance.LayerHelper.transform;
}
}
else
{
grabbedObject = LayerManager.Instance.ActiveLayer.gameObject;
}
before = new TransformObject(grabbedObject.transform);
}
originalParent = grabbedObject.transform.parent;
movable = grabbedObject.GetComponent <IMovable>();
resizable = grabbedObject.GetComponent <IResizable>();
if (movable != null)
{
grabbedObject.transform.parent = controller.transform;
}
break;
case GrabState.One:
grab = GrabState.Both;
var pos = grabbedObject.transform.position;
grabbedObject.transform.parent = originalParent;
grabbedObject.transform.position = pos;
refDist = Vector3.Distance(leftController.transform.position, rightController.transform.position);
refPos = grabbedObject.transform.position;
refCenter = center;
refScale = grabbedObject.transform.localScale;
refRot = grabbedObject.transform.rotation;
refControllers = (rightController.transform.position - leftController.transform.position).normalized;
refUp = (leftController.transform.up + rightController.transform.up).normalized;
ToolController.Instance.ToggleSelectedTool(false);
break;
default:
break;
}
}
public Vector2 ResetPosition(IResizable p)
{
return new Vector2(
p.GetStop().x,
p.GetStart().y)
+ new Vector2(-0.5f,-0.5f);
}
public void OnFullHDAndSmaller_LeavesDefault_Correctly()
{
// Arrange
this.underTest = Resizable.Is.OnFullHDAndSmaller(ResizableOption.NoGrow);
// Act
var underTestClass = underTest.Class;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(5)
.And
.OnlyHaveUniqueItems()
.And
.HaveElementAt(0, "flex-resize-nogrow")
.And
.HaveElementAt(1, "flex-resize-sm-nogrow")
.And
.HaveElementAt(2, "flex-resize-md-nogrow")
.And
.HaveElementAt(3, "flex-resize-lg-nogrow")
.And
.HaveElementAt(4, "flex-resize-xl-nogrow");
}
public void SetParent(IResizable p, Vector2 pos)
{
Vector2 wh2 = (p.GetStart() - p.GetStop()) / new Vector2(2.0f, 2.0f);
p.SetStart(pos - wh2);
p.SetStop(pos + wh2);
}
private void ChangeVertical(double verticalChange, IResizable resizable)
{
double deltaVertical;
double newHeight;
switch (VerticalAlignment)
{
case VerticalAlignment.Bottom:
deltaVertical = Math.Min(verticalChange, resizable.Height - resizable.MinHeight);
newHeight = resizable.Height + deltaVertical;
if (newHeight > resizable.MinHeight)
{
resizable.Height += deltaVertical;
}
break;
case VerticalAlignment.Top:
deltaVertical = Math.Min(verticalChange, resizable.Height - resizable.MinHeight);
newHeight = resizable.Height + deltaVertical;
if (newHeight > resizable.MinHeight)
{
resizable.Top += deltaVertical;
resizable.Height -= deltaVertical;
}
break;
default:
break;
}
}
void Start()
{
if (parent != null && p == null)
{
p = parent.GetComponent <IResizable>();
}
}
private IResizable GetObject(String libraryName)
{
IResizable shape = null;
String AboutLibName = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), libraryName);
if (File.Exists(AboutLibName))
{
///Загружаем сборку
Assembly AboutAssembly = Assembly.LoadFrom(AboutLibName);
///в цикле проходим по всем public-типам сборки
foreach (Type t in AboutAssembly.GetExportedTypes())
{
///если это класс,который реализует интерфейс IAboutInt,
///то это то,что нам нужно Smile
if (t.IsClass && typeof(IResizable).IsAssignableFrom(t))
{
///создаем объект полученного класса
shape = (IResizable)Activator.CreateInstance(t);
///вызываем его метод GetAboutText
break;
}
}
}
return(shape);
}
public Vector2 ResetPosition(IResizable p)
{
return(new Vector2(
p.GetStart().x,
(p.GetStart().y + p.GetStop().y) / 2f)
+ new Vector2(-0.5f, -0.5f));
}
private void ResizeProporcional(IResizable resizable, DragDeltaEventArgs dragDeltaEventArgs)
{
double deltaX = 0;
double deltaY = 0;
double offsetX = 0;
double offsetY = 0;
if ((ResizeDirection & Direction.Right) == Direction.Right || (ResizeDirection & Direction.Left) == Direction.Left)
{
deltaX = dragDeltaEventArgs.HorizontalChange;
offsetX = dragDeltaEventArgs.HorizontalChange;
deltaX = -dragDeltaEventArgs.HorizontalChange;
deltaY = dragDeltaEventArgs.HorizontalChange;
offsetY = dragDeltaEventArgs.HorizontalChange;
deltaY = -dragDeltaEventArgs.HorizontalChange;
}
if ((ResizeDirection & Direction.Bottom) == Direction.Bottom || (ResizeDirection & Direction.Top) == Direction.Top)
{
deltaX = dragDeltaEventArgs.VerticalChange;
offsetX = dragDeltaEventArgs.VerticalChange;
deltaX = -dragDeltaEventArgs.VerticalChange;
deltaY = dragDeltaEventArgs.VerticalChange;
offsetY = dragDeltaEventArgs.VerticalChange;
deltaY = -dragDeltaEventArgs.VerticalChange;
}
resizable.Resize(deltaX, deltaY, offsetX, offsetY);
}
public static void UpdateRecSize(this IResizable container)
{
container.UpdateSize();
((Control)container).Refresh();
if (container.ResizableParent != null)
{
container.ResizableParent.UpdateRecSize();
}
}
private void ResizeThumb_DragDelta(object sender, DragDeltaEventArgs e)
{
IResizable resizable = DataContext as IResizable;
if (resizable != null)
{
ChangeVertical(e.VerticalChange, resizable);
ChangeHorizontal(e.HorizontalChange, resizable);
}
}
public ResizeImageCommand(IResizable customImage, int width, int height)
{
_customImage = customImage;
_newImage = _imageFunctions.ResizeImg(Image.FromFile(customImage.GetPath()), width, height);
_newWidth = width;
_newHeight = height;
_prevImage = customImage.Image;
_prevHeight = customImage.ImageResolution.Height;
_prevWidth = customImage.ImageResolution.Width;
}
/// <summary>
/// Funkcja do zmiany ksztalu figury innej niz kolo
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonChangeSize_Click(object sender, EventArgs e)
{
if (shape is IResizable)
{
IResizable resizable = (IResizable)shape;
resizable.ChangeSize();
}
else
{
MessageBox.Show("Nie mozna zmienic rozmiaru okregu");
}
}
/// <summary>
/// Change size
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonChangeSize_Click(object sender, EventArgs e)
{
if (shape is IResizable)
{
IResizable resizable = (IResizable)shape;
resizable.ChangeSize();
}
else
{
MessageBox.Show("Nie da się zmienić rozmiaru tego kształtu");
}
}
public static Point GetMiddlePoint(this IPositionAware model)
{
IResizable resizable = model as IResizable;
if (resizable != null)
{
return(new Point(model.Left + (resizable.Width / 2), model.Top + (resizable.Height / 2)));
}
else
{
return(new Point(model.Left, model.Top));
}
}
private void Should_maintain_aspect_ratio_on_height_change(IResizable resizable)
{
resizable.Width = 10;
resizable.Height = 20;
Assert.AreEqual(10, resizable.Width, 0.01);
Assert.AreEqual(20, resizable.Height, 0.01);
resizable.MaintainAspectRatio = true;
resizable.Height = 40;
Assert.AreEqual(20, resizable.Width, 0.01);
}
private void OnGrabRelease(XRController controller)
{
switch (grab)
{
case GrabState.One:
grab = GrabState.None;
if (controller.transform == grabbedObject.transform.parent)
{
var pos = grabbedObject.transform.position;
grabbedObject.transform.parent = originalParent;
grabbedObject.transform.position = pos;
}
if (before != null)
{
TransformObject after = new TransformObject(grabbedObject.transform);
if (MultiGrab)
{
MultiLayerMoveOperation op = new MultiLayerMoveOperation(LayerManager.Instance.LayerHelper, before, after);
OperationManager.Instance.PushOperation(op);
foreach (Layer layer in LayerManager.Instance.layers)
{
layer.transform.parent = LayerManager.Instance.LayersHolder.transform;
}
}
else
{
LayerMoveOperation op = new LayerMoveOperation(LayerManager.Instance.ActiveLayer, before, after);
OperationManager.Instance.PushOperation(op);
}
before = null;
}
grabbedObject = null;
originalParent = null;
movable = null;
resizable = null;
break;
case GrabState.Both:
grab = GrabState.One;
grabbedObject.transform.parent = controller == leftController ? rightController.transform : leftController.transform;
ToolController.Instance.ToggleSelectedTool(true);
break;
default:
break;
}
}
public virtual void ResizeSelectedShapes(double width, double height)
{
foreach (Shape shape in shapes)
{
ISelectable selectable = shape as ISelectable;
if (selectable != null && selectable.IsSelected)
{
IResizable resizable = shape as IResizable;
if (resizable != null)
{
resizable.Resize(width, height);
}
}
}
IsDirty = true;
}
public virtual void Render(Graphics g)
{
CanvasPaintArgs e = new CanvasPaintArgs();
e.g = g;
#region RenderShapes
foreach (Shape shape in shapes)
{
e.BorderPen = Pens.Black;
e.FillBrush = Brushes.White;
IDesignable designable = shape as IDesignable;
if (designable != null)
{
e.FillBrush = new SolidBrush(designable.FillColor);
e.BorderPen = new Pen(designable.BorderColor, designable.BorderSize);
}
shape.Render(e);
}
#endregion
#region RenderSelection
foreach (Shape shape in shapes)
{
ISelectable selectable = shape as ISelectable;
if (selectable != null && selectable.IsSelected)
{
selectable.RenderSelection(e);
IResizable resizable = shape as IResizable;
if (resizable != null)
{
resizable.RenderResize(e);
}
}
}
#endregion
}
public void Constructor_Default_Default()
{
// Arrange
this.underTest = new FluentResizable();
// Act
var underTestClass = underTest.Class;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(5)
.And
.OnlyHaveUniqueItems()
.And
.Match(x => x.All(v => v.StartsWith("flex-resize") && v.EndsWith("-unset")));
}
private void Should_not_maintain_aspect_ratio_by_default(IResizable resizable)
{
resizable.Width = 10;
resizable.Height = 20;
Assert.AreEqual(10, resizable.Width, 0.01);
Assert.AreEqual(20, resizable.Height, 0.01);
resizable.Height = 40;
Assert.AreEqual(10, resizable.Width, 0.01);
Assert.AreEqual(40, resizable.Height, 0.01);
resizable.Width = 20;
Assert.AreEqual(20, resizable.Width, 0.01);
Assert.AreEqual(40, resizable.Height, 0.01);
}
public void OnFullHD_SetsValue_Correctly()
{
// Arrange
this.underTest = Resizable.Is.OnFullHD(ResizableOption.NoGrow);
// Act
var underTestClass = underTest.Class;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(5)
.And
.OnlyHaveUniqueItems()
.And
.HaveElementAt(4, "flex-resize-xl-nogrow");
}
public void GetClass_NoGrow_Correctly()
{
// Arrange
this.underTest = Resizable.NoGrow;
// Act
var underTestClass = underTest.Class;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(5)
.And
.OnlyHaveUniqueItems()
.And
.Match(x => x.All(v => v.StartsWith("flex-resize") && v.EndsWith("-nogrow")));
}
private void ChangeHorizontal(double horizontalChange, IResizable resizable)
{
double deltaHorizontal;
switch (HorizontalAlignment)
{
case HorizontalAlignment.Left:
deltaHorizontal = Math.Min(horizontalChange, resizable.Width - resizable.MinWidth);
resizable.Left += deltaHorizontal;
resizable.Width -= deltaHorizontal;
break;
case HorizontalAlignment.Right:
deltaHorizontal = Math.Min(horizontalChange, resizable.Width - resizable.MinWidth);
resizable.Width += deltaHorizontal;
break;
default:
break;
}
}
private void AssociatedObjectOnDragDelta(object sender, DragDeltaEventArgs dragDeltaEventArgs)
{
IResizable resizable = this.AssociatedObject.DataContext as IResizable;
if (resizable == null)
{
return;
}
double deltaX = 0;
double deltaY = 0;
double offsetX = 0;
double offsetY = 0;
if ((ResizeDirection & Direction.Right) == Direction.Right)
{
deltaX = dragDeltaEventArgs.HorizontalChange;
}
if ((ResizeDirection & Direction.Left) == Direction.Left)
{
offsetX = dragDeltaEventArgs.HorizontalChange;
deltaX = -dragDeltaEventArgs.HorizontalChange;
}
if ((ResizeDirection & Direction.Bottom) == Direction.Bottom)
{
deltaY = dragDeltaEventArgs.VerticalChange;
}
if ((ResizeDirection & Direction.Top) == Direction.Top)
{
offsetY = dragDeltaEventArgs.VerticalChange;
deltaY = -dragDeltaEventArgs.VerticalChange;
}
resizable.Resize(deltaX, deltaY, offsetX, offsetY);
}
public Lab1()
{
InitializeComponent();
bitmapMain = new Bitmap(drawField.Width, drawField.Height);
bitmapSecondary = new Bitmap(drawField.Width, drawField.Height);
string path = "D:\\4 сем\\ооп\\1\\graphicEditor\\graphicEditor\\bin\\Debug";
string[] dirs = Directory.GetFiles(path);
for (int i = 0; i < dirs.Length; i++)
{
if (dirs[i].Contains(".dll"))
{
IResizable myObject = GetObject(dirs[i]);
if (myObject != null)
{
shapes.Add(myObject);
shapeComboBox.Items.Add(myObject.GetType().Name);
}
}
}
}
public GLResizer(IResizable Target) : base(0, 0)
{
this.m_Target = Target;
}
public GHResizer(IResizable Target)
: base(0, 0)
{
this.m_Target = Target;
}
public Vector2 ResetPosition(IResizable p)
{
return(p.GetStop() + new Vector2(-0.5f, -0.5f));
}
