internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition,
bool finalResults)
{
lock (resultHolders)
{
foreach (CResultHolder holder in resultHolders)
{
if (holder.WClass == wclass &&
holder.UClass == uclass &&
holder.NorwegianCount == competition.NorwegianCount &&
holder.FinalResults == finalResults)
{
return(holder.Results);
}
}
ResultsReturn[] results = result.GetResults(wclass,
uclass,
competition,
finalResults);
CResultHolder newHolder = new CResultHolder(
wclass,
uclass,
competition.NorwegianCount,
finalResults,
results);
resultHolders.Add(newHolder);
return(results);
}
}
/*private ResultsReturn[] convertIntoArray(ResultsReturn results)
* {
* ResultsReturn[] returnArray =
* new ResultsReturn[results.Count];
* int i = 0;
* Structs.Competition competition = myInterface.GetCompetitions()[0];
* foreach(DSResults.ResultsRow row in results)
* {
* returnArray[i] = new ResultsReturn(competition.Type, competition.NorwegianCount);
* returnArray[i].ClubId = row.ClubId;
* returnArray[i].CompetitorId = row.CompetitorId;
* returnArray[i].HitsTotal = row.Hits;
* returnArray[i].Medal = row.Medal;
* returnArray[i].PointsTotal = row.Points;
* returnArray[i].ShooterName = row.ShooterName;
* returnArray[i].FigureHitsTotal = row.FigureHits;
* returnArray[i].HitsPerStnString = row.HitsPerStn;
* returnArray[i].FinalShootingPlace = row.FinalShootingPlace;
* returnArray[i].PriceMoney = row.PriceMoney;
* i++;
* }
* return returnArray;
* }*/
internal Structs.ResultWeaponsClass[] ResultsGetWClasses()
{
database = myInterface.databaseClass.Database;
ArrayList list = new ArrayList();
for (int i = 1; i <= Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass thisClass =
(Structs.ResultWeaponsClass)i;
try
{
int.Parse(thisClass.ToString());
}
catch (Exception)
{
// thisClass is a string, which means it is a valid class
if (myInterface.GetCompetitorResultsExist(thisClass))
{
list.Add(thisClass);
}
}
}
return((Structs.ResultWeaponsClass[])list.ToArray(typeof(Structs.ResultWeaponsClass)));
}
internal string ExportResults(bool finalResults)
{
//database = myInterface.databaseClass.database;
StringBuilder html = new StringBuilder();
html.Length = 0;
html.Append(createHtmlHeader());
html.Append(createCompetitionHeader());
html.Append("<h1>Individuella resultat</h1>");
// Get results for the competitors
for (int i = 1; i < Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass wclass =
(Structs.ResultWeaponsClass)i;
if (i.ToString() != wclass.ToString())
{
// A real resultweaponsclass
for (int j = 1; j <= Structs.ShootersClassMax; j++)
{
Structs.ShootersClass uclass =
(Structs.ShootersClass)j;
if (j.ToString() != uclass.ToString())
{
// TODO fixa en bättre räknare
if (myInterface.GetCompetitorResultsExist(wclass, uclass))
{
html.Append(createCompetitorResults(wclass,
uclass, finalResults));
}
}
}
}
}
// Get results for the teams
for (int i = 1; i < Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass wclass =
(Structs.ResultWeaponsClass)i;
if (i.ToString() != wclass.ToString())
{
// A real resultweaponsclass
Structs.ResultsReturnTeam[] teamresults =
myInterface.resultTeamClass.GetTeamResults(wclass, myInterface.GetCompetitions()[0].NorwegianCount);
if (teamresults.Length > 0)
{
html.Append(createTeamResults(teamresults, wclass));
}
}
}
html.Append(createHtmlFooter());
return(html.ToString());
}
private byte[] ExportTeamResults(Structs.ResultWeaponsClass wclass,
bool finalResults, bool returnDocument,
ref pdfPage page, ref double yPos)
{
if (yPos + conversionPixelsToMM * 3 * fontSize >= bottomMargin)
{
page = this.getNewPage(ref yPos);
}
ResultsReturnTeam[] results = myInterface.ResultsGetTeams(wclass,
myInterface.GetCompetitions()[0]);
if (results.Length == 0)
{
if (returnDocument)
{
return(returnPdfInBytes());
}
else
{
return(new byte[0]);
}
}
// Write headers
yPos = writeResultsPageTeamHeader(page, yPos, wclass);
yPos = writeResultsTeamHeader(page, yPos);
int i = 0;
foreach (ResultsReturnTeam result in results)
{
if (yPos + calculateTeamHeight(result) >= bottomMargin)
{
page = this.getNewPage(ref yPos);
yPos = writeResultsPageTeamHeader(page, yPos, wclass);
if (yPos < TextStart)
{
yPos = TextStart;
}
yPos = writeResultsTeamHeader(page, yPos);
}
i++;
yPos = writeResultsTeam(page, yPos, result, i);
}
// Return what we've created
if (returnDocument)
{
return(returnPdfInBytes());
}
else
{
return(new byte[0]);
}
}
internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition)
{
return(GetResults(
wclass,
uclass,
competition,
false));
}
internal string ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
StringBuilder html = new StringBuilder();
html.Append(createHtmlHeader());
html.Append(createCompetitionHeader());
html.Append(createCompetitorResults(wclass, uclass, finalResults));
html.Append(createHtmlFooter());
return(html.ToString());
}
internal ResultsReturnTeam[] GetTeamResults(Structs.ResultWeaponsClass wclass,
Structs.Competition competition)
{
Trace.WriteLine("CResults.GetResults(" + wclass.ToString() +
") started on thread \"" +
System.Threading.Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
while (resultsAlreadyRunning)
{
System.Threading.Thread.Sleep(50);
}
Trace.WriteLine("CResults: GetResults() " +
" locking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (GetResultsLock)
{
Trace.WriteLine("CResults: GetResults() " +
" locked \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
try
{
resultsAlreadyRunning = true;
CompetitionType = myInterface.CompetitionCurrent.Type;
database = myInterface.databaseClass.Database;
useNorwegianCount = competition.NorwegianCount;
// Ok, now lets count the real ones
DSResults results = getAllTeams(wclass);
results = sortTeams(results);
ResultsReturnTeam[] toReturn =
convertIntoArray(results);
return(toReturn);
}
finally
{
Trace.WriteLine("CResultsTeam: GetResults() " +
" unlocking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Trace.WriteLine("CResults.GetResults ended.");
resultsAlreadyRunning = false;
}
}
}
internal CResultHolder(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
bool norwegianCount,
bool finalResults,
ResultsReturn[] results)
{
WClass = wclass;
UClass = uclass;
NorwegianCount = norwegianCount;
FinalResults = finalResults;
Results = results;
}
internal byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
if (finalResults != true)
{
throw new ApplicationException("Not implemented yet");
}
double yPos = topMargin;
sharpPDF.pdfPage page = null;
return(ExportResults(wclass, uclass, finalResults, true, ref page, ref yPos));
}
private void calculateStandardMedals(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass)
{
List <ResultsReturn> results;
Structs.Competition competition = myInterface.CompetitionCurrent;
results = getAllCompetitors(
wclass,
uclass,
true);
results.Sort();
calculateMedals(results);
}
private double writeResultsClassHeader(pdfPage page, double yPos,
Structs.ResultWeaponsClass wclass, Structs.ShootersClass uclass)
{
Structs.ShootersClassShort uclassshort = (Structs.ShootersClassShort)(int) uclass;
string klass = uclassshort.ToString().Replace("Klass", "") +
wclass.ToString();
addText(page, "Klass:", leftMargin, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = addText(page, klass,
leftMargin + 30, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = yPos + 4;
return(yPos);
}
internal CPrintResultlist(ref Common.Interface newCommon,
Structs.ResultWeaponsClass wclasswanted,
Structs.ShootersClass uclasswanted,
bool prelResults,
string clubIdwanted) : base ()
{
CommonCode = newCommon;
wclass = wclasswanted;
uclass = uclasswanted;
printPrelResults = prelResults;
clubId = clubIdwanted;
competition = CommonCode.GetCompetitions()[0];
CompetitionType = competition.Type;
}
internal CPrintResultlist(ref Common.Interface newCommon,
Structs.ResultWeaponsClass wclasswanted,
Structs.ShootersClass uclasswanted,
bool prelResults,
string clubIdwanted) : base()
{
CommonCode = newCommon;
wclass = wclasswanted;
uclass = uclasswanted;
printPrelResults = prelResults;
clubId = clubIdwanted;
competition = CommonCode.GetCompetitions()[0];
CompetitionType = competition.Type;
}
internal byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
ResultsReturn[] results =
myInterface.resultClass.GetResults(
wclass,
uclass,
myInterface.CompetitionCurrent);
string resultString = RenderResults(results);
Encoding enc = ASCIIEncoding.GetEncoding(1252);
return(enc.GetBytes(resultString));
}
private byte[] ExportResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults, bool returnDocument,
ref pdfPage page, ref double yPos)
{
if (yPos + conversionPixelsToMM * 3 * fontSize >= bottomMargin)
{
page = this.getNewPage(ref yPos);
}
// Write headers
yPos = writeResultsClassHeader(page, yPos, wclass, uclass);
if (yPos < TextStart)
{
yPos = TextStart;
}
yPos = writeResultsHeader(page, yPos);
ResultsReturn[] results = myInterface.resultClass.GetResults(wclass, uclass,
myInterface.CompetitionCurrent, true);
int i = 0;
foreach (ResultsReturn result in results)
{
if (yPos + conversionPixelsToMM * fontSize >= bottomMargin)
{
page = this.getNewPage(ref yPos);
yPos = writeResultsClassHeader(page, yPos, wclass, uclass);
if (yPos < TextStart)
{
yPos = TextStart;
}
yPos = writeResultsHeader(page, yPos);
}
i++;
yPos = writeResultsUser(page, yPos, result, i);
}
// Return what we've created
if (returnDocument)
{
return(returnPdfInBytes());
}
else
{
return(new byte[0]);
}
}
internal Structs.ResultWeaponsClass[] GetResultWeaponClassesWithResults()
{
string select = "SELECT DISTINCT weapons.class " +
"FROM (weapons RIGHT JOIN Competitors ON weapons.WeaponId = Competitors.WeaponId) " +
"INNER JOIN CompetitorResults ON Competitors.CompetitorId = CompetitorResults.CompetitorId;";
System.Data.OleDb.OleDbCommand cmd = new System.Data.OleDb.OleDbCommand(
select, myInterface.databaseClass.Conn);
if (myInterface.databaseClass.Conn.State != ConnectionState.Open)
{
myInterface.databaseClass.Conn.Open();
}
System.Data.OleDb.OleDbDataReader r = cmd.ExecuteReader();
List <Structs.WeaponClass> wclasses = new List <Structs.WeaponClass>();
while (r.Read())
{
wclasses.Add((Structs.WeaponClass)r.GetInt32(0));
}
r.Dispose();
cmd.Dispose();
List <Structs.ResultWeaponsClass> rwclasses = new List <Structs.ResultWeaponsClass>();
foreach (Structs.WeaponClass wclass in wclasses)
{
// Check for duplicates
Structs.ResultWeaponsClass rwc =
CConvert.ConvertWeaponsClassToResultClass(
wclass,
myInterface.CompetitionCurrent.Type);
if (!rwclasses.Contains(rwc))
{
rwclasses.Add(rwc);
}
}
// Sort
rwclasses.Sort();
return(rwclasses.ToArray());
}
private void populateWeaponsClassDropDown()
{
Trace.WriteLine("FCompetitors: populateWeaponsClassDropDown() " +
"started on thread \"" +
Thread.CurrentThread.Name +
"\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() +
" )");
Structs.Competition[] comps = CommonCode.GetCompetitions();
if (comps.Length == 0)
{
return;
}
Structs.Competition comp = comps[0];
DatasetTeams ds = new DatasetTeams();
for (int i = 1; i <= Structs.ResultWeaponsClassMax; i++)
{
Structs.ResultWeaponsClass wc = (Structs.ResultWeaponsClass)i;
try
{
int test = int.Parse(wc.ToString());
}
catch (System.FormatException)
{
DatasetTeams.WeaponClassRow row =
ds.WeaponClass.NewWeaponClassRow();
row.ClassId = i;
row.ClassName = wc.ToString() + "-vapen";
if ((comp.Type != Structs.CompetitionTypeEnum.MagnumField &
row.ClassName.IndexOf("M") == -1) |
(comp.Type == Structs.CompetitionTypeEnum.MagnumField &
row.ClassName.IndexOf("M") > -1 &
row.ClassName != "M-vapen"))
{
ds.WeaponClass.AddWeaponClassRow(row);
}
}
this.ddWeaponClass.DataSource = ds.WeaponClass;
this.ddWeaponClass.DisplayMember = "ClassName";
this.ddWeaponClass.ValueMember = "ClassId";
}
Trace.WriteLine("FCompetitors: populateWeaponsClassDropDown() ended.");
}
private void populateCompetitors()
{
Trace.WriteLine("FCompetitors: DdClubs_SelectedIndexChanged() " +
"started on thread \"" +
Thread.CurrentThread.Name +
"\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() +
" )");
Structs.Club club =
CommonCode.GetClub(
(string)this.DdClubs.SelectedValue);
Structs.ResultWeaponsClass wclass =
(Structs.ResultWeaponsClass)
(int) this.ddWeaponClass.SelectedValue;
// Get all shooters that belong to the current club and
// have a competitor with the current class
//Structs.Shooter[] shooters = CommonCode.GetShooters(club, wclass);
Structs.Competitor[] comps = CommonCode.GetCompetitors(club, wclass, "Surname, Givenname");
DatasetTeams ds1 = new DatasetTeams();
DatasetTeams ds2 = new DatasetTeams();
DatasetTeams ds3 = new DatasetTeams();
DatasetTeams ds4 = new DatasetTeams();
DatasetTeams ds5 = new DatasetTeams();
shooters = new Hashtable();
addShootersToDS(ds1, comps);
addShootersToDS(ds2, comps);
addShootersToDS(ds3, comps);
addShootersToDS(ds4, comps);
addShootersToDS(ds5, comps);
// Bind the dropdowns to the datatable
this.ddCompetitor1.DataSource = ds1.Competitors;
this.ddCompetitor2.DataSource = ds2.Competitors;
this.ddCompetitor3.DataSource = ds3.Competitors;
this.ddCompetitor4.DataSource = ds4.Competitors;
this.ddCompetitor5.DataSource = ds5.Competitors;
Trace.WriteLine("FCompetitors: DdClubs_SelectedIndexChanged() ended.");
}
private double writeResultsPageTeamHeader(pdfPage page, double yPos,
Structs.ResultWeaponsClass wclass)
{
Structs.Competition comp = myInterface.GetCompetitions()[0];
addText(page, "Tävling:", leftMargin, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = addText(page, comp.Name + ", " + comp.StartTime.ToShortDateString(),
leftMargin + 30, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
addText(page, "Vapen:", leftMargin, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
yPos = addText(page, wclass.ToString(),
leftMargin + 30, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
/*addText(page, "Klass:", leftMargin, yPos, fontCompetitionHeader, fontCompetitionHeaderSize);
* yPos = addText(page, uclass.ToString(),
* leftMargin + 30, yPos , fontCompetitionHeader, fontCompetitionHeaderSize);*/
yPos = yPos + 4;
return(yPos);
}
private Structs.ResultWeaponsClass getCurrentWeaponClass()
{
try
{
if (this.ddWClasses.SelectedIndex == -1)
{
return(Structs.ResultWeaponsClass.Unknown);
}
int selectedValue = (int)this.ddWClasses.SelectedValue;
Structs.ResultWeaponsClass thisClass =
(Structs.ResultWeaponsClass)selectedValue;
return(thisClass);
}
catch (System.Exception exc)
{
Trace.WriteLine("FResultsView.getCurrentWeaponClass " +
"Exception:\r\n" + exc.ToString());
throw;
}
}
private string createTeamResults(ResultsReturnTeam[] results,
Structs.ResultWeaponsClass wclass)
{
StringBuilder html = new StringBuilder();
html.Append("<h1>Lagtävling</h1>");
html.Append("Vapengrupp " + wclass.ToString() + ":");
html.Append("<table>\r\n");
html.Append("<tr>" +
"<td><b>Pl</b></td>" +
"<td><b>Klubb</b></td>" +
"<td><b>Lag</b></td>" +
"<td><b>Resultat</b></td>" +
"</tr>\r\n");
int place = 0;
foreach (ResultsReturnTeam result in results)
{
place++;
html.Append("<tr>");
html.Append("<td class=\"resultevenline\">" + place.ToString() + "</td>");
html.Append("<td class=\"resultevenline\">" + myInterface.GetClub(result.ClubId).Name + "</td>");
html.Append("<td class=\"resultevenline\">" + result.TeamName + "</td>");
switch (myInterface.GetCompetitions()[0].Type)
{
case Structs.CompetitionTypeEnum.Field:
{
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append("<td class=\"resultevenline\">" + (result.Hits + result.FigureHits).ToString() + "</td>");
}
else
{
html.Append("<td class=\"resultevenline\">" + result.Hits.ToString() + "/" + result.FigureHits.ToString() + "</td>");
}
break;
}
case Structs.CompetitionTypeEnum.Precision:
{
html.Append("<td class=\"resultevenline\">" + result.Hits.ToString() + "</td>");
break;
}
}
html.Append("</tr>\r\n");
// The total results
html.Append("<tr><td colspan=2></td>");
html.Append("<td colspan=2>" + result.HitsPerStn.Replace(";", " ") + "</td>");
html.Append("</tr>\r\n");
Structs.Team team = myInterface.GetTeam(result.TeamId);
foreach (int compId in (int[])team.CompetitorIds.ToArray(typeof(int)))
{
Structs.Competitor comp = myInterface.GetCompetitor(compId);
html.Append("<tr><td colspan=2></td>");
html.Append("<td>" + GetNameForCompetitor(comp) + "</td>");
html.Append("<td>" + GetResultForCompetitor(comp) + "</td>");
html.Append("</tr>\r\n");
}
}
html.Append("</table>");
return(html.ToString());
}
private string createTeamResults(Structs.ResultsReturnTeam[] results,
Structs.ResultWeaponsClass wclass)
{
StringBuilder html = new StringBuilder();
html.Append("<h1>Lagtävling</h1>");
html.Append("Vapenklass " + wclass.ToString() + ":");
html.Append("<table>\r\n");
html.Append("<tr>" +
"<td><b>Pl</b></td>" +
"<td><b>Klubb</b></td>" +
"<td><b>Lag</b></td>" +
"<td><b>Resultat</b></td>" +
"</tr>\r\n");
int place = 0;
foreach (Structs.ResultsReturnTeam result in results)
{
place++;
html.Append("<tr>");
html.Append("<td class=\"resultevenline\">" + place.ToString() + "</td>");
html.Append("<td class=\"resultevenline\">" + myInterface.GetClub(result.ClubId).Name + "</td>");
html.Append("<td class=\"resultevenline\">" + result.TeamName + "</td>");
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append("<td class=\"resultevenline\">" + (result.Hits + result.FigureHits).ToString() + "</td>");
}
else
{
html.Append("<td class=\"resultevenline\">" + result.Hits.ToString() + "/" + result.FigureHits.ToString() + "</td>");
}
html.Append("</tr>\r\n");
// The total results
html.Append("<tr><td colspan=2></td>");
html.Append("<td colspan=2>" + result.HitsPerStn.Replace(";", " ") + "</td>");
html.Append("</tr>\r\n");
Structs.Team team = myInterface.GetTeam(result.TeamId);
ArrayList comps = new ArrayList();
if (team.CompetitorId1 != -1)
{
comps.Add(team.CompetitorId1);
}
if (team.CompetitorId2 != -1)
{
comps.Add(team.CompetitorId2);
}
if (team.CompetitorId3 != -1)
{
comps.Add(team.CompetitorId3);
}
if (team.CompetitorId4 != -1)
{
comps.Add(team.CompetitorId4);
}
foreach (int compId in (int[])comps.ToArray(typeof(int)))
{
Structs.Competitor comp = myInterface.GetCompetitor(compId);
html.Append("<tr><td colspan=2></td>");
html.Append("<td>" + GetNameForCompetitor(comp) + "</td>");
html.Append("<td>" + GetResultForCompetitor(comp) + "</td>");
html.Append("</tr>\r\n");
}
}
html.Append("</table>");
return(html.ToString());
}
private string createCompetitorResults(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool finalResults)
{
StringBuilder html = new StringBuilder();
html.Append("<p><table>");
html.Append("<tr>");
html.Append("<td width=" + internalTableWidthcol1.ToString() +
"><b>Vapenklass:</b></td>");
html.Append("<td>" + wclass.ToString() + "</td>");
html.Append("</tr>");
html.Append("<tr>");
html.Append("<td width=" + internalTableWidthcol1.ToString() +
"><b>Klass:</b></td>");
html.Append("<td>" + uclass.ToString() + "</td>");
html.Append("</tr>");
html.Append("</table>");
if (this.useWidth)
{
html.Append("<table width=100% border=0 cellspacing=5 cellpadding=0>");
}
else
{
html.Append("<table border=0 cellspacing=0>");
}
foreach (string columnName in this.colOrder)
{
html.Append("<th");
if (useWidth)
{
html.Append(" width=");
}
switch (columnName)
{
case "Place":
if (useWidth)
{
html.Append(this.colPlaceWidth.ToString() + "%");
}
html.Append(" align=center>Pl");
break;
case "Name":
if (useWidth)
{
html.Append(this.colNameWidth.ToString() + "%");
}
html.Append(" align=left>Namn");
break;
case "Club":
if (useWidth)
{
html.Append(this.colClubWidth.ToString() + "%");
}
html.Append(" align=left>Klubb");
break;
case "Result":
if (useWidth)
{
html.Append(this.colResultWidth.ToString() + "%");
}
html.Append(" align=left colSpan=" +
(3 + myInterface.GetStationsCount()).ToString() +
">Result");
break;
case "ResultTot":
if (useWidth)
{
html.Append(this.colResultTotWidth.ToString() + "%");
}
html.Append(" align=center>Tot");
break;
case "Points":
if (useWidth)
{
html.Append(this.colPointsWidth.ToString() + "%");
}
html.Append(" align=center>" + HttpUtility.HtmlEncode("Poäng"));
break;
case "StdMed":
if (useWidth)
{
html.Append(this.colStdMedWidth.ToString() + "%");
}
html.Append(" align=center>Stm");
break;
case "PriceMoney":
if (finalResults)
{
html.Append(" align=center>Pris");
}
else
{
html.Append(">");
}
break;
}
html.Append("</th>");
}
Structs.ResultsReturn[] results =
myInterface.resultClass.GetResults(
wclass,
uclass,
myInterface.GetCompetitions()[0].NorwegianCount, finalResults);
int place = 0;
foreach (Structs.ResultsReturn result in results)
{
place++;
html.Append("<tr>");
foreach (string columnName in this.colOrder)
{
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\" ");
}
else
{
html.Append(" class=\"resultoddline\" ");
}
if (useWidth)
{
html.Append(" width=");
}
switch (columnName)
{
case "Place":
if (useWidth)
{
html.Append(this.colPlaceWidth.ToString() + "%");
}
html.Append(" align=center>" + place.ToString());
break;
case "Name":
if (useWidth)
{
html.Append(this.colNameWidth.ToString() + "%");
}
html.Append(" align=left>" +
HttpUtility.HtmlEncode(result.ShooterName));
break;
case "Club":
if (useWidth)
{
html.Append(this.colClubWidth.ToString() + "%");
}
html.Append(" align=left>" +
HttpUtility.HtmlEncode(
myInterface.GetClub(result.ClubId).Name));
break;
case "Result":
if (useWidth)
{
html.Append(this.colResultWidth.ToString() + "%");
}
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append(" align=left></td>");
foreach (string str in result.HitsPerStn.Split(';'))
{
if (str.Length > 0)
{
string[] resparts = str.Split('/');
int temp = int.Parse(resparts[0]) +
int.Parse(resparts[1]);
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>" +
temp.ToString() + "</td>");
}
}
}
else
{
html.Append(" align=left></td>");
foreach (string str in result.HitsPerStn.Split(';'))
{
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>" + str + "</td>");
}
}
html.Append("<td");
if (place % 2 == 0)
{
html.Append(" class=\"resultevenline\"");
}
else
{
html.Append(" class=\"resultoddline\"");
}
html.Append(" align=right>");
if (result.FinalShootingPlace < 100 &
result.FinalShootingPlace > 0)
{
html.Append("( " + result.FinalShootingPlace.ToString() +
" )");
}
html.Append("</td>");
break;
case "Points":
if (useWidth)
{
html.Append(this.colPointsWidth.ToString() + "%");
}
html.Append(" align=center>" + result.Points);
break;
case "ResultTot":
if (useWidth)
{
html.Append(this.colResultTotWidth.ToString() + "%");
}
if (myInterface.GetCompetitions()[0].NorwegianCount)
{
html.Append(" align=center>" +
(result.Hits + result.FigureHits).ToString());
}
else
{
html.Append(" align=center>" +
result.Hits.ToString() + "/" +
result.FigureHits.ToString());
}
break;
case "StdMed":
if (useWidth)
{
html.Append(this.colStdMedWidth.ToString() + "%");
}
html.Append(" align=center>");
switch (result.Medal)
{
case (int)Structs.Medal.StandardSilver:
html.Append("S");
break;
case (int)Structs.Medal.StardardBrons:
html.Append("B");
break;
}
break;
case "PriceMoney":
if (finalResults)
{
html.Append(" align=right>");
if (result.PriceMoney > 0)
{
html.Append(result.PriceMoney.ToString() + ":-");
}
}
else
{
html.Append(">");
}
break;
}
if (columnName != "Result")
{
html.Append("</td>");
}
}
html.Append("</tr>");
}
html.Append("</table></p>");
return(html.ToString());
}
private List <ResultsReturn> markMedals(List <ResultsReturn> results)
{
int i = 0;
Structs.Competition competition = myInterface.CompetitionCurrent;
switch (competition.Type)
{
case Structs.CompetitionTypeEnum.Field:
{
if (useNorwegianCount)
{
foreach (ResultsReturn row in results)
{
i++;
if (row.NorwegianPoints >= standardSilverMedal)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.NorwegianPoints >= standardBronsMedal)
{
row.Medal = Structs.Medal.StardardBrons;
}
else
{
row.Medal = Structs.Medal.None;
}
}
}
else
{
foreach (ResultsReturn row in results)
{
i++;
if (row.HitsTotal >= standardSilverMedal)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= standardBronsMedal)
{
row.Medal = Structs.Medal.StardardBrons;
}
else
{
row.Medal = Structs.Medal.None;
}
}
}
break;
}
case Structs.CompetitionTypeEnum.MagnumField:
{
foreach (ResultsReturn row in results)
{
i++;
if (row.HitsTotal >= standardSilverMedal)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= standardBronsMedal)
{
row.Medal = Structs.Medal.StardardBrons;
}
else
{
row.Medal = Structs.Medal.None;
}
}
break;
}
case Structs.CompetitionTypeEnum.Precision:
{
int series = myInterface.GetStationsCount();
foreach (ResultsReturn row in results)
{
i++;
if (row.HitsTotal >= standardSilverMedal)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= standardBronsMedal)
{
row.Medal = Structs.Medal.StardardBrons;
}
else
{
row.Medal = Structs.Medal.None;
}
Structs.Competitor competitor = myInterface.GetCompetitor(row.CompetitorId);
Structs.Weapon weapon = myInterface.GetWeapon(competitor.WeaponId);
Structs.ResultWeaponsClass wclass =
CConvert.ConvertWeaponsClassToResultClass(
weapon.WClass, competition.Type);
switch (series)
{
case 6:
{
switch (wclass)
{
case Structs.ResultWeaponsClass.A:
{
if (row.HitsTotal >= 277)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 267 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.B:
{
if (row.HitsTotal >= 282)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 273 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.C:
{
if (row.HitsTotal >= 283)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 276 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
}
break;
}
case 7:
{
switch (wclass)
{
case Structs.ResultWeaponsClass.A:
{
if (row.HitsTotal >= 323)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 312 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.B:
{
if (row.HitsTotal >= 329)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 319 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.C:
{
if (row.HitsTotal >= 330)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 322 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
}
break;
}
case 10:
{
switch (wclass)
{
case Structs.ResultWeaponsClass.A:
{
if (row.HitsTotal >= 461)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 445 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.B:
{
if (row.HitsTotal >= 470)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 455 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
case Structs.ResultWeaponsClass.C:
{
if (row.HitsTotal >= 471)
{
row.Medal = Structs.Medal.StandardSilver;
}
else if (row.HitsTotal >= 460 & row.Medal != Structs.Medal.StandardSilver)
{
row.Medal = Structs.Medal.StardardBrons;
}
break;
}
}
break;
}
}
}
break;
}
default:
throw new ApplicationException("Unknown competition type");
}
return(results);
}
private List <ResultsReturn> getAllCompetitors(Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass, bool standardMedalsCalculation)
{
List <ResultsReturn> results = new List <ResultsReturn>();
Structs.Competition competition = myInterface.CompetitionCurrent;
Hashtable shooters = new Hashtable();
Hashtable weapons = new Hashtable();
string selectString = "";
string standardClass = "ShooterClass=" + ((int)Structs.ShootersClass.Klass1).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Klass2).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Klass3).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Öppen).ToString();
string damClass = "ShooterClass=" + ((int)Structs.ShootersClass.Damklass1).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Damklass2).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.Damklass3).ToString();
string extraClasses = "ShooterClass=" + ((int)Structs.ShootersClass.Juniorklass).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassYngre).ToString() +
" or ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassÄldre).ToString();
if (standardMedalsCalculation)
{
if (wclass == Structs.ResultWeaponsClass.C &&
(competition.Championship == Structs.CompetitionChampionshipEnum.SM |
competition.Championship == Structs.CompetitionChampionshipEnum.Landsdel))
{
switch (uclass)
{
case Structs.ShootersClass.Klass:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass1:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass2:
selectString = standardClass;
break;
case Structs.ShootersClass.Klass3:
selectString = standardClass;
break;
case Structs.ShootersClass.Öppen:
selectString = "ShooterClass=" + ((int)uclass).ToString();
break;
case Structs.ShootersClass.Damklass:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass1:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass2:
selectString = damClass;
break;
case Structs.ShootersClass.Damklass3:
selectString = damClass;
break;
case Structs.ShootersClass.Juniorklass:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.Juniorklass).ToString();
break;
case Structs.ShootersClass.VeteranklassYngre:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassYngre).ToString();
break;
case Structs.ShootersClass.VeteranklassÄldre:
selectString = "ShooterClass=" + ((int)Structs.ShootersClass.VeteranklassÄldre).ToString();
break;
default:
throw new NotImplementedException("uclass: " + uclass.ToString());
}
}
else
{
selectString = ""; // Everyone in one calculation
}
}
else
{
// Fetch the shooters
switch (uclass)
{
case Structs.ShootersClass.Damklass:
selectString = damClass;
break;
case Structs.ShootersClass.Klass:
selectString = standardClass;
break;
case Structs.ShootersClass.Okänd:
selectString = "";
break;
default:
selectString = "ShooterClass=" + ((int)uclass).ToString();
break;
}
}
foreach (DatabaseDataset.CompetitorsRow row in database.Competitors.Select(selectString))
{
// What shootersclass is current user?
#if DEBUG
Structs.ShootersClass currentUclass =
(Structs.ShootersClass)row.ShooterClass; // TODO Remove
#endif
// Setup a cache for weapons.
Structs.Weapon weapon;
if (weapons.ContainsKey(row.WeaponId))
{
weapon = (Structs.Weapon)weapons[row.WeaponId];
}
else
{
weapon = myInterface.GetWeapon(row.WeaponId);
weapons.Add(row.WeaponId, weapon);
}
// For each competitor, find the result (competitorresults)
// and add together
/*if ( (myInterface.ConvertWeaponsClassToResultClass(
* weapon.WClass) == wclass |
* wclass == Structs.ResultWeaponsClass.Unknown)
* &
* ( uclass == currentUclass | uclass == Structs.ShootersClass.Okänd))*/
if (myInterface.ConvertWeaponsClassToResultClass(
weapon.WClass) == wclass |
wclass == Structs.ResultWeaponsClass.Unknown)
{
ResultsReturn thisResult = ResultsGetCompetitor(row.CompetitorId);
if (thisResult.HitsTotal > 0)
{
results.Add(thisResult);
}
}
}
return(results);
}
internal Structs.ShootersClass[] ResultsGetUClasses(
Structs.ResultWeaponsClass wclass)
{
Trace.WriteLine("CResult.ResultsGetUClasses(\"" +
wclass.ToString() + "\") " +
"started on thread \"" +
System.Threading.Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
DateTime start = DateTime.Now;
database = myInterface.databaseClass.Database;
List <int> sClassesIntTable = new List <int>();
List <Structs.ShootersClass> shooterClasses = new List <Structs.ShootersClass>();
foreach (DatabaseDataset.CompetitorsRow row in
database.Competitors)
{
Structs.Weapon weapon = myInterface.GetWeapon(row.WeaponId);
if (myInterface.ConvertWeaponsClassToResultClass(weapon.WClass) ==
wclass)
{
if (row.GetChildRows("CompetitorsCompetitorResults").Length > 0)
{
if (!sClassesIntTable.Contains(row.ShooterClass))
{
sClassesIntTable.Add(row.ShooterClass);
Structs.ShootersClass uclass =
(Structs.ShootersClass)row.ShooterClass;
shooterClasses.Add(uclass);
}
}
}
}
if (myInterface.CompetitionCurrent.OneClass)
{
if (shooterClasses.Contains(Structs.ShootersClass.Klass1) ||
shooterClasses.Contains(Structs.ShootersClass.Klass2) ||
shooterClasses.Contains(Structs.ShootersClass.Klass3))
{
shooterClasses.Add(Structs.ShootersClass.Klass);
shooterClasses.Remove(Structs.ShootersClass.Klass1);
shooterClasses.Remove(Structs.ShootersClass.Klass2);
shooterClasses.Remove(Structs.ShootersClass.Klass3);
}
if (shooterClasses.Contains(Structs.ShootersClass.Damklass1) ||
shooterClasses.Contains(Structs.ShootersClass.Damklass2) ||
shooterClasses.Contains(Structs.ShootersClass.Damklass3))
{
shooterClasses.Add(Structs.ShootersClass.Damklass);
shooterClasses.Remove(Structs.ShootersClass.Damklass1);
shooterClasses.Remove(Structs.ShootersClass.Damklass2);
shooterClasses.Remove(Structs.ShootersClass.Damklass3);
}
}
/*for(int i=0 ; i<=Structs.ShootersClassMax ; i++)
* {
* try
* {
* if (sClassesIntTable.Contains(i))
* {
* int.Parse(((Structs.ShootersClass)i).ToString());
* }
* }
* catch(System.FormatException)
* {
* // Ok, we got a class
* Structs.ShootersClass uclass =
* (Structs.ShootersClass)i;
* shooterClasses.Add(uclass);
* }
* }*/
shooterClasses.Sort();
Trace.WriteLine("CResult.ResultsGetUClasses(\"" +
wclass.ToString() + "\") " +
"ending after " +
(DateTime.Now - start).TotalMilliseconds.ToString() +
" ms.");
return(shooterClasses.ToArray());
}
private DSResults getAllTeams(Structs.ResultWeaponsClass wclass)
{
DSResults results = new DSResults();
// Add columns for each station (used later for sorting)
int stationCount = myInterface.GetStationsCount();
for (int stationNr = 1; stationNr <= stationCount; stationNr++)
{
results.TeamResults.Columns.Add("Station" + stationNr.ToString(), typeof(int));
}
if (myInterface.CompetitionCurrent.Type == Structs.CompetitionTypeEnum.Precision)
{
for (int stationNr = myInterface.GetStationsCount(); stationNr >= 1; stationNr--)
{
for (int i = 10; i > 0; i--)
{
results.TeamResults.Columns.Add("Station" + stationNr.ToString() + "-" + i.ToString(), typeof(int));
}
}
}
foreach (DatabaseDataset.TeamsRow teamrow in database.Teams)
{
if (teamrow.WClass == (int)wclass)
{
ArrayList comps = new ArrayList();
if (!teamrow.IsCompetitorId1Null())
{
comps.Add((DatabaseDataset.CompetitorsRow)
database.Competitors.Select("CompetitorId=" + teamrow.CompetitorId1.ToString())[0]);
}
if (!teamrow.IsCompetitorId2Null())
{
comps.Add((DatabaseDataset.CompetitorsRow)
database.Competitors.Select("CompetitorId=" + teamrow.CompetitorId2.ToString())[0]);
}
if (!teamrow.IsCompetitorId3Null())
{
comps.Add((DatabaseDataset.CompetitorsRow)
database.Competitors.Select("CompetitorId=" + teamrow.CompetitorId3.ToString())[0]);
}
if (!teamrow.IsCompetitorId4Null())
{
comps.Add((DatabaseDataset.CompetitorsRow)
database.Competitors.Select("CompetitorId=" + teamrow.CompetitorId4.ToString())[0]);
}
if (!teamrow.IsCompetitorId5Null())
{
comps.Add((DatabaseDataset.CompetitorsRow)
database.Competitors.Select("CompetitorId=" + teamrow.CompetitorId5.ToString())[0]);
}
Hashtable teamHits = new Hashtable();
Hashtable teamFigureHits = new Hashtable();
Hashtable teamCountNrOfTens = new Hashtable();
int totPoints = 0;
foreach (DatabaseDataset.CompetitorsRow compsRow in
(DatabaseDataset.CompetitorsRow[])
comps.ToArray(typeof(DatabaseDataset.CompetitorsRow)))
{
foreach (DatabaseDataset.CompetitorResultsRow compresrow in
(DatabaseDataset.CompetitorResultsRow[])
compsRow.GetChildRows("CompetitorsCompetitorResults"))
{
DatabaseDataset.StationsRow stationsRow =
(DatabaseDataset.StationsRow)database.Stations.Select("StationId=" + compresrow.StationId.ToString())[0];
int teamHitsThisStn = 0;
if (teamHits.ContainsKey(stationsRow.StationNr))
{
teamHitsThisStn = (int)teamHits[stationsRow.StationNr];
}
int teamFigureHitsThisStn = 0;
if (teamFigureHits.ContainsKey(stationsRow.StationNr))
{
teamFigureHitsThisStn = (int)teamFigureHits[stationsRow.StationNr];
}
teamHitsThisStn += compresrow.Hits;
teamFigureHitsThisStn += compresrow.FigureHits;
totPoints += compresrow.Points;
teamHits[stationsRow.StationNr] = teamHitsThisStn;
teamFigureHits[stationsRow.StationNr] = teamFigureHitsThisStn;
if (CompetitionType == Structs.CompetitionTypeEnum.Precision)
{
foreach (string strn in compresrow.StationFigureHits.Split(';'))
{
if (strn != "" && int.Parse(strn) != 0)
{
string columnName = "Station" + stationsRow.StationNr.ToString() + "-" +
strn;
int thisValue = 0;
if (teamCountNrOfTens.ContainsKey(columnName))
{
thisValue = (int)teamCountNrOfTens[columnName];
}
thisValue++;
teamCountNrOfTens[columnName] = thisValue;
}
}
}
}
}
int totFigureHits = 0;
int totHits = 0;
string stnHits = "";
DSResults.TeamResultsRow newTeamRow =
results.TeamResults.NewTeamResultsRow();
if (myInterface.GetCompetitions()[0].Type == Structs.CompetitionTypeEnum.Precision)
{
for (int stationNr = myInterface.GetStationsCount(); stationNr >= 1; stationNr--)
{
for (int i = 10; i > 0; i--)
{
newTeamRow["Station" + stationNr.ToString() + "-" + i.ToString()] = 0;
}
}
}
for (int stationNr = 1; stationNr <= stationCount; stationNr++)
{
int hitsThisStn = 0;
int figureHitsThisStn = 0;
if (teamHits.ContainsKey(stationNr))
{
hitsThisStn = (int)teamHits[stationNr];
}
if (teamFigureHits.ContainsKey(stationNr))
{
figureHitsThisStn = (int)teamFigureHits[stationNr];
}
totHits += hitsThisStn;
totFigureHits += figureHitsThisStn;
switch (CompetitionType)
{
case Structs.CompetitionTypeEnum.Field:
{
if (this.useNorwegianCount)
{
stnHits += (hitsThisStn + figureHitsThisStn).ToString() + ";";
newTeamRow["Station" + stationNr.ToString()] = hitsThisStn + figureHitsThisStn;
}
else
{
stnHits += hitsThisStn.ToString() + "/" + figureHitsThisStn.ToString() + ";";
newTeamRow["Station" + stationNr.ToString()] = hitsThisStn;
}
break;
}
case Structs.CompetitionTypeEnum.Precision:
{
stnHits += hitsThisStn.ToString() + ";";
newTeamRow["Station" + stationNr.ToString()] = hitsThisStn;
for (int i = 10; i >= 1; i--)
{
string columnName = "Station" + stationNr.ToString() + "-" +
i.ToString();
if (teamCountNrOfTens.ContainsKey(columnName))
{
newTeamRow[columnName] = (int)teamCountNrOfTens[columnName];
}
else
{
newTeamRow[columnName] = 0;
}
}
break;
}
}
}
newTeamRow.ClubId = teamrow.ClubId;
newTeamRow.FigureHits = totFigureHits;
newTeamRow.Hits = totHits;
newTeamRow.NorwPoints = totFigureHits + totHits;
newTeamRow.Points = totPoints;
newTeamRow.TeamId = teamrow.TeamId;
newTeamRow.TeamName = teamrow.Name;
newTeamRow.HitsPerStn = stnHits;
results.TeamResults.AddTeamResultsRow(newTeamRow);
}
}
return(results);
}
private void updateDdUClassesWithThread()
{
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() " +
"started on thread " +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
try
{
if (UpdateDdUClassesInThreadsCount > 0)
{
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() " +
" already has threads waiting");
return;
}
Interlocked.Increment(ref UpdateDdUClassesInThreadsCount);
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() locking \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (lockObject)
{
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() " +
"locked \"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Structs.ResultWeaponsClass wclass = this.getCurrentWeaponClass();
Structs.ShootersClass[] uclasses =
CommonCode.ResultsGetUClasses(wclass);
tableUClasses = new DataTable();
DataColumn colUName1 = new DataColumn("Name", typeof(string));
tableUClasses.Columns.Add(colUName1);
DataColumn colUId1 = new DataColumn("Id", typeof(int));
tableUClasses.Columns.Add(colUId1);
foreach (Structs.ShootersClass uclass in uclasses)
{
tableUClasses.Rows.Add(
new object[] {
uclass.ToString(),
(int)uclass
});
}
if (this.InvokeRequired)
{
this.Invoke(BindDDUClasses);
}
else
{
BindDDUClasses();
}
}
}
catch (Exception exc)
{
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() " +
"Exception: \r\n" + exc.ToString());
}
finally
{
Interlocked.Decrement(ref UpdateDdUClassesInThreadsCount);
Trace.WriteLine("FResultsView.updateDdUClassesWithThread() ended");
}
}
private void updateDatasetwithThread()
{
try
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() " +
"started on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
if (populateDatasetwithThreadsCount > 0)
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() " +
" already has threads waiting");
return;
}
Interlocked.Increment(ref populateDatasetwithThreadsCount);
Trace.WriteLine("FResultsView.populateDatasetwithThread() locking \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (lockObject)
{
Trace.WriteLine("FResultsView.populateDatasetwithThread() locked \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Thread.Sleep(100);
DateTime start = DateTime.Now;
if (CommonCode.GetCompetitions().Length == 0)
{
return;
}
this.datasetResults1 = new DatasetResults();
this.datasetResults1.DataSetName = "DatasetResults";
this.datasetResults1.Locale =
new System.Globalization.CultureInfo("sv");
Structs.ResultWeaponsClass wclass = getCurrentWeaponClass();
Structs.ShootersClass uclass = getCurrentShootersClass();
if (uclass == Structs.ShootersClass.Okänd)
{
return;
}
ResultsReturn[] results = CommonCode.ResultsGet(wclass,
uclass,
CommonCode.GetCompetitions()[0],
false);
datasetResults1 = new Allberg.Shooter.Windows.DatasetResults();
int i = 1;
bool useNorwegian = CommonCode.GetCompetitions()[0].NorwegianCount;
Hashtable clubs = new Hashtable();
foreach (ResultsReturn result in results)
{
DatasetResults.ResultsRow newRow =
this.datasetResults1.Results.NewResultsRow();
newRow.Place = i;
if (clubs.ContainsKey(result.ClubId))
{
newRow.Club = (string)clubs[result.ClubId];
}
else
{
string clubName = getClubName(result.ClubId);
newRow.Club = clubName;
clubs.Add(result.ClubId, clubName);
}
switch ((Structs.Medal)result.Medal)
{
case Structs.Medal.StandardSilver:
newRow.Medal = "S";
break;
case Structs.Medal.StardardBrons:
newRow.Medal = "B";
break;
default:
newRow.Medal = "";
break;
}
newRow.Points = result.PointsTotal;
newRow.ShooterName = result.ShooterName;
switch (CommonCode.GetCompetitions()[0].Type)
{
case Structs.CompetitionTypeEnum.Field:
{
if (useNorwegian)
{
newRow.Hits = (result.HitsTotal + result.FigureHitsTotal).ToString();
newRow.HitsPerStation = "";
foreach (string str in result.HitsPerStnString.Split(';'))
{
if (str != "")
{
newRow.HitsPerStation += str + " ";
}
}
newRow.HitsPerStation = newRow.HitsPerStation.TrimEnd();
}
else
{
newRow.Hits = result.HitsTotal.ToString() + " / " +
result.FigureHitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
}
break;
}
case Structs.CompetitionTypeEnum.MagnumField:
{
newRow.Hits = result.HitsTotal.ToString() + " / " +
result.FigureHitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
break;
}
case Structs.CompetitionTypeEnum.Precision:
{
newRow.Hits = result.HitsTotal.ToString();
newRow.HitsPerStation =
result.HitsPerStnString.Replace(";", " ");
break;
}
default:
throw new ApplicationException("Unknown CompetitionType");
}
if (result.FinalShootingPlace != 100)
{
newRow.HitsPerStation += " (" + result.FinalShootingPlace.ToString() + ")";
}
this.datasetResults1.Results.AddResultsRow(newRow);
i++;
}
if (this.InvokeRequired)
{
this.Invoke(DatasetBindToDataGrid);
}
else
{
DatasetBindToDataGrid();
}
Trace.WriteLine("FResultsView.populateDatasetwithThread took " +
(DateTime.Now - start).TotalMilliseconds.ToString() +
" ms.");
}
Trace.WriteLine("FResultsView.populateDatasetwithThread() unlocking \"" +
"lockObject\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
Thread.CurrentThread.ManagedThreadId.ToString() + " )");
}
finally
{
Interlocked.Decrement(ref populateDatasetwithThreadsCount);
Trace.WriteLine("FResultsView.populateDatasetwithThread() ended");
}
}
internal ResultsReturn[] GetResults(
Structs.ResultWeaponsClass wclass,
Structs.ShootersClass uclass,
Structs.Competition competition,
bool finalResults)
{
Trace.WriteLine("CResults.GetResults(" + wclass.ToString()
+ ", " + uclass.ToString() +
") started on thread \"" +
System.Threading.Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
while (resultsAlreadyRunning)
{
System.Threading.Thread.Sleep(50);
}
Trace.WriteLine("CResults: GetResults() " +
" locking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
lock (GetResultsLock)
{
Trace.WriteLine("CResults: GetResults() " +
" locked \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
try
{
resultsAlreadyRunning = true;
database = myInterface.databaseClass.Database;
useNorwegianCount = competition.NorwegianCount;
// First find out about the standard medals
calculateStandardMedals(wclass, uclass);
// Ok, now lets count the real ones
if (competition.OneClass)
{
switch (uclass)
{
case Structs.ShootersClass.Damklass:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass1:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass2:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Damklass3:
uclass = Structs.ShootersClass.Damklass;
break;
case Structs.ShootersClass.Juniorklass:
break;
case Structs.ShootersClass.Klass:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass1:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass2:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.Klass3:
uclass = Structs.ShootersClass.Klass;
break;
case Structs.ShootersClass.VeteranklassYngre:
break;
case Structs.ShootersClass.VeteranklassÄldre:
break;
case Structs.ShootersClass.Öppen:
break;
default:
throw new NotSupportedException("Structs.ShootersClass." +
uclass.ToString() + " is not supported");
}
}
List <ResultsReturn> results = getAllCompetitors(wclass, uclass, false);
results.Sort();
if (myInterface.CompetitionCurrent.Championship !=
Structs.CompetitionChampionshipEnum.Club)
{
results = markMedals(results);
}
else
{
// Mark all as not having medals
foreach (ResultsReturn row in results)
{
row.Medal = Structs.Medal.None;
}
}
if (finalResults)
{
results = markPriceMoney(results);
}
return(results.ToArray());
}
finally
{
Trace.WriteLine("CResults: GetResults() " +
" unlocking \"GetResultsLock\" on thread \"" +
Thread.CurrentThread.Name + "\" ( " +
System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + " )");
Trace.WriteLine("CResults.GetResults ended.");
resultsAlreadyRunning = false;
}
}
}
internal Structs.ShootersClass[] ResultsGetUClasses(
Structs.ResultWeaponsClass wclass)
{
return(result.ResultsGetUClasses(wclass));
}
