public static WriteableBitmap Create(ISize s)
{
var wn = new WriteableBitmap(s.DrawWidth, s.DrawHeight);
//new Graphics(Color.Transparent, wn).fillRect(0, 0, w, h);
return(wn);
}
public GoogleProjectIcon(IIcon icon, IIconColor color, ISize size, string density)
{
this.Icon = icon;
this.Color = color;
this.Size = size;
this.Density = density;
}
public TextEditElement(IPosition position, ISize size, Func <string> readContent, Action <string> saveContent, StyleIndex styleIndex = StyleIndex.TextElement)
: base(position, size, styleIndex, readContent)
{
this.saveContent = saveContent;
Normalize();
}
/// <summary>
/// Initializes a new instance of the <see cref="CommonController" /> class.
/// </summary>
/// <param name="_iMaster">The i common.</param>
/// <param name="_iProductCategoryType">Type of the i product category.</param>
/// <param name="_iUser">The i user.</param>
/// <param name="_iSize">Size of the i.</param>
public MasterController(IMaster _iMaster, IProductCategoryType _iProductCategoryType, IUser _iUser, ISize _iSize)
{
iMaster = _iMaster;
iProductCategoryType = _iProductCategoryType;
iUser = _iUser;
iSize = _iSize;
}
public ValueRenderRectangle(Double x,
Double y,
ISize size,
IPoint2D offset)
: this(x, y, size.Width, size.Height, offset)
{
}
public MapFrame(ISize size)
{
Start = Coor.Empty;
Size = size;
ConstSize = (ISize)Size.Clone();
Scale = 1;
}
static private void GetSizePrivate(XElement element, ISize isize, int[] size)
{
IEnumerable <XElement> nl = element.GetChildNodes();
foreach (XElement n in nl)
{
if (!(n is XElement))
{
continue;
}
XElement e = n as XElement;
bool rec = false;
Action <XElement, int[]> gs = isize.GetSize(e, out rec);
int x = size[0];
int y = size[1];
gs(e, size);
if (x > size[0])
{
size[0] = x;
}
if (y > size[1])
{
size[1] = y;
}
if (rec)
{
GetSizePrivate(e, isize, size);
}
}
}
public static LandingArea Create(ISize landingAreaSize)
{
LandingArea landingArea = new LandingArea();
landingArea.SetSize(landingAreaSize);
return(landingArea);
}
///// <summary>
///// Generate a new image from the bitmap with the specified format, width, and height, and at the specified location.
///// Returns the actual size of the generated image, which may differ from the requested values by a pixel or so.
///// </summary>
///// <param name="sourceBmp">The bitmap containing an image from which to generate a new image with the
///// specified settings. This bitmap is not modified.</param>
///// <param name="newFilePath">The location on disk to store the image that is generated.</param>
///// <param name="newImageFormat">The new image format.</param>
///// <param name="newWidth">The width to make the new image.</param>
///// <param name="newHeight">The height to make the new image.</param>
///// <param name="newJpegQuality">The JPEG quality setting (0 - 100) for the new image. Only used if the
///// image format parameter is JPEG; ignored for all other formats.</param>
///// <returns>An instance of <see cref="Size" /> that describes the actual width and height of the generated image.</returns>
///// <exception cref="System.ArgumentNullException">sourceBmp</exception>
///// <exception cref="UnsupportedImageTypeException">Thrown when <paramref name="sourceBmp" />
///// cannot be resized to the requested dimensions.</exception>
///// <exception cref="ArgumentNullException">Thrown when <paramref name="sourceBmp" /> is null.</exception>
//public static Size SaveImageFile(System.Drawing.Image sourceBmp, string newFilePath, ImageFormat newImageFormat, double newWidth, double newHeight, int newJpegQuality)
//{
// if (sourceBmp == null)
// throw new ArgumentNullException(nameof(sourceBmp));
// //Create new bitmap with the new dimensions and in the specified format.
// Bitmap destinationBmp = CreateResizedBitmap(sourceBmp, sourceBmp.Size.Width, sourceBmp.Size.Height, newWidth, newHeight);
// try
// {
// SaveImageToDisk(destinationBmp, newFilePath, newImageFormat, newJpegQuality);
// return new Size(destinationBmp.Width, destinationBmp.Height);
// }
// finally
// {
// destinationBmp.Dispose();
// }
//}
///// <summary>
///// Overlay the text and/or image watermark over the image specified in the <paramref name="filePath" /> parameter and return.
///// </summary>
///// <param name="filePath">A string representing the full path to the image file
///// (e.g. "C:\mypics\myprettypony.jpg", "myprettypony.jpg").</param>
///// <param name="galleryId">The gallery ID. The watermark associated with this gallery is applied to the file.</param>
///// <returns>
///// Returns a System.Drawing.Image instance containing the image with the watermark applied.
///// </returns>
//public static System.Drawing.Image AddWatermark(string filePath, int galleryId)
//{
// Watermark wm = Factory.GetWatermarkInstance(galleryId);
// return wm.ApplyWatermark(filePath);
//}
///// <summary>
///// Create a new Bitmap with the specified dimensions.
///// </summary>
///// <param name="inputBmp">The source bitmap to use.</param>
///// <param name="sourceBmpWidth">The width of the input bitmap. This should be equal to inputBmp.Size.Width, but it is added as
///// a parameter so that calling code can send a cached value rather than requiring this method to query the bitmap for the data.
///// If a value less than zero is specified, then inputBmp.Size.Width is used.
///// </param>
///// <param name="sourceBmpHeight">The height of the input bitmap. This should be equal to inputBmp.Size.Height, but it is added as
///// a parameter so that calling code can send a cached value rather than requiring this method to query the bitmap for the data.</param>
///// If a value less than zero is specified, then inputBmp.Size.Height is used.
///// <param name="newWidth">The width of the new bitmap.</param>
///// <param name="newHeight">The height of the new bitmap.</param>
///// <returns>Returns a new Bitmap with the specified dimensions.</returns>
///// <exception cref="UnsupportedImageTypeException">Thrown when <paramref name="inputBmp"/>
///// cannot be resized to the requested dimensions. Typically this will occur during
///// <see cref="Graphics.DrawImage(System.Drawing.Image, Rectangle, Rectangle, GraphicsUnit)"/> because there is not enough system memory.</exception>
///// <exception cref="ArgumentNullException">Thrown when <paramref name="inputBmp" /> is null.</exception>
//public static Bitmap CreateResizedBitmap(System.Drawing.Image inputBmp, int sourceBmpWidth, int sourceBmpHeight, double newWidth, double newHeight)
//{
// //Adapted (but mostly copied) from http://www.codeproject.com/cs/media/bitmapmanip.asp
// //Create a new bitmap object based on the input
// if (inputBmp == null)
// throw new ArgumentNullException("inputBmp");
// if (sourceBmpWidth <= 0)
// sourceBmpWidth = inputBmp.Size.Width;
// if (sourceBmpHeight <= 0)
// sourceBmpHeight = inputBmp.Size.Height;
// double xScaleFactor = newWidth / sourceBmpWidth;
// double yScaleFactor = newHeight / sourceBmpHeight;
// int calculatedNewWidth = (int)(sourceBmpWidth * xScaleFactor);
// int calculatedNewHeight = (int)(sourceBmpHeight * yScaleFactor);
// if (calculatedNewWidth <= 0)
// {
// calculatedNewWidth = 1; // Make sure the value is at least 1.
// xScaleFactor = (float)calculatedNewWidth / (float)sourceBmpWidth; // Update the scale factor to reflect the new width
// }
// if (calculatedNewHeight <= 0)
// {
// calculatedNewHeight = 1; // Make sure the value is at least 1.
// yScaleFactor = (float)calculatedNewHeight / (float)sourceBmpHeight; // Update the scale factor to reflect the new height
// }
// Bitmap newBmp = null;
// try
// {
// newBmp = new Bitmap(calculatedNewWidth, calculatedNewHeight, PixelFormat.Format24bppRgb); //Graphics.FromImage doesn't like Indexed pixel format
// //Create a graphics object attached to the new bitmap
// using (Graphics newBmpGraphics = Graphics.FromImage(newBmp))
// {
// newBmpGraphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
// // Make background white. Without this a thin grey line is rendered along the top and left.
// // See http://social.msdn.microsoft.com/Forums/en-US/winforms/thread/2c9ac8d0-366c-4919-8f92-3a91c56f41e0/
// newBmpGraphics.Clear(Color.White);
// newBmpGraphics.ScaleTransform((float)xScaleFactor, (float)yScaleFactor);
// //Draw the bitmap in the graphics object, which will apply the scale transform.
// //Note that pixel units must be specified to ensure the framework doesn't attempt
// //to compensate for varying horizontal resolutions in images by resizing; in this case,
// //that's the opposite of what we want.
// Rectangle drawRect = new Rectangle(0, 0, sourceBmpWidth, sourceBmpHeight);
// lock (_sharedLock)
// {
// try
// {
// try
// {
// newBmpGraphics.DrawImage(inputBmp, drawRect, drawRect, GraphicsUnit.Pixel);
// }
// catch (OutOfMemoryException)
// {
// // The garbage collector will automatically run to try to clean up memory, so let's wait for it to finish and
// // try again. If it still doesn't work because the image is just too large and the system doesn't have enough
// // memory, catch the OutOfMemoryException and throw one of our UnsupportedImageTypeException exceptions instead.
// GC.WaitForPendingFinalizers();
// newBmpGraphics.DrawImage(inputBmp, drawRect, drawRect, GraphicsUnit.Pixel);
// }
// }
// catch (OutOfMemoryException)
// {
// throw new Events.CustomExceptions.UnsupportedImageTypeException();
// }
// }
// }
// }
// catch
// {
// if (newBmp != null)
// newBmp.Dispose();
// throw;
// }
// return newBmp;
//}
///// <overloads>Persist the specified image to disk at the specified path.</overloads>
///// <summary>
///// Persist the specified image to disk at the specified path. If the directory to contain the file does not exist, it
///// is automatically created.
///// </summary>
///// <param name="image">The image to persist to disk.</param>
///// <param name="newFilePath">The full physical path, including the file name to where the image is to be stored. Ex: C:\mypics\cache\2008\May\flower.jpg</param>
///// <param name="imageFormat">The file format for the image.</param>
///// <param name="jpegQuality">The quality value to save JPEG images at. This is a value between 1 and 100. This parameter
///// is ignored if the image format is not JPEG.</param>
///// <exception cref="ArgumentNullException">Thrown when <paramref name="imageFormat" /> is null.</exception>
//public static void SaveImageToDisk(System.Drawing.Image image, string newFilePath, ImageFormat imageFormat, int jpegQuality)
//{
// if (imageFormat == null)
// throw new ArgumentNullException("imageFormat");
// if (String.IsNullOrEmpty(newFilePath))
// throw new ArgumentNullException("newFilePath");
// VerifyDirectoryExistsForNewFile(newFilePath);
// if (imageFormat.Equals(ImageFormat.Jpeg))
// SaveJpgImageToDisk(image, newFilePath, jpegQuality);
// else
// SaveNonJpgImageToDisk(image, newFilePath, imageFormat);
//}
///// <summary>
///// Persist the specified image to disk at the specified path. If the directory to contain the file does not exist, it
///// is automatically created.
///// </summary>
///// <param name="imageData">The image to persist to disk.</param>
///// <param name="newFilePath">The full physical path, including the file name to where the image is to be stored. Ex: C:\mypics\cache\2008\May\flower.jpg</param>
///// <exception cref="ArgumentNullException">Thrown when <paramref name="imageData" /> or <paramref name="newFilePath" /> is null.</exception>
//public static void SaveImageToDisk(byte[] imageData, string newFilePath)
//{
// if (imageData == null)
// throw new ArgumentNullException("imageData");
// if (String.IsNullOrEmpty(newFilePath))
// throw new ArgumentNullException("newFilePath");
// VerifyDirectoryExistsForNewFile(newFilePath);
// File.WriteAllBytes(newFilePath, imageData);
//}
#endregion
#region Private Static Methods
//private static void SaveJpgImageToDisk(System.Drawing.Image image, string newFilepath, long jpegQuality)
//{
// //Save the image in the JPG format using the specified compression value.
// using (EncoderParameters eps = new EncoderParameters(1))
// {
// eps.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, jpegQuality);
// ImageCodecInfo ici = GetEncoderInfo("image/jpeg");
// image.Save(newFilepath, ici, eps);
// }
//}
///// <summary>
///// Make sure the directory exists for the file at the specified path. It is created if it does not exist.
///// (For example, it might not exist when the user changes the thumbnail or optimized location and subsequently
///// synchronizes. This process creates a new directory structure to match the directory structure where the
///// originals are stored, and there may be cases where we need to save a file to a directory that doesn't yet exist.
///// </summary>
///// <param name="newFilepath">The full physical path for which to verify the directory exists. Ex: C:\mypics\cache\2008\May\flower.jpg</param>
//private static void VerifyDirectoryExistsForNewFile(string newFilepath)
//{
// if (!Directory.Exists(Path.GetDirectoryName(newFilepath)))
// {
// Directory.CreateDirectory(Path.GetDirectoryName(newFilepath));
// }
//}
//private static void SaveNonJpgImageToDisk(System.Drawing.Image image, string newFilepath, System.Drawing.Imaging.ImageFormat imgFormat)
//{
// image.Save(newFilepath, imgFormat);
//}
//private static ImageCodecInfo GetEncoderInfo(String mimeType)
//{
// //Get the image codec information for the specified mime type.
// ImageCodecInfo[] encoders = ImageCodecInfo.GetImageEncoders();
// for (int j = 0; j < encoders.Length; ++j)
// {
// if (encoders[j].MimeType == mimeType)
// return encoders[j];
// }
// return null;
//}
/// <summary>
/// Calculate new width and height values of an existing <paramref name="size" /> instance, making the length
/// of the longest side equal to <paramref name="maxLength" />. The aspect ratio if preserved. If
/// <paramref name="autoEnlarge" /> is <c>true</c>, then increase the size so that the longest side equals <paramref name="maxLength" />
/// (i.e. enlarge a small image if necessary).
/// </summary>
/// <param name="size">The current size of an object.</param>
/// <param name="maxLength">The target length (in pixels) of the longest side.</param>
/// <param name="autoEnlarge">
/// A value indicating whether to enlarge objects that are smaller than the
/// <paramref name="size" />. If true, the new width and height will be increased if necessary. If false, the original
/// width and height are returned when their dimensions are smaller than <paramref name="maxLength" />. This
/// parameter has no effect when <paramref name="maxLength" /> is greater than the width and height of
/// <paramref name="size" />.
/// </param>
/// <returns>
/// Returns a <see cref="Size" /> instance conforming to the requested parameters.
/// </returns>
private static ISize CalculateWidthAndHeight(ISize size, int maxLength, bool autoEnlarge)
{
int newWidth, newHeight;
if (!autoEnlarge && (maxLength > size.Width) && (maxLength > size.Height))
{
// Bitmap is smaller than desired thumbnail dimensions but autoEnlarge = false. Don't enlarge thumbnail;
// just use original size.
newWidth = (int)size.Width;
newHeight = (int)size.Height;
}
else if (size.Width > size.Height)
{
// Bitmap is in landscape format (width > height). The width will be the longest dimension.
newWidth = maxLength;
newHeight = (int)(size.Height * newWidth / size.Width);
}
else
{
// Bitmap is in portrait format (height > width). The height will be the longest dimension.
newHeight = maxLength;
newWidth = (int)(size.Width * newHeight / size.Height);
}
return(new Size(newWidth, newHeight));
}
public RenderRectangle(IPoint2D location,
ISize size,
IPoint2D offset)
: base(location, size)
{
_offset = offset;
}
public void GetClass_IsElement_Correctly()
{
// Arrange
this.underTest = Size.IsElement(50);
// Act
var underTestClass = underTest.Class;
var underTestCss = underTest.Css;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(5)
.And
.OnlyHaveUniqueItems();
underTestCss.Should()
.NotBeNull()
.And
.HaveCount(5);
underTestCss.Keys.Should()
.Match(keys => keys.All(key => !string.IsNullOrWhiteSpace(key)));
underTestCss.Values.Should()
.Match(values => values.All(value => Regex.Matches(value, "50em").Count == 2));
}
public IPosition Move(ISize withinBoundary)
{
IPosition newPosition = this;
switch (this.Orientation)
{
case Oriented.NORTH:
newPosition = this.YAxis < withinBoundary.Lenght - 1 ? StepNorth(): this;
break;
case Oriented.EAST:
newPosition = this.XAxis < withinBoundary.Width - 1 ? StepEast() : this;
break;
case Oriented.SOUTH:
newPosition = this.YAxis > 0 ? StepSouth() : this;
break;
case Oriented.WEST:
newPosition = this.XAxis > 0 ? StepWest() : this;
break;
}
;
return(newPosition);
}
public IconDetailsViewModel(IIcon icon, ISize size = null, IIconColor color = null)
: this()
{
var sizes = icon.Provider.GetSizes();
var densities = icon.Provider.GetDensities();
// fill selection controls
this._icon = icon;
this._colors = new ObservableCollection <IIconColor>(MaterialIconColor.Get());
this._size = size ?? sizes.First();
this._sizes = new ObservableCollection <ISize>(sizes);
this._densities = new ObservableCollection <Selectable <string> >(
densities.Select(density => new Selectable <string>(density, !density.Contains("drawable"),
(x) => this.AddToProjectCommand.RaiseCanExecuteChanged())));
// fill user selection
this._color = color ?? MaterialIconColor.Black;
this._colorCode = this.ColorToCode(this._color.Color);
this._materialColorSelected = this._color is MaterialIconColor
? this._color
: MaterialIconColor.Black;
this._projectIcon = icon.Provider.CreateProjectIcon(this.Icon,
this.Color, this.Size, densities.FirstOrDefault());
this.GenerateName();
}
public void OnFullHD_SetsValue_Correctly()
{
// Arrange
this.underTest = Size.Is.OnFullHD("75px");
// Act
var underTestClass = underTest.Class;
var underTestCss = underTest.Css;
// Assert
underTestClass.Should().NotBeNullOrWhiteSpace();
underTestClass.Split(' ').Should()
.HaveCount(1)
.And
.OnlyHaveUniqueItems();
underTestCss.Should()
.NotBeNull()
.And
.HaveCount(1);
underTestCss.Keys.Should()
.Match(keys => keys.All(key => !string.IsNullOrWhiteSpace(key)));
var lines = underTestCss.Values.ToArray();
lines.Should().HaveCount(1);
lines[0].Should().Match(line => Regex.Matches(line, "75px").Count == 2);
}
public ValueCube(Double x,
Double y,
ISize size,
Double depth)
: this(x, y, size.Width, size.Height, depth)
{
}
public static Vector3 GetExtentPos(ISize obj, PosEnum pos)
{
float x, y;
if ((int)pos < 3)
{
y = obj.Center.y + obj.Height / 2f;
}
else if ((int)pos < 6)
{
y = obj.Center.y;
}
else
{
y = obj.Center.y - obj.Height / 2f;
}
if ((int)pos % 3 == 0)
{
x = obj.Center.x - obj.Width / 2f;
}
else if ((int)pos % 3 == 1)
{
x = obj.Center.x;
}
else
{
x = obj.Center.x + obj.Width / 2f;
}
return(Round(new Vector3(x, y, 0)));
}
public PuzzleSaver(ISize size, string filename, Broadcast broadcast)
{
_size = size;
_filename = filename;
_broadcast = broadcast;
_pixels = new Color[size.Width, size.Height];
}
public ValueIntRectangle(IPoint2D pos,
ISize size)
: this(Convert.ToInt32(pos.X),
Convert.ToInt32(pos.Y),
Convert.ToInt32(size.Width),
Convert.ToInt32(size.Height))
{
}
public BaseGdiDevice(Color?backgroundColor,
ISize size)
{
Invalidate(
Convert.ToInt32(size.Width),
Convert.ToInt32(size.Height),
backgroundColor);
}
public TextViewElement(IPosition position, ISize size, StyleIndex styleIndex = StyleIndex.TextElement, Func <string> readContent = null)
: base(position, size, styleIndex)
{
//this.text = (readContent == null) ? null : readContent();
this.readContent = readContent;
Normalize();
}
public HomeController(ISize sizeService, IDepth depthService, ITopping toppingService, IPizza pizzaService, IPizzaTopping pizzaToppingService)
{
_sizeService = sizeService;
_depthService = depthService;
_toppingService = toppingService;
_pizzaService = pizzaService;
_pizzaToppingService = pizzaToppingService;
}
public void Create_landing_area_success()
{
ISize landingAreaSize = Size.Create(100, 100);
ISize platformSize = Size.Create(10, 10);
IPosition platformoutPosition = Position.Create(5, 5);
Assert.NotNull(Landings.Create(landingAreaSize, platformSize, platformoutPosition));
}
public void Resize(ISize newSize)
{
var oldSizeVector = canvasItem.GetSize().ToVector();
var newSizeVector = newSize.ToVector();
var deltaSize = newSizeVector.Subtract(oldSizeVector);
DeltaResize(deltaSize);
}
public void ShouldReturnSize()
{
//arrange
ISize actualsSize = CharacterRace.WoodElf.Size();
//assert
actualsSize.Should().Be(new Medium());
}
public ProjectIconDesign(IIcon icon, IIconColor color, ISize size, string density)
{
this.Icon = icon;
this.FullName = icon.Name;
this.Color = color;
this.Size = size;
this.Density = density;
}
public Region(IPosition position, ISize size, StyleIndex styleIndex = StyleIndex.Default)
{
this.row = position.row;
this.col = position.col;
this.width = size.width;
this.height = size.height;
this.styleIndex = styleIndex;
}
private long GetDocumentSize(ISize doc)
{
if (doc == null)
{
return(1);
}
return(doc.Size);
}
public void SetSize(ISize size)
{
if (size == null)
{
throw new ArgumentNullException(nameof(size));
}
_size = Aggregates.Size.Create(size.X, size.Y);
}
public static LandingPlatform Create(ISize size, IPosition position, int platformRocketSeparation)
{
LandingPlatform landingPlatform = new LandingPlatform();
landingPlatform.SetSize(size);
landingPlatform.SetPlatformPosition(position);
landingPlatform.SetPlatformRocketSeparation(platformRocketSeparation);
return(landingPlatform);
}
public ProductCategoryAPIController(IProductCategoryService _categoryService, IAscending _ascending, ICount _count, IPageNumber _number, ISize _size, IItemSearch _itemSearch)
{
this.categoryService = _categoryService;
this.ascending = _ascending;
this.count = _count;
this.number = _number;
this.size = _size;
this.itemSearch = _itemSearch;
}
public HubSaver(ISize size, string filename, Broadcast broadcast, Queue queue)
{
_queue = queue;
_puzzleSaver = new PuzzleSaver(size, filename, broadcast);
_heatmapSaver = new HeatmapSaver(size, filename, broadcast);
_tileSaver = new TileSaver(size, filename, broadcast);
_creators = new[] { _puzzleSaver, _heatmapSaver, _tileSaver, };
}
public static Size GetOrientatedSize(ISize media, MediaOrientation orientation)
{
switch (orientation)
{
case MediaOrientation.Transpose:
case MediaOrientation.Rotate90:
case MediaOrientation.Transverse:
case MediaOrientation.Rotate270 : return new Size(media.Height, media.Width);
default : return new Size(media.Width, media.Height);
}
}
public static Rectangle CalculateCropRectangle(ISize sourceSize, ISize targetSize, Alignment anchor)
{
var x = 0d;
var y = 0d;
var nPercent = 0d;
double nPercentW = (double)targetSize.Width / (double)sourceSize.Width;
double nPercentH = (double)targetSize.Height / (double)sourceSize.Height;
if (nPercentH < nPercentW)
{
nPercent = nPercentW;
switch (anchor)
{
case Alignment.Top:
y = 0;
break;
case Alignment.Bottom:
y = targetSize.Height - (sourceSize.Height * nPercent);
break;
default:
y = (targetSize.Height - (sourceSize.Height * nPercent)) / 2d;
break;
}
}
else
{
nPercent = nPercentH;
switch (anchor)
{
case Alignment.Left:
y = 0;
break;
case Alignment.Right:
x = targetSize.Width - (sourceSize.Width * nPercent);
break;
default:
x = (targetSize.Width - (sourceSize.Width * nPercent)) / 2d;
break;
}
}
return new Rectangle(
x: (int)x,
y: (int)y,
width: (int)(sourceSize.Width * nPercent),
height: (int)(sourceSize.Height * nPercent)
);
}
public Polygon FromPercentages(ISize size)
{
var bounds = Vector2f.Create(size);
var scaled = new Vector2f[Vertices.Length];
var i = 0;
foreach (var vector in Vertices)
{
scaled[i] = Vector2f.Create(vector.X * bounds.X, vector.Y * bounds.Y);
i++;
}
return new Polygon(scaled);
}
public static Vector2f Create(ISize size)
=> new Vector2f { X = size.Width, Y = size.Height };
public Rectangle( ISize size )
: this(0, size.Width - 1, size.Height - 1, 0)
{
}
public static bool FitsIn(this ISize source, ISize target)
=> source.Width <= target.Width && source.Height <= target.Height;
/// <summary>
/// Draws the character when scaled to geographic sizes.
/// </summary>
/// <param name="character"></param>
/// <param name="center"></param>
/// <param name="size"></param>
public virtual void DrawCharacter(ICharacterSymbol character, ICoordinate center, ISize size)
{
Envelope env = new Envelope(center.X - size.XSize / 2, center.X + size.XSize / 2, center.Y - size.YSize / 2, center.Y + size.YSize / 2);
Rectangle r = ProjToBuffer(env);
Font tempFont = new Font(character.FontFamilyName, r.Height, character.Style, GraphicsUnit.Pixel);
Brush brush = new SolidBrush(character.Color);
_device.TextContrast = 0;
_device.TextRenderingHint = System.Drawing.Text.TextRenderingHint.AntiAlias;
_device.DrawString(character.ToString(), tempFont, brush, r.Left, r.Top);
brush.Dispose();
tempFont.Dispose();
}
public GridSnappingEngine(ISize gridSize, double threshold)
: base(threshold)
{
GridSize = gridSize;
}
ILogo IPrintLayout.CreateLogo(string symbolLibraryId, string symbolName, ISize size, IPosition position)
{
var logo = new PrintLayoutLogo()
{
Name = symbolName,
ResourceId = symbolLibraryId,
Position = (PrintLayoutLogoPosition)position,
Size = (PrintLayoutLogoSize)size
};
return logo;
}
public MediaRenditionInfo(ISize size, string path)
: this(size.Width, size.Height, path)
{ }
public static Size CalculateScaledSize(ISize source, Size maxSize)
{
#region Preconditions
if (source == null)
throw new ArgumentNullException("source");
#endregion
return CalculateScaledSize(new Size(source.Width, source.Height), maxSize);
}
public static Size CalculateScaledSize(ISize source, double scale)
{
#region Preconditions
if (source == null) throw new ArgumentNullException("source");
#endregion
return new Size(
width: (int)(source.Height * scale),
height: (int)(source.Width * scale)
);
}
