public void SerializationElementListTest()
{
ElementList object1 = new ElementList(true);
Shape shape1 = new Shape();
Shape shape2 = new Shape();
shape1.Location = new PointF(10, 10);
shape2.Location = new PointF(20, 20);
object1.Add(shape1);
object1.Add(shape2);
//Serialize the object
MemoryStream stream = new MemoryStream();
XmlFormatter serializer = new XmlFormatter();
serializer.Serialize(stream, object1);
stream.Position = 0; // reset the stream to the beginning
SqlXml xml = new SqlXml(stream);
//Recreate the object in object 2
ElementList object2;
using (MemoryStream stream2 = new MemoryStream(Encoding.UTF8.GetBytes(xml.Value)))
{
object2 = (ElementList)serializer.Deserialize(stream2);
}
Shape shape3 = object2[0] as Shape;
Shape shape4 = object2[1] as Shape;
Assert.IsTrue(object2.Count == 2, "ElementList collection does not contain 2 items.");
Assert.IsTrue(shape3.Location == new PointF(10, 10), "Collection item 'shape1' location not deserialized correctly.");
Assert.IsTrue(shape4.Location == new PointF(20, 20), "Collection item 'shape2' location not deserialized correctly.");
}
public GameOver(Player player)
{
Button done = new Button("DONE", () => Program.Manager.NextState = new MainMenu(), 50, 200);
done.Anchor = new Vec2(0.6, 0.2);
AddExpandElement(done);
Label Gameover = new Label("GAME OVER", 45);
Gameover.Anchor = new Vec2(0.5, 0.9);
Frame.Add(Gameover);
ElementList names = new ElementList();
names.Add(new Label("DEATHS", 23));
names.Add(new Label("KILLS", 23));
names.Add(new Label("BONUSES", 23));
names.Horizontal = false;
names.Anchor = new Vec2(0.4, 0.5);
names.Visit((Element e) => e.FixedWidth = 130);
names.Spacing = 20;
Frame.Add(names);
Label p1 = new Label("PLAYER 1", 23);
Label p2 = new Label("PLAYER 2", 23);
p1.FixedWidth = 110;
p2.FixedWidth = 110;
p1.Anchor = new Vec2(0.65, 0.75);
p2.Anchor = new Vec2(0.85, 0.75);
Frame.Add(p1);
Frame.Add(p2);
ElementList p1stats = new ElementList();
p1stats.Add(new Label(Program.Statistics.Deaths[0].ToString(), 23));
p1stats.Add(new Label(Program.Statistics.Kills[0].ToString(), 23));
p1stats.Add(new Label(Program.Statistics.Bonuses[0].ToString(), 23));
p1stats.Horizontal = false;
p1stats.Anchor = new Vec2(0.65, 0.5);
p1stats.Visit((Element e) => e.FixedWidth = 110);
p1stats.Spacing = 20;
Frame.Add(p1stats);
ElementList p2stats = new ElementList();
p2stats.Add(new Label(Program.Statistics.Deaths[1].ToString(), 23));
p2stats.Add(new Label(Program.Statistics.Kills[1].ToString(), 23));
p2stats.Add(new Label(Program.Statistics.Bonuses[1].ToString(), 23));
p2stats.Horizontal = false;
p2stats.Anchor = new Vec2(0.85, 0.5);
p2stats.Visit((Element e) => e.FixedWidth = 110);
p2stats.Spacing = 20;
Frame.Add(p2stats);
player.Dir = 1;
Winner = new Walking(player);
cam.Position = player.Position + new Vec2(40, 0);
}
/// <summary>
/// Add Image to Pdf from Image path.
/// </summary>
/// <param name="ImagePath">A Path</param>
/// <param name="MaxHeight">Max Height Allowed</param>
/// <param name="MaxWidth">Max Width Allowed</param>
/// <exception cref="System.ArgumentNullException">ImagePath is null.</exception>
/// <exception cref="System.UriFormatException">ImagePath is empty.-or- The scheme specified in ImagePath is not correctly formed.</exception>
private static void AddImageWithWidthHeight(String ImagePath, Int32 MaxHeight = 700, Int32 MaxWidth = 600)
{
System.Drawing.Image Image = System.Drawing.Bitmap.FromFile(ImagePath);
iTextSharp.text.Image pic = iTextSharp.text.Image.GetInstance(Image, System.Drawing.Imaging.ImageFormat.Jpeg);
if (pic.Height > pic.Width)
{
//Maximum height is 800 pixels.
float percentage = 0.0f;
percentage = MaxHeight / pic.Height;
pic.ScalePercent(percentage * 100);
}
else
{
//Maximum width is 600 pixels.
float percentage = 0.0f;
percentage = 600 / pic.Width;
pic.ScalePercent(percentage * 100);
}
pic.Border = iTextSharp.text.Rectangle.BOX;
pic.BorderColor = iTextSharp.text.BaseColor.GREEN;
pic.BorderWidth = 3f;
ElementList.Add(pic);
}
/// <summary>
/// Loads the preambles file
/// </summary>
public void LoadPreambles(string PreamblesFile)
{
ElementList.Clear();
try
{
if (File.Exists(PreamblesFile))
{
XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(List <DynPreambleElement>));
using (TextReader tr = new StreamReader(PreamblesFile))
{
List <DynPreambleElement> l = serializer.Deserialize(tr) as List <DynPreambleElement>;
if (l != null)
{
foreach (var model in l)
{
ElementList.Add(new DynPreambleElementVM(model));
}
// register property change handlers
foreach (var vm in ElementList)
{
vm.PropertyChanged += (o, e) => NotifyPropertyChanged("Preamble");
}
}
}
}
}
catch (Exception)
{
}
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
int IndexToRemove;
int NumberToAdd;
List <int> RemovedIndexes = new List <int>();
for (int i = 0; i < ElementNumber;)
{
IndexToRemove = Random.Next(0, SetSize - (1 + RemovedIndexes.Count));
if (RemovedIndexes.IndexOf(IndexToRemove) == -1)
{
NumberToAdd = NumberList[IndexToRemove];
ElementList.Add(NumberToAdd);
NumberList.RemoveAt(IndexToRemove);
RemovedIndexes.Add(IndexToRemove);
i++;
}
}
ElementList.Sort();
}
/// <summary>Search AvailableElementData by mission code (aka commercial number).</summary>
/// <param name="commercialNumber">Mission code (aka commercial number)</param>
/// <returns>list of found AvailableElementData.</returns>
internal ElementList <AvailableElementData> GetAvailableElementDataListByMissionCode(string commercialNumber)
{
ElementList <AvailableElementData> elementDataList = new ElementList <AvailableElementData>();
if (!string.IsNullOrEmpty(commercialNumber))
{
IList <SystemInfo> systemList;
lock (_systemListLock)
{
systemList = _systemList.Where(element => (element.Value.PisMission != null && element.Value.PisMission.CommercialNumber == commercialNumber)).Select(e => e.Value).ToList();
}
elementDataList.Capacity = systemList.Count;
foreach (SystemInfo system in systemList)
{
AvailableElementData elementData = T2GDataConverter.BuildAvailableElementData(system);
if (elementData != null)
{
elementDataList.Add(elementData);
}
}
}
return(elementDataList);
}
public void PickElements()
{
int randIndex = -1;
int uniqueNum = 0;
// If ElementList has element(s) then clear both lists and rebuilt
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build(); // rebuild _numberList data
}
// Loop trhough number of elements need to add
for (int i = 0; i < ElementNumber; i++)
{
// Generate a random index position between 1 to SetSize (inclusive)
randIndex = _Random.Next(1, SetSize);
uniqueNum = NumberList.ElementAt(randIndex);
// Determine its a duplicate number
while (ElementList.Contains(uniqueNum))
{
// Then again generate number
randIndex = _Random.Next(1, SetSize);
uniqueNum = NumberList.ElementAt(randIndex);
}
// If its a unique number then add to element list
ElementList.Add(uniqueNum);
}
// Sort the ElementList
ElementList.Sort();
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
//ElementList and NumberList call their clear method:
ElementList.Clear();
NumberList.Clear();
//build method is called:
this._build();
//6 random numbers are selected from NumberList, they are added to the ElementList and then removed from NumberList:
IEnumerable <int> threeRandom = NumberList.OrderBy(x => Random.Next()).Take(this.ElementNumber);
foreach (int y in threeRandom)
{
ElementList.Add(y);
}
ElementList.Sort();
NumberList.RemoveAll(c => ElementList.ToList().Exists(n => n == c));
}
else
{
//build method is called:
this._build();
//6 random numbers are selected from NumberList, they are added to the ElementList and then removed from NumberList:
IEnumerable <int> threeRandom = NumberList.OrderBy(x => Random.Next()).Take(ElementNumber);
foreach (int y in threeRandom)
{
ElementList.Add(y);
}
NumberList.RemoveAll(c => ElementList.ToList().Exists(n => n == c));
}
}
/// <summary>
/// Search AvailableElementData By TargetAddress (By Element, MissionOperatorCode, or MissionId)
/// </summary>
/// <param name="targetAddress">Target address.</param>
/// <param name="lstAvailableElementData">[out] Information describing the list available element.</param>
/// <returns>List of AvailableElementData matching TargetAddress criteria.</returns>
public T2GManagerErrorEnum GetAvailableElementDataByTargetAddress(TargetAddressType targetAddress, out ElementList <AvailableElementData> lstAvailableElementData)
{
T2GManagerErrorEnum lReturn = T2GManagerErrorEnum.eFailed;
lstAvailableElementData = new ElementList <AvailableElementData>();
if (targetAddress != null && !string.IsNullOrEmpty(targetAddress.Id))
{
// Resolve target elements
switch (targetAddress.Type)
{
case AddressTypeEnum.Element:
AvailableElementData element = new AvailableElementData();
lReturn = GetAvailableElementDataByElementNumber(targetAddress.Id, out element);
if (lReturn == T2GManagerErrorEnum.eSuccess)
{
lstAvailableElementData.Add(element);
}
break;
case AddressTypeEnum.MissionOperatorCode:
lReturn = GetAvailableElementDataListByMissionOperatorCode(targetAddress.Id, out lstAvailableElementData);
break;
case AddressTypeEnum.MissionCode:
lReturn = GetAvailableElementDataListByMissionCode(targetAddress.Id, out lstAvailableElementData);
break;
}
}
return(lReturn);
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
/// <summary>
/// PickElements method will grantee unique and random numbers are exist in number list
/// </summary>
public void PickElements()
{
if (ElementNumber > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
int counter = NumberList.Count;
for (int i = 0; i < counter; i++)
{
int selectionPostion = random.Next(0, maxValue: NumberList.Count);
int selection = NumberList[selectionPostion];
ElementList.Add(selection);
NumberList.RemoveAt(selectionPostion);
}
}
else
{
_build();
int counter = 0;
do
{
int selectionPostion = random.Next(0, maxValue: NumberList.Count);
int selection = NumberList[selectionPostion];
ElementList.Add(selection);
NumberList.RemoveAt(selectionPostion);
} while (counter < NumberList.Count);
}
}
public void AddDataToElementList()
{
var list = new ElementList <Element>("test");
var data = new Data <string>("data", "value", -1, "", true);
list.Add(data);
Assert.IsTrue(data.Categories.Contains(list));
}
public bool Create(string measDetId, ElementList sParams)
{
db.SetConnection();
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(measDetId);
sParams.Add(new Element("detector_id", l));
string sSQL1 = "Insert into " + table + " ";
string sSQL = sSQL1 + sParams.ColumnsValues;
return db.Execute(sSQL);
}
public long Create(long measid, ElementList sParams)
{
db.SetConnection();
ArrayList sqlList = new ArrayList();
string sSQL1 = "Insert into results_rec ";
sParams.Add(new Element("mid", measid));
string sSQL = sSQL1 + sParams.ColumnsValues; sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID("results_rec"));
return db.ExecuteTransactionID(sqlList);
}
public long Create(long mid, ElementList resParams)
{
db.SetConnection();
resParams.Add(new Element("mid", mid));
ArrayList sqlList = new ArrayList();
string sSQL1 = "Insert into " + table + "_m" + " ";
string sSQL = sSQL1 + resParams.ColumnsValues;
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID(table + "_m" ));
return db.ExecuteTransactionID(sqlList);
}
public BaseDataTypeEdit(string Xmlpath)
{
XmlNodeList list = ComeCommonMethod.XmlFunction.GetElementList(Xmlpath, "DataTypeName/Name");
for (int i = 0; i < list.Count; i++)
{
ElementList.Add(new DataBaseTypeElement()
{
ColumnName = list[i].InnerText
});
}
}
//Adds a diagram lines and shapes to an svg document
private void AddModelImplementation(Model model)
{
ElementList list = new ElementList(true);
//Add each sorted shape to the svg document
foreach (Element element in model.Lines.Values)
{
if (element.Visible)
{
list.Add(element);
}
}
//Add each sorted line to the svg document
foreach (Element element in model.Shapes.Values)
{
if (element.Visible)
{
list.Add(element);
}
}
list.Sort();
//Go through the diagram and add the element by layer;
foreach (Layer layer in model.Layers)
{
if (layer.Visible)
{
foreach (Element element in list)
{
if (element.Layer == layer)
{
AddElement(element);
}
}
}
}
}
/// <summary>
/// Add Image to Pdf from Image path with Scale size.
/// </summary>
/// <param name="ImagePath"></param>
/// <param name="ImageSize"></param>
/// <exception cref="System.ArgumentNullException">ImagePath is null.</exception>
/// <exception cref="System.UriFormatException">ImagePath is empty.-or- The scheme specified in ImagePath is not correctly formed.</exception>
private static void AddImageWithSize(String ImagePath, float ImageSize = 100f)
{
System.Drawing.Image Image = System.Drawing.Bitmap.FromFile(ImagePath);
iTextSharp.text.Image pic = iTextSharp.text.Image.GetInstance(Image, System.Drawing.Imaging.ImageFormat.Jpeg);
pic.ScaleAbsolute(ImageSize, ImageSize);
PdfPTable table = new PdfPTable(1);
table.AddCell(new PdfPCell(pic));
table.DefaultCell.Border = iTextSharp.text.Rectangle.NO_BORDER;
ElementList.Add(table);
}
public ElementList ToElementList(string layerName)
{
TMXLayer thisLayer = this.Map.Layers.FirstOrDefault(s => s.Name == layerName);
if (thisLayer == null)
{
throw new Exception("Unable to find layer '" + layerName + "'");
}
ElementList newElementList = new ElementList();
MapCellList list = ParseTMXData(thisLayer.Data);
int tileX = 0;
int tileY = 0;
foreach (MapCell cell in list)
{
if (cell.TileID > 0)
{
TMXTile tile = GetTileById(cell.TileID);
string type = tile.Properties.FirstOrDefault(p => p.Name.ToLower() == "type").Value;
if (type == null)
{
type = "0";
}
string state = tile.Properties.FirstOrDefault(p => p.Name.ToLower() == "state").Value;
if (state == null)
{
state = "0";
}
Element ele = new Element()
{
Type = type,
State = state,
X = (tileX * this.Map.TileWidth),
Y = (tileY * this.Map.TileHeight)
};
newElementList.Add(ele);
}
tileX++;
if (tileX > this.Map.Width)
{
tileX = 0;
tileY++;
}
}
return(newElementList);
}
/// <summary>
/// Appends the specified element to the end of this queue.
/// </summary>
/// <remarks>
/// Queues may place limitations on what elements may be added
/// to this Queue. In particular, some Queues will impose restrictions
/// on the type of elements that may be added. Queue implementations
/// should clearly specify in their documentation any restrictions on
/// what elements may be added.
/// </remarks>
/// <param name="obj">
/// Element to be appended to this Queue.
/// </param>
/// <returns>
/// <b>true</b> (as per the general contract of the IList.Add method)
/// </returns>
/// <exception cref="InvalidCastException">
/// If the class of the specified element prevents it from being added
/// to this Queue.
/// </exception>
public virtual bool Add(object obj)
{
lock (this)
{
ElementList.Add(obj);
// this Queue reference is waited on by the blocking remove
// method; use notify to wake up a thread waiting
// to remove
Monitor.Pulse(this);
return(true);
}
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
/*
* build the _elementList with a set of random numbers.
*/
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 0; i < ElementNumber; i++)
{
int randomPosition = Random.Next(0, NumberList.Count);
ElementList.Add(NumberList[randomPosition]);
NumberList.RemoveAt(randomPosition);
}
ElementList.Sort();
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
this._build();
}
for (int i = 0; i < ElementNumber; i++)
{
int chance = this.random.Next(0, NumberList.Count);
NumberList.Remove(chance);
ElementList.Add(chance);
}
ElementList.Sort();
}
public void Handle(UserChangedEvent message)
{
var viewmodel = (from vm in ElementList where vm.Id == message.User.Id select vm).FirstOrDefault();
if (viewmodel == null)
{
viewmodel = new UserRowViewModel(message.User);
ElementList.Add(viewmodel);
ConnectElement(viewmodel);
}
else
{
viewmodel.ExchangeData(message.User);
viewmodel.Refresh();
}
NotifyOfPropertyChange(() => ItemSelected);
NotifyOfPropertyChange(() => ItemsSelected);
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 1; i <= ElementNumber; i++)
{
int n = _random.Next(1, 50);
NumberList.Remove(n);
ElementList.Add(n);
}
ElementList.Sort();
}
// PUBLIC METHODS +_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+_+
// CREATING the public PickElements method here --------------------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
this._build();
}
for (int i = 0; i < ElementNumber; i++)
{
int Number = aa_random.Next(NumberList.Count);
ElementList.Add(NumberList[Number]);
NumberList.RemoveAt(Number);
}
ElementList.Sort();
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 1; i <= ElementNumber; i++)
{
int r = _random.Next(NumberList.Count);
ElementList.Add(NumberList[r]);
NumberList.RemoveAt(r);
}
ElementList.Sort();
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 0; i < ElementNumber; i++)
{
int index = random.Next(NumberList.Count);
ElementList.Add(NumberList[index]);
NumberList.RemoveAt(index);
}
ElementList.Sort();
}
/// <summary>Get all AvailableElementData</summary>
/// <returns>list of all AvailableElementData.</returns>
internal ElementList <AvailableElementData> GetAvailableElementDataList()
{
ElementList <AvailableElementData> elementDataList = new ElementList <AvailableElementData>();
lock (_systemListLock)
{
elementDataList.Capacity = _systemList.Count;
foreach (KeyValuePair <string, SystemInfo> system in _systemList)
{
AvailableElementData elementData = T2GDataConverter.BuildAvailableElementData(system.Value);
if (elementData != null)
{
elementDataList.Add(elementData);
}
}
}
return(elementDataList);
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 0; i < ElementNumber; i++)
{
int lottery = _random.Next(NumberList.Count); // element list real number, numberlist = how many list you have
ElementList.Add(NumberList[lottery]); // Add
NumberList.RemoveAt(lottery); // remove above
}
ElementList.Sort();
}
/// <summary>
/// Extended version of AddParagraph to avoid passing the Document object.
/// </summary>
/// <param name="ParagraphContent"></param>
/// <param name="FontFamily"></param>
/// <param name="FontSize"></param>
/// <param name="FontColor"></param>
public static void AddParagraph2(String ParagraphContent, String FontFamily, float FontSize, Color?FontColor = null)
{
//baseFont = BaseFont.CreateFont(TextFont.Name, BaseFont.TIMES_ROMAN, BaseFont.NOT_EMBEDDED);
iTextSharp.text.Font ltFont;
BaseColor basecolor;
if (FontColor != null)
{
basecolor = new BaseColor((Color)FontColor);
ltFont = FontFactory.GetFont(FontFamily, FontSize, basecolor);
}
else
{
ltFont = FontFactory.GetFont(FontFamily, FontSize);
}
Paragraph ltParagraph = new Paragraph(ParagraphContent, ltFont);
ElementList.Add(ltParagraph);
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
public void PickElements()
{
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
int j = 0;
while (j < ElementNumber)
{
int randPosition = _random.Next(NumberList.Count);
ElementList.Add(NumberList[randPosition]);
NumberList.Remove(NumberList[randPosition]);
j++;
}
ElementList.Sort();
}
/// <summary>
/// Constructs a block selector window.
/// </summary>
public BlockPlacer(Engine engine, LevelEditor parentEditor)
: base("Block Selector")
{
this.parentEditor = parentEditor;
ScreenButton _but = new ScreenButton(this, "Back", "<", engine.FontMain);
_but.Position.X = boarderSize;
_but.Size.X = 32;
ElementList.Add(_but);
_but = new ScreenButton(this, "Forward", ">", engine.FontMain);
_but.Position.X = boarderSize + 32 + boarderSize;
_but.Size.X = 32;
_but.Position.Y = headerSize + boarderSize;
ElementList.Add(_but);
_but = new ScreenButton(this, "New Block", "New", engine.FontMain);
_but.Position.X = boarderSize + 32 + boarderSize + 32 + boarderSize;
_but.Size.X = 48;
_but.Position.Y = headerSize + boarderSize;
ElementList.Add(_but);
_but = new ScreenButton(this, "Edit Block", "Edit", engine.FontMain);
_but.Position.X = boarderSize + 32 + boarderSize + 32 + boarderSize + 48 + boarderSize;
_but.Size.X = 48;
_but.Position.Y = headerSize + boarderSize;
ElementList.Add(_but);
_but = new ScreenButton(this, "Save/Load", "Sv/Ld", engine.FontMain);
_but.Position.X = boarderSize + 32 + boarderSize + 32 + boarderSize + 48 + boarderSize + 48 + boarderSize;
_but.Size.X = 48;
_but.Position.Y = headerSize + boarderSize;
ElementList.Add(_but);
InputField = new ScreenInput(this, engine.FontMain);
AddElement(InputField);
PrevPosition = new Vector2((Size.X - PrevBoxWidth * PrevMaximumColumns) / 2, GetTotalElementHeight());
this.Size.Y = PrevPosition.Y + Screen.boarderSize + PrevMaximumRows * PrevBoxHeight;
FilterBlocks(engine);
this.Position = new Vector2(engine.windowSize.X - this.Size.X, 0);
}
// PUBLIC METHODS +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// CREATE the public PickElements method here ----------------------------
public void PickElement()
{ /* using if statement to clean previously Element list and Number list, then create
* new number list so that the newest Element list can be created through for statement */
if (ElementList.Count > 0)
{
ElementList.Clear();
NumberList.Clear();
_build();
}
for (int i = 1; i <= ElementNumber; i++)
{
//Select random number between 1 to 49
int randomNumber = random.Next(1, 50);
//Remove selected number from Number list to avoid selecting repeated number
NumberList.Remove(randomNumber);
//Add selected number to Element list
ElementList.Add(randomNumber);
//Sort element list ordered by ascending
ElementList.Sort();
}
}
private void Start()
{
ElementList.Clear();
var message = Resources.Message_BusyIndicator_Title;
var result = _BusyWindow.ExecuteAndWait(message, InspectDirectory);
if (_BusyWindow.IsSuccessfullyExecuted == true)
{
ElementList.Add(result);
result.IsExpanded = true;
RefreshElementsVisibilities();
}
else
{
MessageBox.Show(
string.Format(Resources.Message_Error_ParsingDirectoryFailed, _BusyWindow.ExecutionException.Message),
Resources.Message_ApplicationTitle, MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public bool Update(string DetectorName, string CounterType, ElementList sParams)
{
DataRow dr = null;
string table = "CountingParams";
if (CounterType.Equals("Multiplicity") || CounterType.Equals("Coincidence"))
table = "LMMultiplicity";
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
if (l == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det key ({0}) selecting CountingParams", l);
return false;
}
if (table.Equals("LMMultiplicity"))
dr = HasRow(DetectorName, CounterType, table, sParams[faidx].Value); // the FA parameter
else
dr = HasRow(DetectorName, CounterType, table);
if (dr == null)
{
sParams.Add(new Element("detector_id", l));
string sSQL = "Insert into " + table;
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
//NEXT: not tested(?)
string sSQL = "UPDATE " + table + " SET ";
sSQL += (sParams.ColumnEqValueList + " where counter_type=" + SQLSpecific.QVal(CounterType) + " AND detector_id=" + l.ToString());
if (table.Equals("LMMultiplicity"))
sSQL += " AND " + sParams[faidx].Name + "=" + sParams[faidx].Value;
return db.Execute(sSQL);
}
}
public void VerityCtor()
{
ElementList noargslist = new ElementList();
noargslist.Add(new Element("b").Update("Chris"));
Assert.AreEqual("<b>Chris</b>", noargslist.ToString());
ElementList argslist = new ElementList(
new Element("b").Update("Riley"),
new Element("i").Update("Emmitt"));
string actual = argslist;
Assert.AreEqual("<b>Riley</b><i>Emmitt</i>", actual);
}
protected string CycleInsertStatement(long Measurement_ID, ElementList sParams)
{
sParams.Add(new Element("mid", Measurement_ID));
return "Insert into cycles " + sParams.ColumnsValues;
}
protected string HVPRunInsertStatement(long HVPId, ElementList sParams)
{
sParams.Add(new Element("hvp_id", HVPId));
return "Insert into HVStatus " + sParams.ColumnsValues;
}
public long CreateMethod(long resid, long mid, ElementList resParams)
{
db.SetConnection();
resParams.Add(new Element("rid", resid));
resParams.Add(new Element("mid", mid));
ArrayList sqlList = new ArrayList();
string sSQL1 = "Insert into " + MethodTableName(resParams.OptTable) + " ";
string sSQL = sSQL1 + resParams.ColumnsValues;
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID(MethodTableName(resParams.OptTable)));
return db.ExecuteTransactionID(sqlList);
}
public bool Update(string DetectorName, string ItemType, ElementList sParams)
{
bool res = false;
db.SetConnection();
//NEXT: this duo-lookup part takes too long, so get the values once in a wrapper call, then cache them, then reuse them
DataRow dr = HasRow(DetectorName, ItemType); // sets the connection
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
Descriptors mats = new Descriptors("material_types", db);
long m = mats.PrimaryKey(ItemType);
if (l == -1 || m == -1)
{
DBMain.AltLog(LogLevels.Warning, 70130, "Missing Det/Mat keys ({0},{1}) selecting AnalysisMethods", l, m);
return false;
}
if (dr == null) // a new entry!
{
string sSQL = "insert into analysis_method_rec ";
sParams.Add(new Element("item_type_id", m));
sParams.Add(new Element("analysis_method_detector_id", l));
sSQL = sSQL + sParams.ColumnsValues;
res = db.Execute(sSQL);
}
else
{
string wh = " where item_type_id= " + m.ToString() + " AND analysis_method_detector_id=" + l.ToString();
string sSQL1 = "UPDATE analysis_method_rec SET ";
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
res = db.Execute(sSQL);
}
return res;
}
///////////////////////
public bool UpdateCalib(string DetectorName, string ItemType, string calib_table, ElementList sParams)
{
//NEXT: this duo-lookup part takes too long, so get the values once in a wrapper call, then cache them, then reuse them
long l, m;
GetKeys(DetectorName, ItemType, out l, out m);
DataRow dr = HasRow(l, m); // sets the connection
if (l == -1 || m == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det/Mat keys ({0},{1}) selecting method calibration params", l, m);
return false;
}
string wh = " where item_type_id= " + m.ToString() + " AND detector_id=" + l.ToString();
string exsql = "select item_type_id from " + calib_table + wh; // 1 column is sufficient to show existence
DataTable dt = db.DT(exsql);
if (dt.Rows.Count < 1)
{
string sSQL = "insert into " + calib_table + " ";
sParams.Add(new Element("item_type_id", m));
sParams.Add(new Element("detector_id", l));
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
string sSQL1 = "UPDATE " + calib_table + " SET ";
string sSQL = sSQL1 + sParams.ColumnEqValueList + wh;
return db.Execute(sSQL);
}
}
public bool Insert(string DetectorName, string CounterType, ElementList sParams)
{
DataRow dr = null;
string table = "CountingParams";
if (CounterType.Equals("Multiplicity") || CounterType.Equals("Coincidence"))
table = "LMMultiplicity";
Detectors dets = new Detectors(db);
long l = dets.PrimaryKey(DetectorName);
if (l == -1)
{
DBMain.AltLog(LogLevels.Warning, 70137, "Missing Det key ({0}) selecting CountingParams", l);
return false;
}
if (table.Equals("LMMultiplicity"))
dr = HasRow(l, CounterType, table, sParams, sParams[faidx].Value); // the FA parameter
else
dr = HasRow(l, CounterType, table, sParams);
if (dr == null)
{
sParams.Add(new Element("detector_id", l));
string sSQL = "Insert into " + table;
sSQL += sParams.ColumnsValues;
return db.Execute(sSQL);
}
else
{
// identical row found, skip it
return false;
}
}
public long CreateTbl(long id, string table, ElementList sParams, IDB db)
{
sParams.Add(new Element("detector_id", id));
string sSQL1 = "Insert into " + table + " ";
string sSQL = sSQL1 + sParams.ColumnsValues;
ArrayList sqlList = new ArrayList();
sqlList.Add(sSQL);
sqlList.Add(SQLSpecific.getLastID(table));
return db.ExecuteTransactionID(sqlList);
}
protected string CIInsertStatement(long cid, ElementList sParams)
{
sParams.Add(new Element("cid", cid));
return "Insert into composite_isotopic_rec " + sParams.ColumnsValues;
}
