/*
* ################################################################################
*/
private static String getXmlFrage(clsFrage pFrage)
{
String xml_string = "";
xml_string += getStartTag(XML_TAG_FRAGE);
if (pFrage != null)
{
xml_string += getTag(XML_TAG_ID, pFrage.getId());
xml_string += getTag(XML_TAG_NUMMER, pFrage.getNummer());
xml_string += getTag(XML_TAG_GELTUNGSBEREICH, pFrage.getGeltungsbereich());
xml_string += getTag(XML_TAG_TEXT_1, pFrage.getText1());
xml_string += getTag(XML_TAG_TEXT_2, pFrage.getText2());
xml_string += getTag(XML_TAG_BEMERKUNG, pFrage.getBemerkung());
xml_string += getTag(XML_TAG_BILD_1, pFrage.getBild1());
xml_string += getTag(XML_TAG_BILD_2, pFrage.getBild2());
xml_string += getTag(XML_TAG_BILD_3, pFrage.getBild3());
xml_string += getTag(XML_TAG_BILD_4, pFrage.getBild4());
xml_string += getXmlAntwort(pFrage.getAntwortA());
xml_string += getXmlAntwort(pFrage.getAntwortB());
xml_string += getXmlAntwort(pFrage.getAntwortC());
xml_string += getXmlAntwort(pFrage.getAntwortD());
xml_string += getXmlAntwort(pFrage.getAntwortE());
xml_string += getXmlAntwort(pFrage.getAntwortF());
xml_string += getXmlAntwort(pFrage.getAntwortG());
xml_string += getXmlAntwort(pFrage.getAntwortH());
}
xml_string += getEndTag(XML_TAG_FRAGE);
return(xml_string);
}
/*
* ################################################################################
*/
private static bool exportXmlLernFabrik(clsFragenKatalog pFragenKatalog, clsLernFrabrik pLernFrabrik, int pExportModus, String pDateiName)
{
clsFrage temp_frage = null;
String string_datei_inhalt = "";
string_datei_inhalt += "<?xml version=\"1.0\" encoding=\"iso-8859-1\" ?>\n";
string_datei_inhalt += getStartTag(XML_TAG_FRAGENKATALOG);
string_datei_inhalt += getTag(XML_TAG_FRAGENKATALOG_BEZEICHNUNG, "unbenannt");
string_datei_inhalt += getTag(XML_TAG_FRAGENKATALOG_DATUM_ERSTELLUNG, DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss"));
bool fkt_ergebnis = true;
int index_fragen_katalog = 0;
int index_lern_fabrik = 0;
while ((index_lern_fabrik < pLernFrabrik.getAnzahlFragen()))
{
if (pExportModus == fkExportFrageBogen.EXPORT_LERN_FABRIK_KORREKT)
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndexKorrekt(index_lern_fabrik);
}
else if (pExportModus == fkExportFrageBogen.EXPORT_LERN_FABRIK_FALSCH)
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndexFalsch(index_lern_fabrik);
}
else
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndex(index_lern_fabrik);
}
if (index_fragen_katalog >= 0)
{
try
{
temp_frage = pFragenKatalog.getIndex(index_fragen_katalog);
if (temp_frage != null)
{
string_datei_inhalt += getXmlFrage(temp_frage);
}
}
catch (Exception err_inst)
{
Console.WriteLine("Fehler: exportXmlLernFabrik\n" + err_inst.Message + "\n\n" + err_inst.StackTrace);
}
}
index_lern_fabrik = index_lern_fabrik + 1;
}
string_datei_inhalt += getEndTag(XML_TAG_FRAGENKATALOG);
System.IO.File.WriteAllText(pDateiName, string_datei_inhalt);
return(fkt_ergebnis);
}
/**
* <pre>
* Parst eine Instanz der Klasse "clsFrage".
*
* Ist der Parameter "pRootFrage" gleich null, wird null zurueckgegeben.
*
* </pre>
*
* @param pRootFrage XML-Rootelement mit den zu parsenden Daten
* @return eine Instanz mit den geparsten Daten, oder null im Fehlefall
*/
private clsFrage parseClsFrage(String pRootFrage)
{
/*
* Pruefung: Parameter "pBeanRootFrage" gesetzt?
*/
if (pRootFrage == null)
{
return(null);
}
else if (pRootFrage != "")
{
/*
* Ist der Parameter "pRootFrage" gesetzt, wird
* eine neue Instanz der Klasse "clsFrage" erstellt.
*/
clsFrage inst_frage = new clsFrage();
/*
* Die XML-Daten werden in die neue Instanz uebertragen
*/
inst_frage.setId(getTagString(pRootFrage, XML_TAG_ID, -1));
inst_frage.setNummer(getTagString(pRootFrage, XML_TAG_NUMMER, -1));
inst_frage.setGeltungsbereich(getTagString(pRootFrage, XML_TAG_GELTUNGSBEREICH, -1));
inst_frage.setText1(getTagString(pRootFrage, XML_TAG_TEXT_1, -1));
inst_frage.setText2(getTagString(pRootFrage, XML_TAG_TEXT_2, -1));
inst_frage.setBemerkung(getTagString(pRootFrage, XML_TAG_BEMERKUNG, -1));
inst_frage.setBild1(getTagString(pRootFrage, XML_TAG_BILD_1, -1));
inst_frage.setBild2(getTagString(pRootFrage, XML_TAG_BILD_2, -1));
inst_frage.setBild3(getTagString(pRootFrage, XML_TAG_BILD_3, -1));
inst_frage.setBild4(getTagString(pRootFrage, XML_TAG_BILD_4, -1));
/*
* Hier werden nun die Antworten zu der Frage hinzugefuegt.
* Es wurde auf eine Plausipruefung verzichtet, welche sicherstellt, das Antwort
* A auch Antwort A ist. Es werden 8 Antworten gelesen.
*/
inst_frage.setAntwortA(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 1)));
inst_frage.setAntwortB(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 2)));
inst_frage.setAntwortC(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 3)));
inst_frage.setAntwortD(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 4)));
inst_frage.setAntwortE(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 5)));
inst_frage.setAntwortF(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 6)));
inst_frage.setAntwortG(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 7)));
inst_frage.setAntwortH(parseClsAntwort(getTagString(pRootFrage, XML_TAG_ANTWORT, 8)));
/*
* Die erstellte Ergebnisinstanz "clsFrage" als Funktionsergebnis setzen
*/
return(inst_frage);
}
return(null);
}
/**
* Versucht die Instanz aus dem Parameter dem Vektor hinzuzufuegen.
*
* Ist die Parameter-Instanz "null" wird nichts hinzugefuegt und FALSE zurueckgegeben.
*
* @param pClsFrage die hinzuzufuegende Instan
*
* @return TRUE wenn die Instanz dem Vektor hinzugefuegt werden konnte, sonst FALSE
*/
public bool addFrage(clsFrage pClsFrage)
{
/*
* Pruefung: Parameterinstanz ungleich "null" ?
*/
if (pClsFrage != null)
{
try
{
/*
* Ist die Parameterinstanz vorhanden, wird diese dem Vektor hinzugefuegt.
*/
getVektor().Add(pClsFrage);
/*
* Bei der Frageninstanz wird die laufende Nummer gesetzt.
*
* Die Nummer ist in diesem Fall, der Index der hinzugefuegten Frage.
*
* Das ist gleichzeitig auch die Gesamtanzahl der Fragen.
*/
pClsFrage.setLfdNummer("" + getAnzahlFragen());
/*
* Der Aufrufder bekommt TRUE zurueck
*/
return(true);
}
catch (Exception err_inst)
{
System.Console.WriteLine("Fehler: errAddFrage " + err_inst.Message);
}
}
/*
* Vorgaberueckgabe ist FALSE (Fehler oder Parameterinstanz nicht gesetzt)
*/
return(false);
}
/*
* ################################################################################
*/
private static String getKorrektStringFrageX(clsFrage pFrage)
{
String str_korrekte_antworten = "";
String str_fragen_nummer = "";
if (pFrage == null)
{
str_fragen_nummer = "";
str_korrekte_antworten = "";
}
else
{
str_fragen_nummer = (knz_use_lfd_nr ? pFrage.getLfdNummer() : pFrage.getNummer());
str_korrekte_antworten = "";
if (pFrage.getAntwortAKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_a;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortBKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_b;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortCKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_c;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortDKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_d;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortEKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_e;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortFKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_f;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortGKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_g;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
if (pFrage.getAntwortHKorrekt())
{
str_korrekte_antworten = str_korrekte_antworten + m_loesungsbogen_antwort_h;
}
else
{
str_korrekte_antworten = str_korrekte_antworten + " ";
}
}
if (m_knz_loesungsbogen_version_1)
{
str_korrekte_antworten = str_korrekte_antworten.Trim();
}
return(getStringRight(str_fragen_nummer, ANZ_STELLEN_FRAGENNR) + STR_TRENN_STRING + getStringLeft(str_korrekte_antworten, m_max_anzahl_vorhandene_antworten));
}
/*
* ################################################################################
*/
private static String getFrageExportString(clsFrage pFrage, String pNewLineZeichen, bool pKnzExportiereAntworten, bool pKnzExportiereKorrekteAntworten, bool pKnzExportiereFalscheAntworten, bool pKnzExportiereAntwortBezeichnung, bool pKnzAntwortReihenfolgeUmstellen)
{
bool pKnzMarkiereAntwortKorrekt = true;
String frage_export_string = "";
int max_anzahl_spalten = 0;
String antwort_bezeichnung = null;
max_anzahl_spalten = 75;
/*
* Pruefung: Ist die Eingabe "null" ?
*
* Ist die Eingabe "null" ist das Ergebnis ein Leerstring.
*/
if (pFrage == null)
{
frage_export_string = "";
}
else
{
/*
* Aufbereitung Fragenexport
*
* Zuerst kommen 2 New-Line Zeichen fuer den Abstand
*/
frage_export_string += pNewLineZeichen + pNewLineZeichen;
/*
* Fragen-Nummer mit der Breite fuer die Frangennummer.
*/
frage_export_string += getStringRight((knz_use_lfd_nr ? pFrage.getLfdNummer() : pFrage.getNummer()), ANZ_STELLEN_FRAGENNR);
/*
* Abstand zwischen Frage-Nummer und dem Fragentext
*/
frage_export_string += ABSTAND_FNR_FRAGE;
/*
* Der Fragentext als Block formatiert mit dem abschliessendem New-Line-Zeichen
*/
frage_export_string += fkString.getStringMaxCols(pFrage.getText1(), max_anzahl_spalten, m_einzug_frage, pNewLineZeichen) + pNewLineZeichen;
/*
* Auswertung: Antwortreihenfolge-Umstellung
*
* Soll die Antwortreihenfolge umgestellt werden, wird an der Frage die Funktion
* fuer die Umstellung der Antwortreihenfolge aufgerufen.
*
* Soll die Antwortreihenfolge nicht umgestellt werden, wird an der Frage
* die Funktion fuer den Reset der Antwortreihenfolge aufgerufen.
*/
if (pKnzAntwortReihenfolgeUmstellen)
{
pFrage.startAntwortReihenfolgeUmstellen();
}
else
{
pFrage.resetAntwortIndexPosition();
}
/*
* Export der Antworten:
* 1. Kennzeichenermittlung, ob die Antwort aktiv ist
* 2. Kennzeichenermittlung, ob die Antwort exportiert werden soll
* 3. Start des Exportes der Antworten
*
* Ermittlung Kennzeichen Antwort aktiv
*
* Eine Antwort an einer UI-Position ist aktiv, wenn:
*
* - eine Antwort an der UI-Position vorhanden ist
* (mit gleichzeitiger Pruefung, ob diese Antwort auch "Aktiv" ist.)
*
* - Antworten exportiert werden sollen
*/
bool knz_antwort_1_aktiv = pFrage.hasUiPositionAntwort1() && pKnzExportiereAntworten;
bool knz_antwort_2_aktiv = pFrage.hasUiPositionAntwort2() && pKnzExportiereAntworten;
bool knz_antwort_3_aktiv = pFrage.hasUiPositionAntwort3() && pKnzExportiereAntworten;
bool knz_antwort_4_aktiv = pFrage.hasUiPositionAntwort4() && pKnzExportiereAntworten;
bool knz_antwort_5_aktiv = pFrage.hasUiPositionAntwort5() && pKnzExportiereAntworten;
bool knz_antwort_6_aktiv = pFrage.hasUiPositionAntwort6() && pKnzExportiereAntworten;
bool knz_antwort_7_aktiv = pFrage.hasUiPositionAntwort7() && pKnzExportiereAntworten;
bool knz_antwort_8_aktiv = pFrage.hasUiPositionAntwort8() && pKnzExportiereAntworten;
/*
* Ermittlung Kennzeichen Antwort exportieren
*
* Eine Antwort an einer UI-Position wird exportiert, wenn:
*
* - die Antwort aktiv ist
*
* - die Antwort korrekt ist und korrekte Antworten exportiert werden sollen
*
* oder
*
* die Antwort falsch ist und falsche Antworten exportiert werden sollen
*/
bool knz_antwort_1_exportieren = knz_antwort_1_aktiv && (pFrage.getUiPositionAntwort1Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_2_exportieren = knz_antwort_2_aktiv && (pFrage.getUiPositionAntwort2Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_3_exportieren = knz_antwort_3_aktiv && (pFrage.getUiPositionAntwort3Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_4_exportieren = knz_antwort_4_aktiv && (pFrage.getUiPositionAntwort4Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_5_exportieren = knz_antwort_5_aktiv && (pFrage.getUiPositionAntwort5Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_6_exportieren = knz_antwort_6_aktiv && (pFrage.getUiPositionAntwort6Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_7_exportieren = knz_antwort_7_aktiv && (pFrage.getUiPositionAntwort7Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
bool knz_antwort_8_exportieren = knz_antwort_8_aktiv && (pFrage.getUiPositionAntwort8Korrekt() ? pKnzExportiereKorrekteAntworten : pKnzExportiereFalscheAntworten);
/*
* Erstellung der Strings fuer die Antworten
*/
if (knz_antwort_1_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort1Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort1Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort1Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_2_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort2Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort2Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort2Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_3_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort3Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort3Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort3Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_4_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort4Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort4Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort4Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_5_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort5Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort5Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort5Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_6_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort6Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort6Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort6Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_7_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort7Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort7Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort7Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (knz_antwort_8_exportieren)
{
antwort_bezeichnung = (pKnzExportiereAntwortBezeichnung ? pFrage.getUiPositionAntwort8Bez() : ALTERNATIVE_ANTWORT_BEZEICHNUNG);
frage_export_string += pNewLineZeichen + getStringRight((pFrage.getUiPositionAntwort8Korrekt() && pKnzMarkiereAntwortKorrekt ? VORGABE_KORREKT_MARKIERUNG : LEERZEICHEN) + LEERZEICHEN + antwort_bezeichnung, ANZ_STELLEN_ANTWORTBEZEICHNUNG) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getUiPositionAntwort8Text(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
if (pFrage.hasText2())
{
frage_export_string += pNewLineZeichen + getStringRight(" ", ANZ_STELLEN_FRAGENNR) + ABSTAND_FBEZ_ANTWORT + fkString.getStringMaxCols(pFrage.getText2(), max_anzahl_spalten, m_einzug_antwort, pNewLineZeichen) + pNewLineZeichen;
}
}
bool knz_set_trennzeile = true;
if (knz_set_trennzeile)
{
String str_trennzeile = "\n--------------------------------------------------------------------------------------------------------------\n";
frage_export_string += pNewLineZeichen + str_trennzeile;
}
/*
* Nach jeder exportierten Frage, wird "DoEvents" aufgerufen.
*/
//Application.DoEvents();
return(frage_export_string);
}
/*
* ################################################################################
*/
public static String getClipBoardExportString(clsFrage pFrage)
{
return(getFrageExportString(pFrage, "\n\r", true, true, true, true, true));
}
/*
* ################################################################################
*/
private static bool exportTextLernFabrik(clsFragenKatalog pFragenKatalog, clsLernFrabrik pLernFrabrik, int pExportModus, String pDateiName, bool pKnzExportiereAntworten, bool pKnzExportiereKorrekteAntworten, bool pKnzExportiereFalscheAntworten, bool pKnzExportiereAntwortBezeichnung, bool pKnzAntwortReihenfolgeUmstellen)
{
clsStringArray lb_reihenfolge = new clsStringArray();
lb_reihenfolge.addString("000000000000000000000000Dummyzeile");
clsFrage temp_frage = null;
String string_datei_inhalt = "";
string_datei_inhalt += "Export Abfrage Sitzung " + DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss") + " - " + pFragenKatalog.getDateiName() + NEW_LINE;
bool fkt_ergebnis = true;
int index_fragen_katalog = 0;
int index_lern_fabrik = 0;
/*
* While-Schleife ueber alle Fragen der Lernfabrik
*/
while (index_lern_fabrik < pLernFrabrik.getAnzahlFragen())
{
/*
* Bestimmung: Index Fragenkatalog
*
* Es gibt 3 unterschiedliche Exportarten:
* - alle korrekt beantworteten Fragen
* - alle falsch beantworteten Fragen
* - alle Fragen
*
* Je nach Exportmodus wird die entsprechende Funktion in der Lernfabrik aufgerufen,
* welche den Index der naechsten zu exportierenden Frage ermittelt.
*/
if (pExportModus == EXPORT_LERN_FABRIK_KORREKT)
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndexKorrekt(index_lern_fabrik);
}
else if (pExportModus == EXPORT_LERN_FABRIK_FALSCH)
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndexFalsch(index_lern_fabrik);
}
else
{
index_fragen_katalog = pLernFrabrik.getAbfrageIndex(index_lern_fabrik);
}
// System.Console.WriteLine( "index_fragen_katalog =>" + index_fragen_katalog + "< index_lern_fabrik =>" + index_lern_fabrik + "<" );
/*
* Pruefung: Index im Fragenkatalog vorhanden ?
*
* Der Index fuer die Frage aus dem Fragenkatalog muss groesser gleich 0 sein.
*
* Ist der Index kleiner als 0, wird nichts exportiert.
*/
if (index_fragen_katalog >= 0)
{
try
{
/*
* Aus dem Fragenkatalog wird die Frage am ermittelten Index geholt.
*/
temp_frage = pFragenKatalog.getIndex(index_fragen_katalog);
/*
* Ist eine Frage vorhanden, wird diese exportiert.
*/
if (temp_frage != null)
{
string_datei_inhalt += getFrageExportString(temp_frage, NEW_LINE, pKnzExportiereAntworten, pKnzExportiereKorrekteAntworten, pKnzExportiereFalscheAntworten, pKnzExportiereAntwortBezeichnung, pKnzAntwortReihenfolgeUmstellen);
lb_reihenfolge.addString(fkString.right("000000000000000000000" + (knz_use_lfd_nr ? temp_frage.getLfdNummer() : temp_frage.getNummer()), 20) + getKorrektStringFrageX(temp_frage));
}
}
catch (Exception err_inst)
{
Console.WriteLine("Fehler: errExportTextLernFabrik\n" + err_inst.Message + "\n\n" + err_inst.StackTrace);
}
}
/*
* Es wird der Index fuer die Lernfabrik um eins erhoeht und mit der
* naechsten Frage aus der Lernsitzung weitergemacht.
*/
index_lern_fabrik++;
}
/*
* Erstellung des Loesungsbogens
* Es wird die Funktion fuer die Erstellung des Loesungsbogens aufgerufen.
*/
bool pKnzErstelleLoesungsbogen = true;
string_datei_inhalt += getSringLoesungsbogen(pKnzErstelleLoesungsbogen, lb_reihenfolge);
/*
* Stringarray mit den Daten fuer den Loesungsbogen "clearen"
* und anschliessend auf "null" stellen.
*/
lb_reihenfolge.clear();
lb_reihenfolge = null;
/*
* Der erstellte Fragenkatalog wird in der Datei gespeichert
*/
System.IO.File.WriteAllText(pDateiName, string_datei_inhalt);
return(fkt_ergebnis);
}
/*
* ################################################################################
*/
private static bool exportTextFragenKatalog(clsFragenKatalog pFragenKatalog, String pDateiName, bool pKnzExportiereAntworten, bool pKnzExportiereKorrekteAntworten, bool pKnzExportiereFalscheAntworten, bool pKnzExportiereAntwortBezeichnung, bool pKnzAntwortReihenfolgeUmstellen)
{
clsStringArray lb_reihenfolge = new clsStringArray();
lb_reihenfolge.addString("000000000000000000000000Dummyzeile");
clsFrage temp_frage = null;
String string_datei_inhalt = "";
string_datei_inhalt += "Export Abfrage Sitzung " + DateTime.Now.ToString("dd.MM.yyyy HH:mm:ss") + " - " + pFragenKatalog.getDateiName() + NEW_LINE;
bool pKnzErstelleLoesungsbogen = true;
bool fkt_ergebnis = true;
int index_fragen_katalog = 0;
/*
* While-Schleife ueber alle Fragen im Fragenkatalog.
*/
while (index_fragen_katalog < pFragenKatalog.getAnzahlFragen())
{
try
{
/*
* Frage am aktuellem Index aus dem Fragenkatalog holen.
*/
temp_frage = pFragenKatalog.getIndex(index_fragen_katalog);
/*
* Pruefung: Frage gesetzt ?
*
* Ist an der aktuellen Indexpositon keine Frage vorhanden, ist das Ergebnis
* der Funktion "getIndes" gleich "null". In so einem Fall wird mit dem
* naechsten Index weiter gemacht.
*
* Ist eine Frage vorhanden, wird diese exportiert.
*/
if (temp_frage != null)
{
string_datei_inhalt += getFrageExportString(temp_frage, NEW_LINE, pKnzExportiereAntworten, pKnzExportiereKorrekteAntworten, pKnzExportiereFalscheAntworten, pKnzExportiereAntwortBezeichnung, pKnzAntwortReihenfolgeUmstellen);
lb_reihenfolge.addString(fkString.right("000000000000000000000" + (knz_use_lfd_nr ? temp_frage.getLfdNummer() : temp_frage.getNummer()), 20) + getKorrektStringFrageX(temp_frage));
}
}
catch (Exception err_inst)
{
Console.WriteLine("Fehler: errExportTextFragenKatalog\n" + err_inst.Message + "\n\n" + err_inst.StackTrace);
}
/*
* Index der Fragen im Fragenkatalog um eins erhoehen und mit
* der naechsten Frage weitermachen.
*/
index_fragen_katalog++;
}
/*
* Erstellung des Loesungsbogens
* Es wird die Funktion fuer die Erstellung des Loesungsbogens aufgerufen.
*/
string_datei_inhalt += getSringLoesungsbogen(pKnzErstelleLoesungsbogen, lb_reihenfolge);
/*
* Stringarray mit den Daten fuer den Loesungsbogen "clearen"
* und anschliessend auf "null" stellen.
*/
lb_reihenfolge.clear();
lb_reihenfolge = null;
/*
* Der erstellte Fragenkatalog wird in der Datei gespeichert
*/
System.IO.File.WriteAllText(pDateiName, string_datei_inhalt);
return(fkt_ergebnis);
}
/*
* ################################################################################
*/
public static clsFragenKatalog getTestFragenKatalog()
{
clsFragenKatalog test_fragen_katalog = new clsFragenKatalog();
clsFrage aktuelle_frage = null;
test_fragen_katalog.setDateiName("TestFragenkatalog1.xls");
int fragen_nr = 1;
int fragen_anzahl = 2;
int fragen_zaehler = 1;
while (fragen_zaehler <= fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID1_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 1 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 A");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, true, "A"));
aktuelle_frage.setAntwortB(getTestAntwort(true, 2, false, "B"));
aktuelle_frage.setAntwortC(getTestAntwort(true, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(true, 4, false, "D"));
aktuelle_frage.setAntwortE(getTestAntwort(fragen_zaehler > 1, 5, false, "E"));
aktuelle_frage.setAntwortF(getTestAntwort(fragen_zaehler > 1, 6, false, "F"));
aktuelle_frage.setAntwortH(getTestAntwort(fragen_zaehler > 1, 7, false, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(fragen_zaehler > 1, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 7;
fragen_zaehler = 1;
while (fragen_zaehler <= fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID2_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 2 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 B");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, true, "A"));
aktuelle_frage.setAntwortB(getTestAntwort(true, 2, false, "B"));
aktuelle_frage.setAntwortC(getTestAntwort(fragen_zaehler >= 2, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(fragen_zaehler >= 3, 4, false, "D"));
aktuelle_frage.setAntwortE(getTestAntwort(fragen_zaehler >= 4, 5, false, "E"));
aktuelle_frage.setAntwortF(getTestAntwort(fragen_zaehler >= 5, 6, false, "F"));
aktuelle_frage.setAntwortH(getTestAntwort(fragen_zaehler >= 6, 7, false, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(fragen_zaehler >= 7, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 6;
fragen_zaehler = 1;
while (fragen_zaehler <= fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID2_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 2 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 B");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, true, "A"));
aktuelle_frage.setAntwortB(getTestAntwort(true, 2, false, "B"));
aktuelle_frage.setAntwortC(getTestAntwort(fragen_zaehler >= 2, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(fragen_zaehler >= 3, 4, false, "D"));
aktuelle_frage.setAntwortE(getTestAntwort(fragen_zaehler >= 4, 5, false, "E"));
aktuelle_frage.setAntwortF(getTestAntwort(fragen_zaehler >= 5, 6, false, "F"));
aktuelle_frage.setAntwortH(getTestAntwort(fragen_zaehler >= 6, 7, false, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(true, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 4;
fragen_zaehler = 1;
while (fragen_zaehler <= fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID2_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 2 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 B");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, true, "A"));
aktuelle_frage.setAntwortB(getTestAntwort(true, 2, false, "B"));
aktuelle_frage.setAntwortC(getTestAntwort(fragen_zaehler >= 4, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(fragen_zaehler >= 3, 4, false, "D"));
aktuelle_frage.setAntwortE(getTestAntwort(fragen_zaehler >= 2, 5, false, "E"));
aktuelle_frage.setAntwortF(getTestAntwort(fragen_zaehler >= 3, 6, false, "F"));
aktuelle_frage.setAntwortH(getTestAntwort(fragen_zaehler >= 4, 7, false, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(true, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 2;
fragen_zaehler = 0;
while (fragen_zaehler < fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID3_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 3 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 C");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, false, "A"));
aktuelle_frage.setAntwortC(getTestAntwort(true, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(true, 4, true, "D"));
aktuelle_frage.setAntwortF(getTestAntwort(true, 6, false, "F"));
aktuelle_frage.setAntwortG(getTestAntwort(true, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 2;
fragen_zaehler = 0;
while (fragen_zaehler < fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID4_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 4 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 D");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, false, "A"));
aktuelle_frage.setAntwortC(getTestAntwort(true, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(true, 2, true, "B"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++; fragen_nr++;
}
fragen_anzahl = 2;
fragen_zaehler = 0;
while (fragen_zaehler < fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID5_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 5 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 2 E");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, false, "A"));
aktuelle_frage.setAntwortC(getTestAntwort(true, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(true, 4, true, "D"));
aktuelle_frage.setAntwortF(getTestAntwort(true, 6, false, "F"));
aktuelle_frage.setAntwortH(getTestAntwort(true, 7, true, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(true, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++;
fragen_nr++;
}
fragen_anzahl = 2;
fragen_zaehler = 0;
while (fragen_zaehler < fragen_anzahl)
{
aktuelle_frage = new clsFrage();
aktuelle_frage.setId("ID6_" + fragen_zaehler + "_" + fragen_nr);
aktuelle_frage.setNummer("" + fragen_nr);
aktuelle_frage.setText1("Fragenblock 6 Nr. " + fragen_zaehler + " von " + fragen_anzahl);
aktuelle_frage.setText2("Fragentext 6 E");
aktuelle_frage.setAntwortA(getTestAntwort(true, 1, true, "A"));
aktuelle_frage.setAntwortB(getTestAntwort(true, 2, false, "B"));
aktuelle_frage.setAntwortC(getTestAntwort(true, 3, false, "C"));
aktuelle_frage.setAntwortD(getTestAntwort(true, 4, true, "D"));
aktuelle_frage.setAntwortE(getTestAntwort(true, 5, false, "E"));
aktuelle_frage.setAntwortH(getTestAntwort(true, 7, true, "G"));
aktuelle_frage.setAntwortG(getTestAntwort(true, 8, false, "H"));
aktuelle_frage.setText2("Anzahl Antworten: " + aktuelle_frage.getAnzahlVorhandeneAntworten() + " korrekt " + aktuelle_frage.getAnzahlKorrekteAntworten() + " falsch " + aktuelle_frage.getAnzahlFalscheAntworten());
test_fragen_katalog.addFrage(aktuelle_frage);
fragen_zaehler++;
fragen_nr++;
}
return(test_fragen_katalog);
}
/**
* Vertauscht die Reihenfolge der Fragen im Fragenkatalog.
*
* @return TRUE wenn die Tauschfunktion durchlaufen worden ist, sonst FALSE (=keine Umstellungen)
*/
public bool startFragenUmstellung()
{
/*
* Ermittlung der Anzahl der vorhandenen Fragen
*/
int anzahl_fragen_vektor = getAnzahlFragen();
/*
* Pruefung: Anzahl Fragen zu klein ?
*
* Die Anzahl der Fragen muss mindestens 3 Fragen fuer eine Vertauschung sein.
*
* Sind es weniger Fragen, wird die Funktion mit FALSE verlassen.
*
* Dieses ist auch dann der Fall, wenn kein Fragenvektor vorhanden ist.
* Es muss keine Pruefung auf eine Instanz des Vektors gemacht werden,
* da diese Pruefung indirekt in der Funktion "getAnzahlFragen" erfolgt.
*/
if (anzahl_fragen_vektor < 2)
{
return(false);
}
/*
* Definition einer Ober- und Untergrenze fuer die Vertauschungen
*/
int umstellung_index_obergrenze = anzahl_fragen_vektor;
int umstellung_index_untergrenze = -1;
int index_position_neu = 0;
int index_position_alt = 0;
int zaehler_such_schleife = 0;
bool knz_naechster_wert_gefunden = false;
/*
* Temporaere Instanz fuer die Vertauschungen der Vektorpositionen
*/
clsFrage temp_inst_frage = null;
Random inst_zufallsgenerator = new Random();
/*
* While-Schleife ueber alle Fragen.
*
* Jede Frage wird einmal in der Position vertauscht.
*/
while ((index_position_alt < anzahl_fragen_vektor) && (index_position_alt < 32123))
{
/*
* Das Kennzeichen fuer die erfolgreiche Ermittlung eines neuen
* Fragenindexes wird fuer die neue Suche auf FALSE gestellt.
*/
knz_naechster_wert_gefunden = false;
/*
* Der Endlosschleifenverhinderungszaehler wird auf 0 gestellt.
*/
zaehler_such_schleife = 0;
/*
* While-Schleife fuer die Ermittlung eines Fragenindexes
*/
while ((knz_naechster_wert_gefunden == false) && (zaehler_such_schleife < 1000))
{
/*
* Neuer Fragenindex
*
* Es wird per Zufall ein Index zwischen der Ober- und Untergrenze ausgewaehlt
*
* Die Zufallszahl wird mit der Obergrenze multipliziert.
*
* Das stellt sicher, dass der Index nicht groesser als die Obergrenze sein kann.
*/
index_position_neu = inst_zufallsgenerator.Next(0, umstellung_index_obergrenze);
if ((umstellung_index_untergrenze > 0) && (index_position_neu < umstellung_index_untergrenze))
{
/*
* Einhaltung Untergrenze
*
* Ist die Untergrenze groesser als 0, darf der Index nicht
* kleiner als der Index der Untergrenze sein.
*
* Ist der Index kleiner als die Untegrenze, ist in diesem
* Durchgang kein neuer gueltiger Fragenindex ermittelt worden.
*/
}
else if ((umstellung_index_obergrenze >= 0) && (index_position_neu > umstellung_index_obergrenze))
{
/*
* Einhaltung Obergrenze
*
* Ist die Obergrenze groesser als 0, darf der Index nicht
* groesser als der Index der Obergrenze sein.
*
* Ist der Index kleiner als die Obergrenze, ist in diesem
* Durchgang kein neuer gueltiger Fragenindex ermittelt worden.
*/
}
else if ((m_frage_vector[index_position_alt] == null) || (m_frage_vector[index_position_neu] == null))
{
/*
* Vermeidung, dass eine der gefundenen Indexpositonen auf "null" steht.
*/
}
else
{
/*
* Pruefung: Tauschpaar gefunden ?
*
* Ein Tauschpar ist gefunden, wenn
* - die beiden Index-Positionen muessen groesser als 0 sein
* - die beiden Index-Positionen duerfen nicht gleich sein
*/
knz_naechster_wert_gefunden = ((index_position_neu >= 0) && (index_position_alt >= 0) && (index_position_neu != index_position_alt));
}
/*
* Am Schleifenende wid der Schleifenzaehler um eins hochgezaehlt.
*/
zaehler_such_schleife = zaehler_such_schleife + 1;
}
/*
* Pruefung: Neuen Frageindex gefunden?
*
* Nach der While-Schleife werde nochmals die Bedingungen fuer das
* Tauschpaar geprueft. Die Suchschleife koennte auch durch den
* Endlosschleifenverhinderungszaehler beendet worden sein.
*/
if ((index_position_neu >= 0) && (index_position_alt >= 0) && (index_position_neu != index_position_alt))
{
if ((m_frage_vector[index_position_alt] != null) && (m_frage_vector[index_position_neu] != null))
{
temp_inst_frage = m_frage_vector[index_position_alt];
m_frage_vector[index_position_alt] = m_frage_vector[index_position_neu];
m_frage_vector[index_position_neu] = temp_inst_frage;
}
}
/*
* Der Index fuer die alte Position wird um 1 erhoeht
*/
index_position_alt = index_position_alt + 1;
}
/*
* Am Funktionsende wird die temporaere Instanz von "clsFrage"
* auf "null" gestellt.
*/
temp_inst_frage = null;
/*
* Es wird TRUE zurueckgegeben, da die Tauschfuntkion durchlaufen worden ist.
*/
return(true);
}
