private static PaddingInfo GetPaddingInfo(JObject padding)
{
var result = new PaddingInfo();
int value;
if (padding.GetStyle(LeftName, out value))
{
result.Left = value;
}
if (padding.GetStyle(RightName, out value))
{
result.Right = value;
}
if (padding.GetStyle(TopName, out value))
{
result.Top = value;
}
if (padding.GetStyle(BottomName, out value))
{
result.Bottom = value;
}
return(result);
}
public static TextureRegionAtlas FromXml(string xml, Func <string, Texture2D> textureGetter)
{
var doc = XDocument.Parse(xml);
var root = doc.Root;
var result = new TextureRegionAtlas();
var imageFileAttr = root.Attribute(ImageName);
if (imageFileAttr == null)
{
throw new Exception("Mandatory attribute 'ImageFile' doesnt exist");
}
result.Image = imageFileAttr.Value;
var texture = textureGetter(result.Image);
foreach (XElement entry in root.Elements())
{
var id = entry.Attribute(BaseContext.IdName).Value;
var bounds = new Rectangle(
int.Parse(entry.Attribute(LeftName).Value),
int.Parse(entry.Attribute(TopName).Value),
int.Parse(entry.Attribute(WidthName).Value),
int.Parse(entry.Attribute(HeightName).Value)
);
var isNinePatch = entry.Name == NinePatchRegionName;
TextureRegion region;
if (!isNinePatch)
{
region = new TextureRegion(texture, bounds);
}
else
{
var padding = new PaddingInfo
{
Left = int.Parse(entry.Attribute(NinePatchLeftName).Value),
Top = int.Parse(entry.Attribute(NinePatchTopName).Value),
Right = int.Parse(entry.Attribute(NinePatchRightName).Value),
Bottom = int.Parse(entry.Attribute(NinePatchBottomName).Value)
};
region = new NinePatchRegion(texture, bounds, padding);
}
result[id] = region;
}
return(result);
}
public WidgetStyle(WidgetStyle style)
{
WidthHint = style.WidthHint;
HeightHint = style.HeightHint;
Background = style.Background;
OverBackground = style.OverBackground;
DisabledBackground = style.DisabledBackground;
FocusedBackground = style.FocusedBackground;
Border = style.Border;
OverBorder = style.OverBorder;
DisabledBorder = style.DisabledBorder;
FocusedBorder = style.FocusedBorder;
Padding = style.Padding;
}
public static TextureRegionAtlas FromXml(string xml, Texture2D texture)
{
var doc = XDocument.Parse(xml);
var root = doc.Root;
var regions = new Dictionary <string, TextureRegion>();
foreach (XElement entry in root.Elements())
{
var id = entry.Attribute(BaseContext.IdName).Value;
var bounds = new Rectangle(
int.Parse(entry.Attribute(LeftName).Value),
int.Parse(entry.Attribute(TopName).Value),
int.Parse(entry.Attribute(WidthName).Value),
int.Parse(entry.Attribute(HeightName).Value)
);
var isNinePatch = entry.Name == NinePatchRegionName;
TextureRegion region;
if (!isNinePatch)
{
region = new TextureRegion(texture, bounds);
}
else
{
var padding = new PaddingInfo
{
Left = int.Parse(entry.Attribute(NinePatchLeftName).Value),
Top = int.Parse(entry.Attribute(NinePatchTopName).Value),
Right = int.Parse(entry.Attribute(NinePatchRightName).Value),
Bottom = int.Parse(entry.Attribute(NinePatchBottomName).Value)
};
region = new NinePatchRegion(texture, bounds, padding);
}
regions[id] = region;
}
return(new TextureRegionAtlas(regions));
}
private void RenderEventTableOnReport(ChartRenderModel model)
{
if (model.EventList != null && model.EventList.Count > 0)
{
PaddingInfo info = new PaddingInfo();
info.Top = 10;
info.Bottom = 5;
foreach (var item in model.EventList)
{
XRTableRow row = new XRTableRow();
XRTableCell cell = new XRTableCell();
cell.WidthF = 182.5f;
cell.Text = item.DatumOtvoritve.ToShortDateString();
cell.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter;
row.Cells.Add(cell);
cell = new XRTableCell();
cell.WidthF = 182.5f;
cell.Text = item.Rok.CompareTo(DateTime.MaxValue) > 0 ? item.Rok.ToShortDateString() : "Not-defined";
cell.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter;
row.Cells.Add(cell);
cell = new XRTableCell();
cell.WidthF = 515f;
cell.Text = !String.IsNullOrEmpty(item.Opis) ? item.Opis : "Not-defined";
cell.TextAlignment = DevExpress.XtraPrinting.TextAlignment.MiddleCenter;
cell.Multiline = true;
row.Cells.Add(cell);
row.Padding = info;
xrTableDogodki.Rows.Add(row);
}
}
else
{
xrTableDogodki.Visible = false;
xrLabelTitleDogodki.Visible = false;
}
}
public static TextureRegionAtlas FromJson(string json, Texture2D texture)
{
var root = JObject.Parse(json);
var regions = new Dictionary <string, TextureRegion>();
foreach (var pair in root)
{
var entry = pair.Value;
var jBounds = entry[StylesheetLoader.BoundsName];
var bounds = new Rectangle(int.Parse(jBounds[StylesheetLoader.LeftName].ToString()),
int.Parse(jBounds[StylesheetLoader.TopName].ToString()),
int.Parse(jBounds[StylesheetLoader.WidthName].ToString()),
int.Parse(jBounds[StylesheetLoader.HeightName].ToString()));
TextureRegion region;
if (entry[StylesheetLoader.TypeName].ToString() == "0")
{
region = new TextureRegion(texture, bounds);
}
else
{
var jPadding = entry[StylesheetLoader.PaddingName];
var padding = new PaddingInfo
{
Left = int.Parse(jPadding[StylesheetLoader.LeftName].ToString()),
Top = int.Parse(jPadding[StylesheetLoader.TopName].ToString()),
Right = int.Parse(jPadding[StylesheetLoader.RightName].ToString()),
Bottom = int.Parse(jPadding[StylesheetLoader.BottomName].ToString())
};
region = new NinePatchRegion(texture, bounds, padding);
}
regions[pair.Key.ToString()] = region;
}
return(new TextureRegionAtlas(regions));
}
public static TextureRegionAtlas FromGDX(string data, Func <string, Texture2D> textureLoader)
{
var mode = GDXMode.PageHeader;
GDXPageData pageData = null;
var spriteDatas = new Dictionary <string, GDXSpriteData>();
using (var textReader = new StringReader(data))
{
GDXSpriteData spriteData = null;
while (true)
{
var s = textReader.ReadLine();
if (s == null)
{
break;
}
s = s.Trim();
if (string.IsNullOrEmpty(s))
{
// New PageData
pageData = null;
continue;
}
if (pageData == null)
{
var texture = textureLoader(s);
if (texture == null)
{
throw new Exception(string.Format("Unable to resolve texture {0}", s));
}
pageData = new GDXPageData {
Texture = texture
};
mode = GDXMode.PageHeader;
continue;
}
if (!s.Contains(":"))
{
spriteData = new GDXSpriteData
{
PageData = pageData,
Name = s
};
spriteDatas[s] = spriteData;
mode = GDXMode.Sprite;
continue;
}
var parts = s.Split(':');
var key = parts[0].Trim().ToLower();
var value = parts[1].Trim();
switch (key)
{
case "format":
SurfaceFormat format;
if (!Enum.TryParse(value, out format))
{
format = SurfaceFormat.Color;
}
pageData.Format = format;
break;
case "filter":
parts = value.Split(',');
var minFilter = (GDXTextureFilter)Enum.Parse(typeof(GDXTextureFilter), parts[0].Trim());
var magFilter = (GDXTextureFilter)Enum.Parse(typeof(GDXTextureFilter), parts[1].Trim());
pageData.Filter = FromGDXFilters(minFilter, magFilter);
break;
case "repeat":
if (value == "x")
{
pageData.UWrap = TextureAddressMode.Wrap;
}
else if (value == "y")
{
pageData.VWrap = TextureAddressMode.Wrap;
}
else if (value == "xy")
{
pageData.UWrap = TextureAddressMode.Wrap;
pageData.VWrap = TextureAddressMode.Wrap;
}
break;
case "rotate":
bool isRotated;
bool.TryParse(value, out isRotated);
spriteData.IsRotated = isRotated;
break;
case "xy":
parts = value.Split(',');
spriteData.SourceRectangle.X = int.Parse(parts[0].Trim());
spriteData.SourceRectangle.Y = int.Parse(parts[1].Trim());
break;
case "size":
if (spriteData == null)
{
continue;
}
parts = value.Split(',');
spriteData.SourceRectangle.Width = int.Parse(parts[0].Trim());
spriteData.SourceRectangle.Height = int.Parse(parts[1].Trim());
break;
case "orig":
parts = value.Split(',');
spriteData.OriginalSize = new Point(int.Parse(parts[0].Trim()), int.Parse(parts[1].Trim()));
break;
case "offset":
parts = value.Split(',');
spriteData.Offset = new Point(int.Parse(parts[0].Trim()), int.Parse(parts[1].Trim()));
break;
case "split":
parts = value.Split(',');
var split = new PaddingInfo
{
Left = int.Parse(parts[0].Trim()),
Right = int.Parse(parts[1].Trim()),
Top = int.Parse(parts[2].Trim()),
Bottom = int.Parse(parts[3].Trim())
};
spriteData.Split = split;
break;
}
}
}
var drawables = new Dictionary <string, TextureRegion>();
foreach (var sd in spriteDatas)
{
var texture = sd.Value.PageData.Texture;
var bounds = sd.Value.SourceRectangle;
TextureRegion drawable;
if (!sd.Value.Split.HasValue)
{
drawable = new TextureRegion(texture, bounds);
}
else
{
drawable = new NinePatchRegion(texture, bounds, sd.Value.Split.Value);
}
drawables[sd.Key] = drawable;
}
return(new TextureRegionAtlas(drawables));
}
private static PaddingInfo CalculatePadding(IEnumerable <TunnelMessage> messages, I2PTunnelId desttunnel)
{
var result = new PaddingInfo();
int tunneldatabufferavailable = FREE_SPACE_IN_DATA_MESSAGE_BODY;
var currenttdrecord = new TunnelDataConstructionInfo(desttunnel);
result.TDMessages.Add(currenttdrecord);
var lastix = messages.Count() - 1;
var ix = 0;
foreach (var one in messages)
{
var lastmessage = ix++ == lastix;
var data = one.Message.CreateHeader16.HeaderAndPayload;
var datareader = new BufRefLen(data);
nexttunneldatablock:
int firstfragmentheadersize;
bool fragmented = false;
switch (one.Delivery)
{
case TunnelMessage.DeliveryTypes.Local:
firstfragmentheadersize = 3;
if (data.Length + firstfragmentheadersize > tunneldatabufferavailable)
{
firstfragmentheadersize += 4; // Need message id
fragmented = true;
}
break;
case TunnelMessage.DeliveryTypes.Router:
firstfragmentheadersize = 35;
if (data.Length + firstfragmentheadersize > tunneldatabufferavailable)
{
firstfragmentheadersize += 4; // Need message id
fragmented = true;
}
break;
case TunnelMessage.DeliveryTypes.Tunnel:
firstfragmentheadersize = 39;
if (data.Length + firstfragmentheadersize > tunneldatabufferavailable)
{
firstfragmentheadersize += 4; // Need message id
fragmented = true;
}
break;
default:
throw new NotImplementedException();
}
var freespace = tunneldatabufferavailable - firstfragmentheadersize;
if (freespace < TUNNEL_DATA_MESSAGE_FREE_SPACE_LOW_WATERMARK)
{
currenttdrecord.PaddingNeeded = tunneldatabufferavailable;
currenttdrecord = new TunnelDataConstructionInfo(desttunnel);
result.TDMessages.Add(currenttdrecord);
tunneldatabufferavailable = FREE_SPACE_IN_DATA_MESSAGE_BODY;
goto nexttunneldatablock;
}
// Might fit, and have at least TUNNEL_DATA_MESSAGE_FREE_SPACE_LOW_WATERMARK bytes for payload.
var useddata = fragmented ? freespace : datareader.Length;
var usedspace = firstfragmentheadersize + useddata;
currenttdrecord.Fragments.Add(
new TunnelDataFragmentCreation(
currenttdrecord.TunnelDataInstance,
one,
new BufLen(datareader, 0, useddata),
fragmented));
datareader.Seek(useddata);
tunneldatabufferavailable -= usedspace;
int fragnr = 1;
while (datareader.Length > 0)
{
if (tunneldatabufferavailable < TUNNEL_DATA_MESSAGE_FREE_SPACE_LOW_WATERMARK + FOLLOW_ON_FRAGMENT_HEADER_SIZE)
{
currenttdrecord.PaddingNeeded = tunneldatabufferavailable;
currenttdrecord = new TunnelDataConstructionInfo(desttunnel);
result.TDMessages.Add(currenttdrecord);
tunneldatabufferavailable = FREE_SPACE_IN_DATA_MESSAGE_BODY;
}
freespace = tunneldatabufferavailable - FOLLOW_ON_FRAGMENT_HEADER_SIZE;
if (datareader.Length <= freespace)
{
currenttdrecord.Fragments.Add(
new TunnelDataFragmentFollowOn(
currenttdrecord.TunnelDataInstance,
one,
new BufLen(datareader),
fragnr++, true
));
tunneldatabufferavailable -= FOLLOW_ON_FRAGMENT_HEADER_SIZE + datareader.Length;
datareader.Seek(datareader.Length);
if (lastmessage)
{
currenttdrecord.PaddingNeeded = tunneldatabufferavailable;
return(result);
}
}
else
{
useddata = freespace;
currenttdrecord.Fragments.Add(
new TunnelDataFragmentFollowOn(
currenttdrecord.TunnelDataInstance,
one,
new BufLen(datareader, 0, useddata),
fragnr++,
false
));
datareader.Seek(useddata);
tunneldatabufferavailable = 0;
}
}
}
currenttdrecord.PaddingNeeded = tunneldatabufferavailable;
return(result);
}
// This is how slicing works:
// take the original image, and copy it in chunks - each equal to a size of a piece, including padding around the sides
// to the new "sliced" texture. But when copying, also do a UV lookup into the array that represents the mask; and only
// copy those pixels that are not blocked (and also take the masks's borders into consideration). So essentially bake
// the masked pieces onto a larger texture. Then we can use that one and only texture, with different UVs, to draw every
// single piece.
public static IEnumerator CreateAndSaveSlicedTextureRoutine(SlicingInfo slicingInfo, Texture2D originalTexture,
Texture2D slicedTexture,
string originalTexturePath,
MaskContainer maskContainer,
Dictionary <IntVector2, PieceInfo> pieceInfos,
System.Action <float> onProgress)
{
//TODO maybe we could rationalize these
var rows = slicingInfo.rows;
var columns = slicingInfo.columns;
var originalSize = new Vector2(originalTexture.width, originalTexture.height);
var paddedPieceSize = GetPaddedPieceSize(rows, columns, originalSize);
var pieceSize = new Vector2((float)originalSize.x / (float)columns,
(float)originalSize.y / (float)rows);
var padding = (paddedPieceSize - pieceSize) / 2f;
var borderColor = Color.black;
var paddedPixelCountX = Mathf.FloorToInt(paddedPieceSize.x);
var paddedPixelCountY = Mathf.FloorToInt(paddedPieceSize.y);
var piecePixels = new Color[paddedPixelCountX * paddedPixelCountY];
var maskPixels = new Color[MaskCreator.width * MaskCreator.height];
onProgress(0f);
var thingsToLoadCount = rows * columns + 1; // "+1" for the extra step in the end, assigning textures etc.
// this is just cosmetics- showing the loading indicator
var thingsLoadedSoFar = 0f;
for (int column = 0; column < columns; ++column)
{
for (int row = 0; row < rows; ++row)
{
CreateMask(maskContainer, pieceInfos, row, column, maskPixels);
var sourceOffsetX = Mathf.RoundToInt(pieceSize.x * column - padding.x);
var sourceOffsetY = Mathf.RoundToInt(pieceSize.y * row - padding.y);
var destOffsetX = Mathf.RoundToInt(paddedPieceSize.x * column);
var destOffsetY = Mathf.RoundToInt(paddedPieceSize.y * row);
var dimensions = new Dimension
{
currentRow = row,
currentColumn = column,
rows = rows,
columns = columns
};
var paddingInfo = new PaddingInfo
{
padding = padding,
paddedPieceSize = paddedPieceSize,
paddedPixelCount = new IntVector2(paddedPixelCountX, paddedPixelCountY)
};
TextureUtility.CopyMaskedPieceDataIntoPiecePixelsArray(dimensions, originalTexture, paddingInfo,
new IntVector2(sourceOffsetX, sourceOffsetY),
piecePixels, maskPixels, borderColor);
slicedTexture.SetPixels(destOffsetX, destOffsetY, paddedPixelCountX, paddedPixelCountY, piecePixels, 0);
thingsLoadedSoFar += 1f;
onProgress(thingsLoadedSoFar / thingsToLoadCount);
yield return(null);
}
}
TextureUtility.ExportTexture(slicedTexture, rows, columns, originalSize, originalTexturePath);
}
protected string RegisterHtmlClassName(HtmlExportContext context, BrickStyle style, PaddingInfo borders, PaddingInfo padding)
{
return(DataCellExportHelper.RegisterHtmlClassName(context, style, borders, padding));
}
public static string RegisterHtmlClassName(HtmlExportContext context, BrickStyle style, PaddingInfo borders, PaddingInfo padding)
{
if (style == null)
{
return(String.Empty);
}
string htmlStyle = PSHtmlStyleRender.GetHtmlStyle(style.Font, style.ForeColor, style.BackColor, style.BorderColor, borders, padding, style.BorderDashStyle, context.RightToLeftLayout);
return(context.ScriptContainer.RegisterCssClass(htmlStyle));
}
public NinePatchRegion(Texture2D texture, Rectangle bounds, PaddingInfo info) : base(texture, bounds)
{
_info = info;
var centerWidth = bounds.Width - info.Left - info.Right;
var centerHeight = bounds.Height - info.Top - info.Bottom;
var y = bounds.Y;
if (info.Top > 0)
{
if (info.Left > 0)
{
_topLeft = new TextureRegion(texture,
new Rectangle(bounds.X,
y,
info.Left,
info.Top));
}
if (centerWidth > 0)
{
_topCenter = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left,
y,
centerWidth,
info.Top));
}
if (info.Right > 0)
{
_topRight = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left + centerWidth,
y,
info.Right,
info.Top));
}
}
y += info.Top;
if (centerHeight > 0)
{
if (info.Left > 0)
{
_centerLeft = new TextureRegion(texture,
new Rectangle(bounds.X,
y,
info.Left,
centerHeight));
}
if (centerWidth > 0)
{
_center = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left,
y,
centerWidth,
centerHeight));
}
if (info.Right > 0)
{
_centerRight = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left + centerWidth,
y,
info.Right,
centerHeight));
}
}
y += centerHeight;
if (info.Bottom > 0)
{
if (info.Left > 0)
{
_bottomLeft = new TextureRegion(texture,
new Rectangle(bounds.X,
y,
info.Left,
info.Bottom));
}
if (centerWidth > 0)
{
_bottomCenter = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left,
y,
centerWidth,
info.Bottom));
}
if (info.Right > 0)
{
_bottomRight = new TextureRegion(texture,
new Rectangle(bounds.X + info.Left + centerWidth,
y,
info.Right,
info.Bottom));
}
}
}
public static void CopyMaskedPieceDataIntoPiecePixelsArray(Dimension dimensions,
Texture2D paddedTexture,
PaddingInfo paddingInfo,
IntVector2 sourceOffset,
Color[] piecePixels,
Color[] maskPixels,
Color borderColor)
{
var sourceColor = new Color();
var emptyColor = new Color();
var outlineColor = new Color(0.1f, 0f, 0f, 0f);
int offsetX = Mathf.Max(0, sourceOffset.x);
int offsetY = Mathf.Max(0, sourceOffset.y);
if (dimensions.currentColumn == dimensions.columns - 1)
{
offsetX = paddedTexture.width - paddingInfo.paddedPixelCount.x;
}
if (dimensions.currentRow == dimensions.rows - 1)
{
offsetY = paddedTexture.height - paddingInfo.paddedPixelCount.y;
}
var pieceRectangle = paddedTexture.GetPixels(offsetX, offsetY,
paddingInfo.paddedPixelCount.x,
paddingInfo.paddedPixelCount.y);
for (int x = 0; x < paddingInfo.paddedPixelCount.x; ++x)
{
var maskDataXOffset = (int)(x / paddingInfo.paddedPieceSize.x * MaskCreator.width);
for (int y = 0; y < paddingInfo.paddedPixelCount.y; ++y)
{
var maskData = maskPixels[(int)((y / paddingInfo.paddedPieceSize.y) * MaskCreator.height) * MaskCreator.width
+ maskDataXOffset];
sourceColor = emptyColor;
var currentPixelVisible = maskData.a > 0.5f;
var isBorder = maskData.r > 0.3f;
var isHighlight = maskData.b > 0.3f;
if (currentPixelVisible)
{
if (isBorder)
{
sourceColor = borderColor;
}
else
{
if ((dimensions.currentRow == 0 && y < paddingInfo.padding.y) ||
(dimensions.currentRow == dimensions.rows - 1 && y > (paddingInfo.paddedPieceSize.y - paddingInfo.padding.y)) ||
(dimensions.currentColumn == 0 && x < paddingInfo.padding.x) ||
(dimensions.currentColumn == dimensions.columns - 1 && x > (paddingInfo.paddedPieceSize.x - paddingInfo.padding.x)))
{
//sourceColor = emptyColor;
}
else
{
if (!isHighlight)
{
var actualOffsetX = x;
var actualOffsetY = y;
if (dimensions.currentColumn == 0)
{
actualOffsetX -= (int)paddingInfo.padding.x;
}
if (dimensions.currentRow == 0)
{
actualOffsetY -= (int)paddingInfo.padding.y;
}
if (dimensions.currentColumn == dimensions.columns - 1)
{
actualOffsetX += (int)paddingInfo.padding.x;
}
if (dimensions.currentRow == dimensions.rows - 1)
{
actualOffsetY += (int)paddingInfo.padding.y;
}
sourceColor = pieceRectangle[actualOffsetX + (actualOffsetY * paddingInfo.paddedPixelCount.x)];
}
else
{
sourceColor = outlineColor;
}
}
}
}
piecePixels[x + (y * paddingInfo.paddedPixelCount.x)] = sourceColor;
}
}
}
