public override void Call()
{
Menu.PrintHelp();
var path = Menu.GetUserInput("path:"); //@"C:\Users\Alexandr\Desktop\TEST";
var analyzer = new Analyzer(new Tager(new FileLoader()));
var mask = new Mask(Menu.GetUserInput("mask:"));
var plan=analyzer.BuildPlan(Directory.GetFiles(path), mask);
if (!analyzer.NotSynchronizedFiles.Any()&&!analyzer.ErrorFiles.Keys.Any())
{
Menu.PrintMessage("All files is OK");
Menu.GetUserInput("Press enter...");
return;
}
if (analyzer.ErrorFiles.Keys.Any())
Menu.PrintCollection(
string.Format("{0} files can't be synchronized", analyzer.ErrorFiles.Count()),
analyzer.ErrorFiles,ConsoleColor.Red);
Menu.PrintCollection("Not synchronized files:", (from file in analyzer.NotSynchronizedFiles select file.Key.Name + ".mp3 with "+file.Value), ConsoleColor.Red);
Menu.PrintCollection("Synchronized files:", (from file in analyzer.SynchronizedFiles select file.Name+".mp3"), ConsoleColor.Green);
Menu.PrintPlan(plan);
if (Menu.GetYesNoAnswer("Save this plan?\nY/N:"))
{
PlanProvider provider=new PlanProvider();
provider.Save(plan,Menu.GetUserInput("path:"));
}
}
public override void Call()
{
if (IsCanceled)
{
_synchronizer.Redo();
return;
}
var path = Menu.GetUserInput("path:"); //@"C:\Users\Alexandr\Desktop\TEST";
var tager = new Tager(new FileLoader());
var analyzer = new Analyzer(tager, s => Path.GetExtension(s).ToLower() == ".mp3");
Menu.PrintHelp();
var mask = new Mask(Menu.GetUserInput("mask:"));
analyzer.Analyze(Directory.GetFiles(path), mask);
_synchronizer = new Synchronizer(tager,Menu.SelectSyncRule());
_synchronizer.Sync(analyzer.NotSynchronizedFiles.Keys, mask);
Menu.PrintChanges(_synchronizer.ModifiedFiles);
if (Menu.GetYesNoAnswer("Save changes?\nY/N:"))
{
_synchronizer.Save();
Menu.PrintMessage("Successfully");
Menu.PrintCollection(string.Format("with {0} errors", _synchronizer.ErrorFiles.Count), _synchronizer.ErrorFiles, ConsoleColor.Red);
Menu.GetUserInput("Press enter...");
}
}
public PlanItem(Mask mask, string path, ISyncRule rule, string message)
{
Mask = mask;
FilePath = path;
Rule = rule;
Message = message;
}
public static void Write(string moduleName, Exception exception, Mask mask)
{
LogScope scope = LogScope.Current;
if (scope != null && scope.Name != null)
GetTraceLog(moduleName).LogEvent(string.Format("{0} - Exception! {1}", scope.Name, exception.Message), exception, (long)mask);
else
GetTraceLog(moduleName).LogEvent(string.Format("Exception! {1}", exception.Message), exception, (long)mask);
}
public static void Write(string moduleName, string message, Mask mask)
{
LogScope scope = LogScope.Current;
if (scope != null && scope.Name != null)
GetTraceLog(moduleName).LogEvent(string.Format("{0} - {1}", scope.Name, message), (long)mask);
else
GetTraceLog(moduleName).LogEvent(string.Format("{0}", message), (long)mask);
}
public void NameNotChangeIfTagIsEmpty()
{
var tags = new Mp3Tags() { Album = "Album", Artist = "", Comment = "Comment", Genre = "Genre", Title = "Title", Year = 2015, Track = 1 };
var mask = new Mask("[{track}]. {artist} - {title} {year} live in Russia");
_testTager.Load("oldfilename");
_testTager.ChangeTags(tags);
_testTager.ChangeName(mask);
}
public void Init()
{
_testMask=new Mask("{artist} {title}");
_testTager=new Tager(new TestFileLoader());
_synchronizer=new Synchronizer(_testTager);
_fileWithBadName=new TestMp3File(){Path = "Artist",Tags = new Mp3Tags(){Artist = "Artist",Title = "Title"}};
_fileWithBadTags = new TestMp3File() { Path = "Artist Title", Tags = new Mp3Tags() { Artist = "Artist", Title = "" } };
_fileWithBadTagsAndBadName = new TestMp3File() { Path = "Artist", Tags = new Mp3Tags() { Artist = "Artist", Title = "" } };
}
// Returns the new state
public static uint SetState(uint newValue, Mask mask)
{
uint state;
int error = _controlfp_s(out state, newValue, (uint)mask);
if (error == 0)
{
return state;
}
throw new Win32Exception(error);
}
public override void OptimizeMask(Mask mask)
{
List<string> passwords = new List<string>();
List<int> maskList = new List<int>();
string bestMaskString = null;
double bestMatchPercent = -1;
// initialize mask list to all 2s
for (int i = 0; i < this.TargetMaskLength; i++)
{
maskList.Add(2);
}
// set first and last to 1 and 4
maskList[0] = 1;
maskList[maskList.Count - 1] = 4;
this.toChange = maskList.Count - 2;
// have two 4's
//maskList[maskList.Count - 2] = 4;
//this.toChange = maskList.Count - 3;
// build a memory list of passwords because we hammer on it
using (StreamReader reader = new StreamReader(this.PasswordListFilename))
{
do
{
string password = reader.ReadLine();
if (string.IsNullOrEmpty(password))
{
continue;
}
passwords.Add(password);
} while (!reader.EndOfStream);
}
do
{
mask.MaskString = GetMaskString(maskList);
MaskAnalyzer ma = new MaskAnalyzer(mask);
MaskAnalyzerResults res = ma.AnalyzeMaskCoverage(passwords);
if (res.MatchedPercent > bestMatchPercent)
{
bestMatchPercent = res.MatchedPercent;
bestMaskString = mask.MaskString;
}
} while (IncrementList(maskList));
mask.MaskString = bestMaskString;
}
public SyncPlan BuildPlan(IEnumerable<string> paths,Mask mask)
{
Analyze(paths,mask);
PlanBuilder builder=new PlanBuilder(_tager,mask);
var plan=builder.Build(NotSynchronizedFiles.Keys);
foreach (var errorFile in builder.ErrorFiles)
{
ErrorFiles.Add(errorFile.Key,errorFile.Value);
}
return plan;
}
public override Mask GetMask()
{
// LOTS of possible null refs here
Mask ret = new Mask();
Dictionary<byte, int> charToCount = this.Analyzer.PositionToCharToCount[0];
List<KeyValuePair<byte, int>> sorted = charToCount.OrderByDescending(pair => pair.Value).ToList();
StringBuilder sb = new StringBuilder();
for (int i = 0; i < this.MaxCharsPerSet && i < sorted.Count; i++)
{
sb.Append(Convert.ToChar(sorted[i].Key));
}
ret.Charset1 = sb.ToString();
charToCount = this.Analyzer.PositionToCharToCount[(int)Math.Floor(this.TargetMaskLength / 2.0 * 0.5)];
sorted = charToCount.OrderByDescending(pair => pair.Value).ToList();
sb = new StringBuilder();
for (int i = 0; i < this.MaxCharsPerSet && i < sorted.Count; i++)
{
sb.Append(Convert.ToChar(sorted[i].Key));
}
ret.Charset2 = sb.ToString();
charToCount = this.Analyzer.PositionToCharToCount[(int)Math.Floor(this.TargetMaskLength / 2.0 * 1.5)];
sorted = charToCount.OrderByDescending(pair => pair.Value).ToList();
sb = new StringBuilder();
for (int i = 0; i < this.MaxCharsPerSet && i < sorted.Count; i++)
{
sb.Append(Convert.ToChar(sorted[i].Key));
}
ret.Charset3 = sb.ToString();
charToCount = this.Analyzer.PositionToCharToCount[this.TargetMaskLength - 1];
sorted = charToCount.OrderByDescending(pair => pair.Value).ToList();
sb = new StringBuilder();
for (int i = 0; i < this.MaxCharsPerSet && i < sorted.Count; i++)
{
sb.Append(Convert.ToChar(sorted[i].Key));
}
ret.Charset4 = sb.ToString();
return ret;
}
public override Mask GetMask()
{
// LOTS of possible null refs here
Mask ret = new Mask();
ret.Charset1 = GetTopCharset(0);
ret.Charset2 = GetTopCharsetWithNext(1);
ret.Charset3 = GetTopCharsetWithNext(this.TargetMaskLength / 2 + 1);
ret.Charset4 = GetTopCharsetWithNext(this.TargetMaskLength - 2);
return ret;
}
public void initMasks()
{
CascadeMask[0] = new Mask(300,200,4);
CascadeMask[0].drawSquare(100, 200, 0, 0, 1);
CascadeMask[0].drawSquare(100, 200, 100, 0, 2);
CascadeMask[0].drawSquare(100, 200, 200, 0, 3);
CascadeMask[0].calcPrimeSum(vectorToAr(480, 640));
this.textBox1.Text += "PrimeSum " + CascadeMask[0].PrimeZoneSum[1];
CascadeMask[1] = new Mask(300, 200, 4);
CascadeMask[1].drawSquare(300, 66, 0, 0, 1);
CascadeMask[1].drawSquare(300, 67, 0, 66, 2);
CascadeMask[1].drawSquare(300, 67, 0, 133, 3);
CascadeMask[1].calcPrimeSum(vectorToAr(480, 640));
//public void drawSquare( int mHeight, int mWidth, int hStart = 0, int wStart = 0, short zoneNumber = 0)
CascadeMask[2] = new Mask(300, 200, 7);
CascadeMask[2].drawSquare(100, 100, 0, 0, 1);
CascadeMask[2].drawSquare(100, 100, 100, 0, 2);
CascadeMask[2].drawSquare(100, 100, 200, 0, 3);
CascadeMask[2].drawSquare(100, 100, 0, 100, 6);
CascadeMask[2].drawSquare(100, 100, 100, 100, 4);
CascadeMask[2].drawSquare(100, 100, 200, 100, 5);
CascadeMask[2].calcPrimeSum(vectorToAr(480, 640));
int mH =240; //div by 3
int mW =160; //div by 2
// create mask with 12 zones
CascadeMask[3] = new Mask(mH, mW, 13);
CascadeMask[3].drawSquare(mH/3, mW/4, 0, 0, 3);
CascadeMask[3].drawSquare(mH / 3, mW / 4, mH/3, 0, 3);
CascadeMask[3].drawSquare(mH / 3, mW / 4, (mH / 3)*2, 0, 2);
CascadeMask[3].drawSquare(mH / 3, mW / 4, 0, mW/4, 1);
CascadeMask[3].drawSquare(mH / 3, mW / 4, mH / 3, mW / 4, 1);
CascadeMask[3].drawSquare(mH / 3, mW / 4, (mH / 3) * 2, mW / 4, 2);
CascadeMask[3].drawSquare(mH / 3, mW / 4, 0, mW / 2, 1);
CascadeMask[3].drawSquare(mH / 3, mW / 4, mH / 3, mW / 2, 1);
CascadeMask[3].drawSquare(mH / 3, mW / 4, (mH / 3) * 2, mW / 2, 2);
CascadeMask[3].drawSquare(mH / 3, mW / 4, 0, (mW / 4 )*3, 3);
CascadeMask[3].drawSquare(mH / 3, mW / 4, mH / 3, (mW / 4) * 3, 3);
CascadeMask[3].drawSquare(mH / 3, mW / 4, (mH / 3) * 2, (mW / 4) * 3, 2);
CascadeMask[3].calcPrimeSum(vectorToAr(480, 640));
this.textBox1.Text += "\n Mask Coords: x " + CascadeMask[3].xStart + " y" + CascadeMask[3].yStart ;
}
public void ChangeNameTest()
{
var expectedName = "[1]. Artist - Title 2015 live in Russia";
var mask = new Mask("[{track}]. {artist} - {title} {year} live in Russia");
_testTager.Load("oldfilename");
_testTager.ChangeTags(_tesTags);
_testTager.ChangeName(mask);
var currentFile = _testTager.CurrentFile as TestMp3File;
Assert.AreEqual(true, currentFile.ChangeNameFlag);
Assert.AreEqual(expectedName,currentFile.Name);
}
public override void Call()
{
if (IsCanceled)
{
synchronizer.Redo();
return;
}
var path = Menu.GetUserInput("path:"); //@"C:\Users\Alexandr\Desktop\TEST\New folder";
var tager = new Tager(new FileLoader());
var analyzer = new Analyzer(tager, s => Path.GetExtension(s).ToLower() == ".mp3");
Menu.PrintHelp();
var mask = new Mask(Menu.GetUserInput("mask:"));
analyzer.Analyze(Directory.GetFiles(path), mask);
synchronizer = new Synchronizer(tager);
foreach (var notSynchronizedFile in analyzer.NotSynchronizedFiles)
{
Console.Clear();
Menu.PrintMessage(notSynchronizedFile.Key.Name+" with "+notSynchronizedFile.Value);
synchronizer.Sync(notSynchronizedFile.Key,mask,Menu.SelectSyncRule());
Menu.PrintChanges(notSynchronizedFile.Key);
if (Menu.GetYesNoAnswer("Save changes?\nY/N:"))
{
try
{
synchronizer.SaveLast();
Menu.PrintMessage("Successfully");
Menu.GetUserInput("Press enter...");
}
catch
{
Menu.PrintError("Can't save file");
}
}
else
{
synchronizer.RestoreLast();
}
}
}
private Standart InitStandart(Bitmap bmp)
{
var idealStandart = new IdealStandart();
idealStandart.Matrix = new bool[bmp.Width, bmp.Height];
idealStandart.Height = bmp.Height;
idealStandart.Width = bmp.Width;
var mask = new Mask();
mask.Matrix = new bool[bmp.Width, bmp.Height];
mask.Height = bmp.Height;
mask.Width = bmp.Width;
var incedenceMatrix = new int[bmp.Height][];
unsafe
{
BitmapData bitmapData = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadWrite,
bmp.PixelFormat);
int bytesPerPixel = Image.GetPixelFormatSize(bmp.PixelFormat)/8;
int heightInPixels = bitmapData.Height;
int widthInBytes = bitmapData.Width*bytesPerPixel;
var ptrFirstPixel = (byte*) bitmapData.Scan0;
for (int y = 0; y < heightInPixels; y++)
{
var maskRow = new bool[bmp.Width];
var standartRow = new bool[bmp.Width];
byte* currentLine = ptrFirstPixel + (y*bitmapData.Stride);
for (int x = 0, cell = 0; x < widthInBytes; x = x + bytesPerPixel, cell++)
{
int blue = currentLine[x];
int green = currentLine[x + 1];
int red = currentLine[x + 2];
maskRow[cell] =
mask.Matrix[cell, y] = red > 0 && blue + green == 0 || green > 0 && blue + red == 0;
standartRow[cell] =
idealStandart.Matrix[cell, y] = red + green + blue == 0 || red > 0 && blue + green == 0;
}
incedenceMatrix[y] = IncedenceMatrixRowFill(maskRow, standartRow);
}
bmp.UnlockBits(bitmapData);
}
idealStandart.IncidenceMatrix = incedenceMatrix;
return new Standart(mask, idealStandart);
}
Mp3Tags GetTagsFromFileName(IMp3File file)
{
if (file == null)
throw new ArgumentException("File is not loaded");
Menu.PrintHelp();
var fileName = file.Name;
var mask = new Mask(Menu.GetUserInput("mask:"));
var tagValues = Select(mask.GetTagValuesFromString(fileName));
var result = new Mp3Tags();
foreach (var tagValue in tagValues)
{
result.SetTag(tagValue.Key, tagValue.Value);
}
return result;
}
public TextBoxMask(TextBox control, Mask mask)
{
switch(mask)
{
case Mask.Numeric:
control.TextChanged += Numeric;
break;
case Mask.IPv4Address:
control.TextChanged += IPv4Address;
break;
case Mask.IPv6Address:
control.TextChanged += IPv6Address;
break;
}
control.KeyPress += new KeyPressEventHandler((s, e) => { oldPosition = control.SelectionStart; });
control.MouseClick += new MouseEventHandler((s, e) => { oldPosition = control.SelectionStart; });
UpdatePosition(control);
}
public void Analyze(IEnumerable<string> paths,Mask mask)
{
foreach (var path in Filtrate(paths))
{
if (_tager.Load(path))
{
if (!_tager.ValidateFileName(mask))
{
NotSynchronizedFiles.Add(_tager.CurrentFile,GetFileInfo(mask));
}
else
{
SynchronizedFiles.Add(_tager.CurrentFile);
}
}
else
{
ErrorFiles.Add(path,"load error");
}
}
}
public override bool Call(Mask mask, Tager tager, IMp3File file)
{
if (_isCanceled)
{
RestoreFile();
return true;
}
_file = file;
try
{
_memento = _file.GetMemento();
tager.ChangeTags(tager.GetTagsFromName(mask));
return true;
}
catch
{
return false;
}
}
public bool ValidateFileName(Mask mask)
{
try
{
var posibleTagValuesFromName = mask.GetTagValuesFromString(_currentFile.Name);
var tagsFromFile = _currentFile.GetTags();
var fileNameIsOk = false;
foreach (var tagValues in posibleTagValuesFromName)
{
if (fileNameIsOk)
break;
foreach (var tagValue in tagValues)
{
var currentTagFromFile = tagsFromFile.GetTag(tagValue.Key);
if (tagValue.Value != currentTagFromFile)
{
if (tagValue.Key == "track" && tagValue.Value.StartsWith("0"))
{
if (tagValue.Value.Substring(1) == currentTagFromFile)
continue;
}
fileNameIsOk = false;
break;
}
fileNameIsOk = true;
}
}
return fileNameIsOk;
}
catch
{
return false;
}
}
public void GetTagValuesTest()
{
var testMask=new Mask("a{x}b{y}");
var testString = "aaaabbbb";
var posibleValues = new Dictionary<string, string>
{
{"aaa", "bbb"},
{"aaab", "bb"},
{"aaabb", "b"},
{"aaabbb", ""}
};
foreach (var posibleValue in posibleValues)
{
bool flag = false;
foreach (var result in testMask.GetTagValuesFromString(testString).Where(result => result.ContainsValue(posibleValue.Key)))
{
flag = result["x"] == posibleValue.Key && result["y"] == posibleValue.Value;
if (flag)
break;
}
Assert.AreEqual(true,flag);
}
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
base.Translate_InternalFill(obj, eval);
obj.ComparisonValue = eval(this.ComparisonValue);
obj.Data = this.Data == null ? null : new MaskItem <R, ConditionData.Mask <R>?>(eval(this.Data.Overall), this.Data.Specific?.Translate(eval));
}
private void Start()
{
items = new List <AntMenuItem>();
mask = GetComponent <Mask>();
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
base.Translate_InternalFill(obj, eval);
obj.Parent = eval(this.Parent);
obj.Coordinates = eval(this.Coordinates);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Flags = eval(this.Flags);
obj.FragmentIndex = eval(this.FragmentIndex);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
base.Translate_InternalFill(obj, eval);
obj.Type = eval(this.Type);
obj.Data = eval(this.Data);
}
public static GameObject CreateScrollView(Resources resources)
{
GameObject gameObject = CreateUIElementRoot("Scroll View", new Vector2(200f, 200f));
GameObject gameObject2 = CreateUIObject("Viewport", gameObject);
GameObject gameObject3 = CreateUIObject("Content", gameObject2);
GameObject gameObject4 = CreateScrollbar(resources);
gameObject4.name = "Scrollbar Horizontal";
SetParentAndAlign(gameObject4, gameObject);
RectTransform component = gameObject4.GetComponent <RectTransform>();
component.anchorMin = Vector2.zero;
component.anchorMax = Vector2.right;
component.pivot = Vector2.zero;
RectTransform rectTransform = component;
Vector2 sizeDelta = component.sizeDelta;
rectTransform.sizeDelta = new Vector2(0f, sizeDelta.y);
GameObject gameObject5 = CreateScrollbar(resources);
gameObject5.name = "Scrollbar Vertical";
SetParentAndAlign(gameObject5, gameObject);
gameObject5.GetComponent <Scrollbar>().SetDirection(Scrollbar.Direction.BottomToTop, includeRectLayouts: true);
RectTransform component2 = gameObject5.GetComponent <RectTransform>();
component2.anchorMin = Vector2.right;
component2.anchorMax = Vector2.one;
component2.pivot = Vector2.one;
RectTransform rectTransform2 = component2;
Vector2 sizeDelta2 = component2.sizeDelta;
rectTransform2.sizeDelta = new Vector2(sizeDelta2.x, 0f);
RectTransform component3 = gameObject2.GetComponent <RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.sizeDelta = Vector2.zero;
component3.pivot = Vector2.up;
RectTransform component4 = gameObject3.GetComponent <RectTransform>();
component4.anchorMin = Vector2.up;
component4.anchorMax = Vector2.one;
component4.sizeDelta = new Vector2(0f, 300f);
component4.pivot = Vector2.up;
ScrollRect scrollRect = gameObject.AddComponent <ScrollRect>();
scrollRect.content = component4;
scrollRect.viewport = component3;
scrollRect.horizontalScrollbar = gameObject4.GetComponent <Scrollbar>();
scrollRect.verticalScrollbar = gameObject5.GetComponent <Scrollbar>();
scrollRect.horizontalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.horizontalScrollbarSpacing = -3f;
scrollRect.verticalScrollbarSpacing = -3f;
Image image = gameObject.AddComponent <Image>();
image.sprite = resources.background;
image.type = Image.Type.Sliced;
image.color = s_PanelColor;
Mask mask = gameObject2.AddComponent <Mask>();
mask.showMaskGraphic = false;
Image image2 = gameObject2.AddComponent <Image>();
image2.sprite = resources.mask;
image2.type = Image.Type.Sliced;
return(gameObject);
}
public static ScrollRect CreateScrollView(GameObject parent = null, string name = "Scroll View", LayoutGroupType layoutGroupType = LayoutGroupType.Vertical)
{
Resources resources = GetStandardResources();
GameObject root = CreateUIElementRoot(name, new Vector2(200, 200));
SetParentAndAlign(root, parent);
root.layer = LayerMask.NameToLayer(kUILayerName);
GameObject viewport = CreateUIObject("Viewport", root);
GameObject content = CreateUIObject("Content", viewport);
// Sub controls.
GameObject hScrollbar = CreateScrollbar().gameObject;
hScrollbar.name = "Scrollbar Horizontal";
SetParentAndAlign(hScrollbar, root);
RectTransform hScrollbarRT = hScrollbar.GetComponent <RectTransform>();
hScrollbarRT.anchorMin = Vector2.zero;
hScrollbarRT.anchorMax = Vector2.right;
hScrollbarRT.pivot = Vector2.zero;
hScrollbarRT.sizeDelta = new Vector2(0, hScrollbarRT.sizeDelta.y);
GameObject vScrollbar = CreateScrollbar().gameObject;
vScrollbar.name = "Scrollbar Vertical";
SetParentAndAlign(vScrollbar, root);
vScrollbar.GetComponent <Scrollbar>().SetDirection(Scrollbar.Direction.BottomToTop, true);
RectTransform vScrollbarRT = vScrollbar.GetComponent <RectTransform>();
vScrollbarRT.anchorMin = Vector2.right;
vScrollbarRT.anchorMax = Vector2.one;
vScrollbarRT.pivot = Vector2.one;
vScrollbarRT.sizeDelta = new Vector2(vScrollbarRT.sizeDelta.x, 0);
// Setup RectTransforms.
// Make viewport fill entire scroll view.
RectTransform viewportRT = viewport.GetComponent <RectTransform>();
viewportRT.anchorMin = Vector2.zero;
viewportRT.anchorMax = Vector2.one;
viewportRT.sizeDelta = Vector2.zero;
viewportRT.pivot = Vector2.up;
// Make context match viewpoprt width and be somewhat taller.
// This will show the vertical scrollbar and not the horizontal one.
RectTransform contentRT = content.GetComponent <RectTransform>();
contentRT.anchorMin = Vector2.up;
contentRT.anchorMax = Vector2.one;
contentRT.sizeDelta = new Vector2(0, 300);
contentRT.pivot = Vector2.up;
// Setup UI components.
ScrollRect scrollRect = root.AddComponent <ScrollRect>();
scrollRect.content = contentRT;
scrollRect.viewport = viewportRT;
scrollRect.horizontalScrollbar = hScrollbar.GetComponent <Scrollbar>();
scrollRect.verticalScrollbar = vScrollbar.GetComponent <Scrollbar>();
scrollRect.horizontalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.horizontalScrollbarSpacing = -3;
scrollRect.verticalScrollbarSpacing = -3;
Image rootImage = root.AddComponent <Image>();
rootImage.sprite = resources.background;
rootImage.type = Image.Type.Sliced;
rootImage.color = s_PanelColor;
Mask viewportMask = viewport.AddComponent <Mask>();
viewportMask.showMaskGraphic = false;
Image viewportImage = viewport.AddComponent <Image>();
viewportImage.sprite = resources.mask;
viewportImage.type = Image.Type.Sliced;
switch (layoutGroupType)
{
case LayoutGroupType.Grid:
content.AddComponent <GridLayoutGroup>();
break;
case LayoutGroupType.Horizontal:
content.AddComponent <HorizontalLayoutGroup>();
break;
case LayoutGroupType.Vertical:
content.AddComponent <VerticalLayoutGroup>();
break;
}
return(scrollRect);
}
private long sendFragmented(
Opcode opcode, Stream stream, long length, Mask mask, bool compressed)
{
var quo = length / FragmentLength;
var rem = (int) (length % FragmentLength);
var count = rem == 0 ? quo - 2 : quo - 1;
long sentLen = 0;
int readLen = 0;
byte [] buffer = null;
// Not fragmented
if (quo == 0)
{
buffer = new byte [rem];
readLen = stream.Read (buffer, 0, rem);
if (readLen == rem &&
send (WsFrame.CreateFrame (Fin.FINAL, opcode, mask, buffer, compressed)))
sentLen = readLen;
return sentLen;
}
buffer = new byte [FragmentLength];
// First
readLen = stream.Read (buffer, 0, FragmentLength);
if (readLen == FragmentLength &&
send (WsFrame.CreateFrame (Fin.MORE, opcode, mask, buffer, compressed)))
sentLen = readLen;
else
return sentLen;
// Mid
for (long i = 0; i < count; i++)
{
readLen = stream.Read (buffer, 0, FragmentLength);
if (readLen == FragmentLength &&
send (WsFrame.CreateFrame (Fin.MORE, Opcode.CONT, mask, buffer, compressed)))
sentLen += readLen;
else
return sentLen;
}
// Final
var tmpLen = FragmentLength;
if (rem != 0)
buffer = new byte [tmpLen = rem];
readLen = stream.Read (buffer, 0, tmpLen);
if (readLen == tmpLen &&
send (WsFrame.CreateFrame (Fin.FINAL, Opcode.CONT, mask, buffer, compressed)))
sentLen += readLen;
return sentLen;
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.TriangleBeforeDoor = eval(this.TriangleBeforeDoor);
obj.Unknown = eval(this.Unknown);
obj.Door = eval(this.Door);
}
private bool sendFragmented(Opcode opcode, Stream stream, Mask mask, bool compressed)
{
var len = stream.Length;
var quo = len / FragmentLength;
var rem = (int) (len % FragmentLength);
var times = rem == 0 ? quo - 2 : quo - 1;
byte [] buffer = null;
// Not fragmented
if (quo == 0) {
buffer = new byte [rem];
return stream.Read (buffer, 0, rem) == rem &&
send (WsFrame.CreateFrame (Fin.Final, opcode, mask, buffer, compressed));
}
buffer = new byte [FragmentLength];
// First
if (stream.Read (buffer, 0, FragmentLength) != FragmentLength ||
!send (WsFrame.CreateFrame (Fin.More, opcode, mask, buffer, compressed)))
return false;
// Mid
for (long i = 0; i < times; i++) {
if (stream.Read (buffer, 0, FragmentLength) != FragmentLength ||
!send (WsFrame.CreateFrame (Fin.More, Opcode.Cont, mask, buffer, compressed)))
return false;
}
// Final
var tmpLen = FragmentLength;
if (rem != 0)
buffer = new byte [tmpLen = rem];
return stream.Read (buffer, 0, tmpLen) == tmpLen &&
send (WsFrame.CreateFrame (Fin.Final, Opcode.Cont, mask, buffer, compressed));
}
public void SetScaleTranslate(float sx, float sy, float tx, float ty)
{
scaleX = sx;
skewX = 0;
transX = tx;
skewY = 0;
scaleY = sy;
transY = ty;
persp0 = 0;
persp1 = 0;
persp2 = 1;
#if OPTIMIZED_SKMATRIX
typeMask = Mask.RectStaysRect |
((sx != 1 || sy != 1) ? Mask.Scale : 0) |
((tx != 0 || ty != 0) ? Mask.Translate : 0);
#endif
}
private void buttonStart_Click(object sender, EventArgs e)
{
try
{
Dictionary <MeasureData, double> _measures = new Dictionary <MeasureData, double>();
string err = "Должно быть выбрано ровно 2 измерения.\r\nПервое должно быть 'усреднённым' и содержать статистическую информацию [Σ+].";
foreach (object o in listBoxMeasures.Items)
{
if (multiGraph.Plotters.ContainsKey(o))
{
_measures.Add(o as MeasureData, (multiGraph.Plotters[o] as MovableGraph).Correcture);
}
}
Mask _mask = comboBoxMasks.SelectedItem as Mask;
if (_measures.Count < 2)
{
MessageBox.Show(err);
return;
}
double _maxlen = double.MaxValue;
foreach (MeasureData data in _measures.Keys)
{
_maxlen = Math.Min(_maxlen, data.FullMeasureLength);
}
if (_maxlen < 1d)
{
return;
}
if (_measures.Count != 2)
{
MessageBox.Show(err);
return;
}
else if ((listBoxMeasures.Items[0] as MeasureData).IsMeasured)
{
MessageBox.Show("Первое измерение не является 'усреднённым' [Σ].");
return;
}
else if ((listBoxMeasures.Items[0] as MeasureData).DispData == null)
{
MessageBox.Show("Первое измерение не содержит статистической информации [+].");
return;
}
else
{
MeasureData bm = listBoxMeasures.Items[0] as MeasureData;
MeasureData cm = listBoxMeasures.Items[1] as MeasureData;
double corr = (multiGraph.Plotters[cm] as MovableGraph).Correcture - (multiGraph.Plotters[bm] as MovableGraph).Correcture;
#region зачистка
foreach (Sensor s in cm.AllData.Keys)
{
if (!bm.Data.ContainsKey(s))
{
cm.Used[s] = false;
}
}
foreach (Sensor s in bm.AllData.Keys)
{
if (!cm.Data.ContainsKey(s))
{
bm.Used[s] = false;
}
}
#endregion Зачистка
Dictionary <string, object> objs = AlgsList.Correspondence(bm, cm, corr);
if ((bool)objs["ok"])
{
Dictionary <Sensor, List <double> > insigma = objs["sigma"] as Dictionary <Sensor, List <double> >;
Dictionary <Sensor, List <double> > in3sigma = objs["3sigma"] as Dictionary <Sensor, List <double> >;
Dictionary <Sensor, List <double> > outof3sigma = objs["unstable"] as Dictionary <Sensor, List <double> >;
int count, in1, in3, out3;
count = in1 = in3 = out3 = 0;
foreach (Sensor sensor in insigma.Keys)
{
foreach (double d in insigma[sensor])
{
count++;
in1++;
}
}
foreach (Sensor sensor in in3sigma.Keys)
{
foreach (double d in in3sigma[sensor])
{
count++;
in3++;
}
}
foreach (Sensor sensor in outof3sigma.Keys)
{
foreach (double d in outof3sigma[sensor])
{
count++;
out3++;
}
}
FormCompare report = new FormCompare();
report.RTB.SelectionFont = report.Bold.Font;
report.RTB.AppendText("Сводка по сравнению:\r\n");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(" Базовое измерение: " + bm.ToString() + "\r\n");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(" Сравниваемое измерение: " + cm.ToString() + "\r\n");
report.RTB.SelectionFont = report.Italic.Font;
report.RTB.AppendText(" Всего сравнивалось точек: ");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("" + count + " (" + ((100d / count) * count).ToString("0.00") + "%)\r\n");
report.RTB.SelectionColor = Color.Green;
report.RTB.SelectionFont = report.Italic.Font;
report.RTB.AppendText(" Попало в X±σ: ");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("" + in1 + " (" + ((100d / count) * in1).ToString("0.00") + "%)\r\n");
report.RTB.SelectionColor = Color.Orange;
report.RTB.SelectionFont = report.Italic.Font;
report.RTB.AppendText(" Попало в X±3σ: ");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("" + (in1 + in3) + " (" + ((100d / count) * (in3 + in1)).ToString("0.00") + "%)\r\n");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(" Значения точек в интервале\r\n (-3σ; -σ)U(σ; 3σ):\r\n");
foreach (Sensor s in in3sigma.Keys)
{
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(" " + s.ToString() + ": ");
foreach (double d in in3sigma[s])
{
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(d.ToString() + "; ");
}
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("\r\n");
}
report.RTB.SelectionColor = Color.Red;
report.RTB.SelectionFont = report.Italic.Font;
report.RTB.AppendText(" Не попало в X±3σ: ");
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("" + out3 + " (" + ((100d / count) * out3).ToString("0.00") + "%)\r\n");
foreach (Sensor s in outof3sigma.Keys)
{
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(" " + s.ToString() + ": ");
foreach (double d in outof3sigma[s])
{
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText(d.ToString() + "; ");
}
report.RTB.SelectionFont = report.Normal.Font;
report.RTB.AppendText("\r\n");
}
report.RTB.SelectionColor = Color.Black;
report.setValues(bm, _measures[bm], cm, _measures[cm], _mask);
report.Show();
}
else
{
MessageBox.Show("Ошибка сравнения: " + objs["errorlog"]);
}
}
}
catch (Exception ex) { MessageBox.Show("Ошибка:\r\n" + ex.Message); }
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.BranchCount = eval(this.BranchCount);
obj.Flags = eval(this.Flags);
}
public static ProcessResultArray <Clip> ProcessCommand(Command command, Clip[] incomingClips, ClipMetaData targetMetadata)
{
var clips = new Clip[incomingClips.Length];
for (var i = 0; i < incomingClips.Length; i++)
{
clips[i] = new Clip(incomingClips[i]);
}
ProcessResultArray <Clip> resultContainer;
switch (command.Id)
{
case TokenType.Arpeggiate:
resultContainer = Arpeggiate.Apply(command, clips);
break;
case TokenType.Concat:
resultContainer = Concat.Apply(clips);
break;
case TokenType.Crop:
resultContainer = Crop.Apply(command, clips);
break;
case TokenType.Filter:
resultContainer = Filter.Apply(command, clips);
break;
case TokenType.Interleave:
resultContainer = Interleave.Apply(command, targetMetadata, clips);
break;
case TokenType.InterleaveEvent:
var(success, msg) = OptionParser.TryParseOptions(command, out InterleaveOptions options);
if (!success)
{
return(new ProcessResultArray <Clip>(msg));
}
options.Mode = InterleaveMode.Event;
resultContainer = Interleave.Apply(options, targetMetadata, clips);
break;
case TokenType.Legato:
resultContainer = Legato.Apply(clips);
break;
case TokenType.Mask:
resultContainer = Mask.Apply(command, clips);
break;
case TokenType.Monophonize:
resultContainer = Monophonize.Apply(clips);
break;
case TokenType.Quantize:
resultContainer = Quantize.Apply(command, clips);
break;
case TokenType.Ratchet:
resultContainer = Ratchet.Apply(command, clips);
break;
case TokenType.Relength:
resultContainer = Relength.Apply(command, clips);
break;
case TokenType.Resize:
resultContainer = Resize.Apply(command, clips);
break;
case TokenType.Scale:
resultContainer = Scale.Apply(command, clips);
break;
case TokenType.Scan:
resultContainer = Scan.Apply(command, clips);
break;
case TokenType.SetLength:
resultContainer = SetLength.Apply(command, clips);
break;
case TokenType.SetRhythm:
resultContainer = SetRhythm.Apply(command, clips);
break;
case TokenType.Shuffle:
resultContainer = Shuffle.Apply(command, clips);
break;
case TokenType.Skip:
resultContainer = Skip.Apply(command, clips);
break;
case TokenType.Slice:
resultContainer = Slice.Apply(command, clips);
break;
case TokenType.Take:
resultContainer = Take.Apply(command, clips);
break;
case TokenType.Transpose:
resultContainer = Transpose.Apply(command, clips);
break;
default:
return(new ProcessResultArray <Clip>($"Unsupported command {command.Id}"));
}
return(resultContainer);
}
/// <summary>
/// Статистически надёжное среднее
/// </summary>
/// <param name="measuresCorrecture">измерения с корректировкой времени</param>
/// <param name="mask">маска</param>
/// <param name="length">продолжительность</param>
/// <returns>среднее, просеенное через Q-критерий, и снабженное информацией о доверительных интервалах</returns>
public static MeasureData reliableMiddle(Dictionary <MeasureData, double> measuresCorrecture, string measureName, Mask mask, double length)
{
Dictionary <Sensor, Dictionary <double, List <double> > > data = new Dictionary <Sensor, Dictionary <double, List <double> > >();
Dictionary <Sensor, Dictionary <double, Dictionary <double, double> > > dispdata = new Dictionary <Sensor, Dictionary <double, Dictionary <double, double> > >();
Dictionary <Sensor, int> dividers = new Dictionary <Sensor, int>();
Dictionary <MeasureData, Dictionary <Sensor, double> > inits = new Dictionary <MeasureData, Dictionary <Sensor, double> >();
Dictionary <Sensor, double> starts = new Dictionary <Sensor, double>();
#region В _starts поместили средний старт и инициализировали data
foreach (MeasureData md in measuresCorrecture.Keys)
{
inits.Add(md, md.StartValues);
}
foreach (MeasureData md in measuresCorrecture.Keys)
{
Dictionary <Sensor, double> sv = md.StartValues;
foreach (Sensor s in md.AllData.Keys)
{
if (!data.ContainsKey(s))
{
data.Add(s, new Dictionary <double, List <double> >());
}
if (!dispdata.ContainsKey(s))
{
dispdata.Add(s, new Dictionary <double, Dictionary <double, double> >());
}
if (!dividers.ContainsKey(s))
{
dividers.Add(s, 1);
}
else
{
dividers[s] = dividers[s] + 1;
}
if (!starts.ContainsKey(s))
{
starts.Add(s, sv[s]);
}
else
{
starts[s] = starts[s] + sv[s];
}
}
}
Dictionary <Sensor, double> _starts = new Dictionary <Sensor, double>();
foreach (Sensor s in starts.Keys)
{
_starts.Add(s, starts[s] / dividers[s]);
}
#endregion
#region Собрали тики в ticks
List <double> ticks = new List <double>();
foreach (double tick in mask.TimePoints)
{
if (tick <= length)
{
ticks.Add(tick);
}
}
#endregion
#region Складываем по маске точки
foreach (double tick in ticks)
{
foreach (MeasureData md in measuresCorrecture.Keys)
{
Dictionary <Sensor, double> vals = md.GetDataAtTheMoment(md.StartTime.AddSeconds(tick - measuresCorrecture[md]));
foreach (Sensor sensor in vals.Keys)
{
if (!data[sensor].ContainsKey(tick))
{
data[sensor].Add(tick, new List <double>());
}
if (!dispdata[sensor].ContainsKey(tick))
{
dispdata[sensor].Add(tick, new Dictionary <double, double>());
}
data[sensor][tick].Add(_starts[sensor] - vals[sensor]);
}
}
}
#endregion
#region Статистика к бою
foreach (Sensor sensor in dispdata.Keys)
{
//dispdata.Add(sensor, new Dictionary<double,Dictionary<double,double>>());
foreach (double tick in dispdata[sensor].Keys)
{
// dispdata[sensor].Add(tick, new Dictionary<double,double>());
List <double> select = Q_095(data[sensor][tick]);
dispdata[sensor][tick].Add(mean(select), dX(select));
}
}
#endregion
#region Пересбор данных
Dictionary <Sensor, List <PointD> > newdata = new Dictionary <Sensor, List <PointD> >();
Dictionary <Sensor, Dictionary <double, double> > newdispdata = new Dictionary <Sensor, Dictionary <double, double> >();
foreach (Sensor s in dispdata.Keys)
{
newdata.Add(s, new List <PointD>());
newdispdata.Add(s, new Dictionary <double, double>());
newdata[s].Add(new PointD(-1, _starts[s]));
foreach (double d in dispdata[s].Keys)
{
Dictionary <double, double> pair = dispdata[s][d];
double k = 0;
foreach (double q in pair.Keys)
{
k = q;
}
newdata[s].Add(new PointD(d, _starts[s] - k));
newdispdata[s].Add(d, pair[k]);
}
}
#endregion
MeasureData mdata = new MeasureData(newdata, -1, measureName, DateTime.Now, "", -1, length, 1, false, mask, "-1", "-1");
mdata.DispData = newdispdata;
return(mdata);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Min = eval(this.Min);
obj.Max = eval(this.Max);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.PartType = eval(this.PartType);
obj.FileName = eval(this.FileName);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
base.Translate_InternalFill(obj, eval);
}
public static GameObject CreateDropdown(Resources resources)
{
GameObject gameObject = CreateUIElementRoot("Dropdown", s_ThickElementSize);
GameObject gameObject2 = CreateUIObject("Label", gameObject);
GameObject gameObject3 = CreateUIObject("Arrow", gameObject);
GameObject gameObject4 = CreateUIObject("Template", gameObject);
GameObject gameObject5 = CreateUIObject("Viewport", gameObject4);
GameObject gameObject6 = CreateUIObject("Content", gameObject5);
GameObject gameObject7 = CreateUIObject("Item", gameObject6);
GameObject gameObject8 = CreateUIObject("Item Background", gameObject7);
GameObject gameObject9 = CreateUIObject("Item Checkmark", gameObject7);
GameObject gameObject10 = CreateUIObject("Item Label", gameObject7);
GameObject gameObject11 = CreateScrollbar(resources);
gameObject11.name = "Scrollbar";
SetParentAndAlign(gameObject11, gameObject4);
Scrollbar component = gameObject11.GetComponent <Scrollbar>();
component.SetDirection(Scrollbar.Direction.BottomToTop, includeRectLayouts: true);
RectTransform component2 = gameObject11.GetComponent <RectTransform>();
component2.anchorMin = Vector2.right;
component2.anchorMax = Vector2.one;
component2.pivot = Vector2.one;
RectTransform rectTransform = component2;
Vector2 sizeDelta = component2.sizeDelta;
rectTransform.sizeDelta = new Vector2(sizeDelta.x, 0f);
Text text = gameObject10.AddComponent <Text>();
SetDefaultTextValues(text);
text.alignment = TextAnchor.MiddleLeft;
Image image = gameObject8.AddComponent <Image>();
image.color = new Color32(245, 245, 245, byte.MaxValue);
Image image2 = gameObject9.AddComponent <Image>();
image2.sprite = resources.checkmark;
Toggle toggle = gameObject7.AddComponent <Toggle>();
toggle.targetGraphic = image;
toggle.graphic = image2;
toggle.isOn = true;
Image image3 = gameObject4.AddComponent <Image>();
image3.sprite = resources.standard;
image3.type = Image.Type.Sliced;
ScrollRect scrollRect = gameObject4.AddComponent <ScrollRect>();
scrollRect.content = (RectTransform)gameObject6.transform;
scrollRect.viewport = (RectTransform)gameObject5.transform;
scrollRect.horizontal = false;
scrollRect.movementType = ScrollRect.MovementType.Clamped;
scrollRect.verticalScrollbar = component;
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.verticalScrollbarSpacing = -3f;
Mask mask = gameObject5.AddComponent <Mask>();
mask.showMaskGraphic = false;
Image image4 = gameObject5.AddComponent <Image>();
image4.sprite = resources.mask;
image4.type = Image.Type.Sliced;
Text text2 = gameObject2.AddComponent <Text>();
SetDefaultTextValues(text2);
text2.text = "Option A";
text2.alignment = TextAnchor.MiddleLeft;
Image image5 = gameObject3.AddComponent <Image>();
image5.sprite = resources.dropdown;
Image image6 = gameObject.AddComponent <Image>();
image6.sprite = resources.standard;
image6.color = s_DefaultSelectableColor;
image6.type = Image.Type.Sliced;
Dropdown dropdown = gameObject.AddComponent <Dropdown>();
dropdown.targetGraphic = image6;
SetDefaultColorTransitionValues(dropdown);
dropdown.template = gameObject4.GetComponent <RectTransform>();
dropdown.captionText = text2;
dropdown.itemText = text;
text.text = "Option A";
dropdown.options.Add(new Dropdown.OptionData
{
text = "Option A"
});
dropdown.options.Add(new Dropdown.OptionData
{
text = "Option B"
});
dropdown.options.Add(new Dropdown.OptionData
{
text = "Option C"
});
RectTransform component3 = gameObject2.GetComponent <RectTransform>();
component3.anchorMin = Vector2.zero;
component3.anchorMax = Vector2.one;
component3.offsetMin = new Vector2(10f, 6f);
component3.offsetMax = new Vector2(-25f, -7f);
RectTransform component4 = gameObject3.GetComponent <RectTransform>();
component4.anchorMin = new Vector2(1f, 0.5f);
component4.anchorMax = new Vector2(1f, 0.5f);
component4.sizeDelta = new Vector2(20f, 20f);
component4.anchoredPosition = new Vector2(-15f, 0f);
RectTransform component5 = gameObject4.GetComponent <RectTransform>();
component5.anchorMin = new Vector2(0f, 0f);
component5.anchorMax = new Vector2(1f, 0f);
component5.pivot = new Vector2(0.5f, 1f);
component5.anchoredPosition = new Vector2(0f, 2f);
component5.sizeDelta = new Vector2(0f, 150f);
RectTransform component6 = gameObject5.GetComponent <RectTransform>();
component6.anchorMin = new Vector2(0f, 0f);
component6.anchorMax = new Vector2(1f, 1f);
component6.sizeDelta = new Vector2(-18f, 0f);
component6.pivot = new Vector2(0f, 1f);
RectTransform component7 = gameObject6.GetComponent <RectTransform>();
component7.anchorMin = new Vector2(0f, 1f);
component7.anchorMax = new Vector2(1f, 1f);
component7.pivot = new Vector2(0.5f, 1f);
component7.anchoredPosition = new Vector2(0f, 0f);
component7.sizeDelta = new Vector2(0f, 28f);
RectTransform component8 = gameObject7.GetComponent <RectTransform>();
component8.anchorMin = new Vector2(0f, 0.5f);
component8.anchorMax = new Vector2(1f, 0.5f);
component8.sizeDelta = new Vector2(0f, 20f);
RectTransform component9 = gameObject8.GetComponent <RectTransform>();
component9.anchorMin = Vector2.zero;
component9.anchorMax = Vector2.one;
component9.sizeDelta = Vector2.zero;
RectTransform component10 = gameObject9.GetComponent <RectTransform>();
component10.anchorMin = new Vector2(0f, 0.5f);
component10.anchorMax = new Vector2(0f, 0.5f);
component10.sizeDelta = new Vector2(20f, 20f);
component10.anchoredPosition = new Vector2(10f, 0f);
RectTransform component11 = gameObject10.GetComponent <RectTransform>();
component11.anchorMin = Vector2.zero;
component11.anchorMax = Vector2.one;
component11.offsetMin = new Vector2(20f, 1f);
component11.offsetMax = new Vector2(-10f, -2f);
gameObject4.SetActive(value: false);
return(gameObject);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Skill = eval(this.Skill);
obj.Boost = eval(this.Boost);
}
public static Dropdown CreateDropdown(GameObject parent = null, string name = "Dropdown", string defaultLabel = "Option A")
{
Resources resources = GetStandardResources();
GameObject root = CreateUIElementRoot(name, s_ThickElementSize);
SetParentAndAlign(root, parent);
root.layer = LayerMask.NameToLayer(kUILayerName);
GameObject label = CreateUIObject("Label", root);
GameObject arrow = CreateUIObject("Arrow", root);
GameObject template = CreateUIObject("Template", root);
GameObject viewport = CreateUIObject("Viewport", template);
GameObject content = CreateUIObject("Content", viewport);
GameObject item = CreateUIObject("Item", content);
GameObject itemBackground = CreateUIObject("Item Background", item);
GameObject itemCheckmark = CreateUIObject("Item Checkmark", item);
GameObject itemLabel = CreateUIObject("Item Label", item);
// Sub controls.
GameObject scrollbar = CreateScrollbar().gameObject;
scrollbar.name = "Scrollbar";
SetParentAndAlign(scrollbar, template);
Scrollbar scrollbarScrollbar = scrollbar.GetComponent <Scrollbar>();
scrollbarScrollbar.SetDirection(Scrollbar.Direction.BottomToTop, true);
RectTransform vScrollbarRT = scrollbar.GetComponent <RectTransform>();
vScrollbarRT.anchorMin = Vector2.right;
vScrollbarRT.anchorMax = Vector2.one;
vScrollbarRT.pivot = Vector2.one;
vScrollbarRT.sizeDelta = new Vector2(vScrollbarRT.sizeDelta.x, 0);
// Setup item UI components.
Text itemLabelText = itemLabel.AddComponent <Text>();
SetDefaultTextValues(itemLabelText);
itemLabelText.font = resources.font;
itemLabelText.alignment = TextAnchor.MiddleLeft;
Image itemBackgroundImage = itemBackground.AddComponent <Image>();
itemBackgroundImage.color = new Color32(245, 245, 245, 255);
Image itemCheckmarkImage = itemCheckmark.AddComponent <Image>();
itemCheckmarkImage.sprite = resources.checkmark;
Toggle itemToggle = item.AddComponent <Toggle>();
itemToggle.targetGraphic = itemBackgroundImage;
itemToggle.graphic = itemCheckmarkImage;
itemToggle.isOn = true;
// Setup template UI components.
Image templateImage = template.AddComponent <Image>();
templateImage.sprite = resources.standard;
templateImage.type = Image.Type.Sliced;
ScrollRect templateScrollRect = template.AddComponent <ScrollRect>();
templateScrollRect.content = (RectTransform)content.transform;
templateScrollRect.viewport = (RectTransform)viewport.transform;
templateScrollRect.horizontal = false;
templateScrollRect.movementType = ScrollRect.MovementType.Clamped;
templateScrollRect.verticalScrollbar = scrollbarScrollbar;
templateScrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
templateScrollRect.verticalScrollbarSpacing = -3;
Mask scrollRectMask = viewport.AddComponent <Mask>();
scrollRectMask.showMaskGraphic = false;
Image viewportImage = viewport.AddComponent <Image>();
viewportImage.sprite = resources.mask;
viewportImage.type = Image.Type.Sliced;
// Setup dropdown UI components.
Text labelText = label.AddComponent <Text>();
SetDefaultTextValues(labelText);
labelText.font = resources.font;
labelText.alignment = TextAnchor.MiddleLeft;
Image arrowImage = arrow.AddComponent <Image>();
arrowImage.sprite = resources.dropdown;
Image backgroundImage = root.AddComponent <Image>();
backgroundImage.sprite = resources.standard;
backgroundImage.color = s_DefaultSelectableColor;
backgroundImage.type = Image.Type.Sliced;
Dropdown dropdown = root.AddComponent <Dropdown>();
dropdown.targetGraphic = backgroundImage;
SetDefaultColorTransitionValues(dropdown);
dropdown.template = template.GetComponent <RectTransform>();
dropdown.captionText = labelText;
dropdown.itemText = itemLabelText;
// Setting default Item list.
labelText.text = defaultLabel;
dropdown.options.Add(new Dropdown.OptionData {
text = "Option A"
});
dropdown.options.Add(new Dropdown.OptionData {
text = "Option B"
});
dropdown.options.Add(new Dropdown.OptionData {
text = "Option C"
});
// Set up RectTransforms.
RectTransform labelRT = label.GetComponent <RectTransform>();
labelRT.anchorMin = Vector2.zero;
labelRT.anchorMax = Vector2.one;
labelRT.offsetMin = new Vector2(10, 6);
labelRT.offsetMax = new Vector2(-25, -7);
RectTransform arrowRT = arrow.GetComponent <RectTransform>();
arrowRT.anchorMin = new Vector2(1, 0.5f);
arrowRT.anchorMax = new Vector2(1, 0.5f);
arrowRT.sizeDelta = new Vector2(20, 20);
arrowRT.anchoredPosition = new Vector2(-15, 0);
RectTransform templateRT = template.GetComponent <RectTransform>();
templateRT.anchorMin = new Vector2(0, 0);
templateRT.anchorMax = new Vector2(1, 0);
templateRT.pivot = new Vector2(0.5f, 1);
templateRT.anchoredPosition = new Vector2(0, 2);
templateRT.sizeDelta = new Vector2(0, 150);
RectTransform viewportRT = viewport.GetComponent <RectTransform>();
viewportRT.anchorMin = new Vector2(0, 0);
viewportRT.anchorMax = new Vector2(1, 1);
viewportRT.sizeDelta = new Vector2(-18, 0);
viewportRT.pivot = new Vector2(0, 1);
RectTransform contentRT = content.GetComponent <RectTransform>();
contentRT.anchorMin = new Vector2(0f, 1);
contentRT.anchorMax = new Vector2(1f, 1);
contentRT.pivot = new Vector2(0.5f, 1);
contentRT.anchoredPosition = new Vector2(0, 0);
contentRT.sizeDelta = new Vector2(0, 28);
RectTransform itemRT = item.GetComponent <RectTransform>();
itemRT.anchorMin = new Vector2(0, 0.5f);
itemRT.anchorMax = new Vector2(1, 0.5f);
itemRT.sizeDelta = new Vector2(0, 20);
RectTransform itemBackgroundRT = itemBackground.GetComponent <RectTransform>();
itemBackgroundRT.anchorMin = Vector2.zero;
itemBackgroundRT.anchorMax = Vector2.one;
itemBackgroundRT.sizeDelta = Vector2.zero;
RectTransform itemCheckmarkRT = itemCheckmark.GetComponent <RectTransform>();
itemCheckmarkRT.anchorMin = new Vector2(0, 0.5f);
itemCheckmarkRT.anchorMax = new Vector2(0, 0.5f);
itemCheckmarkRT.sizeDelta = new Vector2(20, 20);
itemCheckmarkRT.anchoredPosition = new Vector2(10, 0);
RectTransform itemLabelRT = itemLabel.GetComponent <RectTransform>();
itemLabelRT.anchorMin = Vector2.zero;
itemLabelRT.anchorMax = Vector2.one;
itemLabelRT.offsetMin = new Vector2(20, 1);
itemLabelRT.offsetMax = new Vector2(-10, -2);
template.SetActive(false);
return(dropdown);
}
/// <summary>
/// Get whether the current access mask is granted all specific permissions.
/// </summary>
/// <param name="mask">The access mask to check</param>
/// <returns>True access all is granted.</returns>
public bool IsAllAccessGranted(AccessMask mask)
{
return(Mask.IsAllAccessGranted(mask));
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Name = eval(this.Name);
obj.NewTexture = eval(this.NewTexture);
obj.Index = eval(this.Index);
}
/// <summary>
/// Get hash code.
/// </summary>
/// <returns>The hash code</returns>
public override int GetHashCode()
{
return(Type.GetHashCode() ^ Flags.GetHashCode() ^ Mask.GetHashCode()
^ Sid.GetHashCode() ^ ObjectType.GetHashCode() ^ InheritedObjectType.GetHashCode()
^ ServerSid?.GetHashCode() ?? 0 ^ NtObjectUtils.GetHashCodeByteArray(ApplicationData));
}
public MaskedColoredGrid(Mask mask) : base(mask.Rows, mask.Columns)
{
Mask = mask;
Mask.UnlinkMaskedCells(Mask, Cells.Cast <CartesianCell>());
}
protected static void InternalAddScrollView <T>(MenuCommand menuCommand) where T : ScrollView
{
GameObject root = CreateUIElementRoot(typeof(T).Name, new Vector2(200, 200));
GameObject viewport = CreateUIObject("Viewport", root);
GameObject content = CreateUIObject("Content", viewport);
GameObject parent = menuCommand.context as GameObject;
if (parent != null)
{
root.transform.SetParent(parent.transform, false);
}
Selection.activeGameObject = root;
GameObject hScrollbar = CreateScrollbar();
hScrollbar.name = "Scrollbar Horizontal";
hScrollbar.transform.SetParent(root.transform, false);
RectTransform hScrollbarRT = hScrollbar.GetComponent <RectTransform>();
hScrollbarRT.anchorMin = Vector2.zero;
hScrollbarRT.anchorMax = Vector2.right;
hScrollbarRT.pivot = Vector2.zero;
hScrollbarRT.sizeDelta = new Vector2(0, hScrollbarRT.sizeDelta.y);
GameObject vScrollbar = CreateScrollbar();
vScrollbar.name = "Scrollbar Vertical";
vScrollbar.transform.SetParent(root.transform, false);
vScrollbar.GetComponent <Scrollbar>().SetDirection(Scrollbar.Direction.BottomToTop, true);
RectTransform vScrollbarRT = vScrollbar.GetComponent <RectTransform>();
vScrollbarRT.anchorMin = Vector2.right;
vScrollbarRT.anchorMax = Vector2.one;
vScrollbarRT.pivot = Vector2.one;
vScrollbarRT.sizeDelta = new Vector2(vScrollbarRT.sizeDelta.x, 0);
RectTransform viewportRect = viewport.GetComponent <RectTransform>();
viewportRect.anchorMin = Vector2.zero;
viewportRect.anchorMax = Vector2.one;
viewportRect.sizeDelta = Vector2.zero;
viewportRect.pivot = Vector2.up;
RectTransform contentRect = content.GetComponent <RectTransform>();
contentRect.anchorMin = Vector2.up;
contentRect.anchorMax = Vector2.one;
contentRect.sizeDelta = new Vector2(0, 300);
contentRect.pivot = Vector2.up;
ScrollView scrollRect = root.AddComponent <T>();
scrollRect.content = contentRect;
scrollRect.viewport = viewportRect;
scrollRect.horizontalScrollbar = hScrollbar.GetComponent <Scrollbar>();
scrollRect.verticalScrollbar = vScrollbar.GetComponent <Scrollbar>();
scrollRect.horizontalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.verticalScrollbarVisibility = ScrollRect.ScrollbarVisibility.AutoHideAndExpandViewport;
scrollRect.horizontalScrollbarSpacing = -3;
scrollRect.verticalScrollbarSpacing = -3;
Image rootImage = root.AddComponent <Image>();
rootImage.sprite = AssetDatabase.GetBuiltinExtraResource <Sprite>(bgPath);
rootImage.type = Image.Type.Sliced;
rootImage.color = panelColor;
Mask viewportMask = viewport.AddComponent <Mask>();
viewportMask.showMaskGraphic = false;
Image viewportImage = viewport.AddComponent <Image>();
viewportImage.sprite = AssetDatabase.GetBuiltinExtraResource <Sprite>(maskPath);
viewportImage.type = Image.Type.Sliced;
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Priority = eval(this.Priority);
obj.DuckingDecibel = eval(this.DuckingDecibel);
}
/// <summary>
/// Refreshes the underlying bitmap using changes array, and applying given mask shape.
/// </summary>
/// <param name="mask"></param>
public void RefreshBitmap(Mask mask = Mask.Rectangle)
{
if (mask == Mask.Disabled)
{
//mask is disabled, therefore the whole image will be repainted
Int32Rect maskingRect = new Int32Rect(0, 0, width, height);
WriteToPixelBytes();
int delta = width * bytesPerPixel;
bitmap.Lock();
bitmap.WritePixels(maskingRect, pixelBytes, delta, 0);
bitmap.Unlock();
}
else if (anythingChanged)
{
if (mask == Mask.Rectangle)
{
int xSize = xMaxChanged - xMinChanged + 1, ySize = yMaxChanged - yMinChanged + 1;
int delta = xSize * bytesPerPixel - 3;
Int32Rect maskingRect = new Int32Rect(xMinChanged, yMinChanged, xSize, ySize);
byte[] pixelsRect = new byte[xSize * ySize * bytesPerPixel];
int index;
for (int x = 0; x < xSize; x++)
{
int xx = xMinChanged + x;
index = x * bytesPerPixel;
for (int y = 0; y < ySize; y++)
{
int yy = yMinChanged + y;
pixelsRect[index++] = (byte)(MaxByteValue * B[xx][yy]);
pixelsRect[index++] = (byte)(MaxByteValue * G[xx][yy]);
pixelsRect[index++] = (byte)(MaxByteValue * R[xx][yy]);
pixelsRect[index] = (byte)(MaxByteValue * A[xx][yy]);
index += delta;
changed[xx][yy] = false;
}
}
bitmap.Lock();
bitmap.WritePixels(maskingRect, pixelsRect, delta + 3, 0);
bitmap.Unlock();
}
else if (mask == Mask.PerPixel)
{
Int32Rect maskingRect = new Int32Rect(0, 0, 1, 1);
bitmap.Lock();
byte[] pixel = new byte[bytesPerPixel];
for (int y = yMinChanged; y <= yMaxChanged; y++)
{
for (int x = xMinChanged; x <= xMaxChanged; x++)
{
if (!changed[x][y])
{
continue;
}
maskingRect.X = x;
maskingRect.Y = y;
pixel[2] = (byte)(MaxByteValue * R[x][y]);
pixel[1] = (byte)(MaxByteValue * G[x][y]);
pixel[0] = (byte)(MaxByteValue * B[x][y]);
pixel[3] = (byte)(MaxByteValue * A[x][y]);
bitmap.WritePixels(maskingRect, pixel, bytesPerPixel, 0);
changed[x][y] = false;
}
}
bitmap.Unlock();
}
else if (mask == Mask.Circle)
{
throw new NotImplementedException("circle-shaped mask for FastBitmapArray is not implemented");
}
xMinChanged = width - 1;
xMaxChanged = 0;
yMinChanged = height - 1;
yMaxChanged = 0;
anythingChanged = false;
}
}
private void SetBits(Offset offset, Mask mask, bool value)
{
SetBits(offset, mask, (value ? 1 : 0));
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.AliasIndex = eval(this.AliasIndex);
obj.Type = eval(this.Type);
}
public Layer(BinaryReverseReader reader, PsdFile psdFile)
{
Debug.WriteLine("Layer started at " + reader.BaseStream.Position.ToString());
m_psdFile = psdFile;
m_rect = new Rectangle();
m_rect.Y = reader.ReadInt32();
m_rect.X = reader.ReadInt32();
m_rect.Height = reader.ReadInt32() - m_rect.Y;
m_rect.Width = reader.ReadInt32() - m_rect.X;
//-----------------------------------------------------------------------
int numberOfChannels = reader.ReadUInt16();
this.m_channels.Clear();
for (int channel = 0; channel < numberOfChannels; channel++)
{
Channel ch = new Channel(reader, this);
m_channels.Add(ch);
m_sortedChannels.Add(ch.ID, ch);
}
//-----------------------------------------------------------------------
string signature = new string(reader.ReadChars(4));
if (signature != "8BIM")
throw (new IOException("Layer Channelheader error!"));
m_blendModeKey = new string(reader.ReadChars(4));
m_opacity = reader.ReadByte();
m_clipping = reader.ReadByte() > 0;
//-----------------------------------------------------------------------
byte flags = reader.ReadByte();
m_flags = new BitVector32(flags);
//-----------------------------------------------------------------------
reader.ReadByte(); //padding
//-----------------------------------------------------------------------
Debug.WriteLine("Layer extraDataSize started at " + reader.BaseStream.Position.ToString());
// this is the total size of the MaskData, the BlendingRangesData, the
// Name and the AdjustmenLayerInfo
uint extraDataSize = reader.ReadUInt32();
// remember the start position for calculation of the
// AdjustmenLayerInfo size
long extraDataStartPosition = reader.BaseStream.Position;
m_maskData = new Mask(reader, this);
m_blendingRangesData = new BlendingRanges(reader, this);
//-----------------------------------------------------------------------
long namePosition = reader.BaseStream.Position;
m_name = reader.ReadPascalString();
int paddingBytes = (int)((reader.BaseStream.Position - namePosition) % 4);
Debug.Print("Layer {0} padding bytes after name", paddingBytes);
reader.ReadBytes(paddingBytes);
//-----------------------------------------------------------------------
m_adjustmentInfo.Clear();
long adjustmenLayerEndPos = extraDataStartPosition + extraDataSize;
while (reader.BaseStream.Position < adjustmenLayerEndPos)
{
try
{
m_adjustmentInfo.Add(new AdjusmentLayerInfo(reader, this));
}
catch
{
reader.BaseStream.Position = adjustmenLayerEndPos;
}
}
//-----------------------------------------------------------------------
// make shure we are not on a wrong offset, so set the stream position
// manually
reader.BaseStream.Position = adjustmenLayerEndPos;
}
/// <summary>
/// Get hash code.
/// </summary>
/// <returns>The hash code</returns>
public override int GetHashCode()
{
return(Type.GetHashCode() ^ Flags.GetHashCode() ^ Mask.GetHashCode() ^ Sid.GetHashCode() ^ ObjectType.GetHashCode() ^ InheritedObjectType.GetHashCode());
}
Mask GetMask ()
{
if (typeMask.HasFlag (Mask.Unknown))
typeMask = (Mask) SkiaApi.sk_matrix_get_type (ref this);
// only return the public masks
return (Mask) ((uint)typeMask & 0xf);
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Value = eval(this.Value);
obj.Weight = eval(this.Weight);
}
private bool sendFragmented(Opcode opcode, Stream stream, Mask mask, bool compressed)
{
var len = stream.Length;
if (sendFragmented (opcode, stream, len, mask, compressed) == len)
return true;
var msg = "Sending fragmented data is interrupted.";
_logger.Error (msg);
error (msg);
close (CloseStatusCode.ABNORMAL, msg, false);
return false;
}
public static JsonToken String(string text)
{
return(new JsonToken(JsonTokenClass.String, Mask.NullString(text)));
}
public void SetFormat(IntPtr model, Setting setting, Mask mask)
{
if (_setFormat == null) {
throw new Exception("Failed in loading IfcEngine.");
}
_setFormat.Invoke(model, new IntPtr((int)setting), new IntPtr((int)mask));
}
protected void Translate_InternalFill <R>(Mask <R> obj, Func <TItem, R> eval)
{
obj.Unknown0 = eval(this.Unknown0);
obj.Unknown1 = eval(this.Unknown1);
obj.Unknown2 = eval(this.Unknown2);
}
