This forum is read-only - Please use our new Citavi Forum instead.
Dieses Forum dient nur zur Recherche - Bitte nutzen Sie das neue Citavi Forum für Ihre Fragen.

Titelzusätze bei Gesetzen

Schlagen Sie neue Funktionen vor. Wir sind gespannt auf Ihre Wünsche.

Titelzusätze bei Gesetzen

Postby Felix Magin » 2016-06-19 11:47

Hallo,

ergänzend zu Bebbis Wunsch nach dem Untertitel-Feld bei Gesetzen hätte ich auch gern noch das Feld "Titelzusätze" zur Verfügung.

Dieses möchte ich nutzen, um bei internationalen Übereinkommen, die Deutschland ratifiziert hat, darauf hinzuweisen, dass im Bundesgesetzblatt eine nicht verbindliche Übersetzung abgedruckt ist. Die Europäische Menschenrechtskonvention (EMRK) zum Beispiel ist nur im englischen und französischen Wortlaut verbindlich. Im Bundesgesetzblatt findet sich aber eine deutsche Übersetzung (BGBl. 2002 II, S. 1055).
Ähnliches gilt für das WTO-Abkommen (authentische Sprachfassungen: englisch, französisch, spanisch; deutsche Übersetzung in BGBl. 1994 II, S. 1625) und das UN-Kaufrecht (CISG) (authentische Sprachfassungen: englisch, französisch, spanisch, chinesisch, russisch; deutsche Übersetzung in BGBl. 1989 II, S. 588).


Das UN-Kaufrecht würde ich dann wie folgt erfassen:

Titel: Übereinkommen der Vereinten Nationen über Verträge über den internationalen Warenverkauf
Untertitel: UN-Kaufrecht
Kurztitel: nicht authentische deutsche Übersetzung
Abkürzung: CISG
...


Klingt das sinnvoll oder übersehe ich etwas?

Liebe Grüße,

Felix Magin
Felix Magin
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Alma » 2016-06-19 19:14

Hallo Felix,
Es macht mE durchaus Sinn, diesen Zusatz zu erfassen, aber ein Kurztitel ist es ja eigentlich nicht, oder? Was spricht dagegen, diesen Hinweis in einem Freitextfeld zu hinterlegen?

Viele Grüße
Alma
Alma
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Felix Magin » 2016-06-20 07:16

Hallo Alma,

da ist mir ein Flüchtigkeitsfehler unterlaufen. Entsprechend der Thread-Überschrift meinte ich natürlich "Titelzusatz", nicht "Kurztitel". Das wäre tatsächlich falsch. Ein Titelzusatz ist es aber meines Erachtens schon, oder?

Viele Grüße,
Felix
Felix Magin
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Alma » 2016-06-20 14:26

Hallo Felix,
gut, den Fehler hätte ich vielleicht auch selbst entdecken können. Ob es ein Titelzusatz ist, da bin ich mir nicht ganz sicher. Irgendwie würde ich mir unter Titelzusatz etwas anderes vorstellen, kann aber gerade nicht richtig fassen, was. Ich würde eine solche Information vom Gefühl her eher in das Feld Notiz schreiben. Das kannst du ja auch entsprechend ausgeben lassen, ohne dass es eines neuen Feldes bedürfte. Oder benutzt du das Feld schon anderweitig?

Wobei ich gegen "Titelzusatz" als Feld jetzt auch nichts einzuwenden hätte. Ein Feld mehr schadet ja nicht, zumal man damit irgendwie ja auch bei anderen Dokumententypen umgehen kann :-)

Viele Grüße
Alma
Alma
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby jay-squared » 2016-06-20 14:35

Hallo zusammen,

ich bin dazu übergegangen, die Ausgabe bestimmter Zusatzinformationen davon abhängig zu machen, ob im Notizfeld ein bestimmter String steht. Mehr Hintergrund hier.

Genau genommen folge ich inzwischen dem entgegengesetzten Modell als dem, was da steht. Ich drucke bei Gesetzen immer die Jurisdiktion, es sei denn im Notizfeld des Gesetzes, oder der Fundstelle des Gesetzes, steht der string "jurisdiction".

So ein ähnliches Modell könnte man auch hier verwenden: eine Komponente, welche immer dann "inoffizielle Übersetzung" druckt, wenn im Notizfeld des Titels der String "translation" enthalten ist. Da der Typ "Gesetz/Verordnung" auch das Sprachfeld kennt, könnte man die Komponente sogar so programmieren, dass die Komponente automatisch "inoffizielle deutsche Übersetzung", "inoffizielle englische Übersetzung", etc. druckt, abhängig davon, was da im Sprachfeld steht.

Beste Grüße
JJ
jay-squared
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Bebbi » 2016-06-21 01:30

Hallo,

@JJ Welche Bedeutung meinst du https://de.wikipedia.org/wiki/Jurisdiktion?

Die Lösung von JJ ermöglicht natürlich vieles, ist für den Eimsteiger in Citavi aber zu bombastisch und schafft Inseln (Man kann sich nicht mehr mit anderen austauschen etc., Export in andere Programme nicht mehr möglich oder nur beschränkt).

Ansonsten würde ich ich in dieser Expertenrunde dem Wunsch von Felix Magin anschließen als sinnvolle Sache.

Grüße

Bebbi
Bebbi
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Felix Magin » 2016-06-21 09:57

Hallo zusammen.

Alma wrote:Ich würde eine solche Information vom Gefühl her eher in das Feld Notiz schreiben. Das kannst du ja auch entsprechend ausgeben lassen, ohne dass es eines neuen Feldes bedürfte. Oder benutzt du das Feld schon anderweitig?

Nein, das Feld "Notiz" nutze ich nicht anders, ich könnte das also auch dahin schreiben. In den von mir angesprochenen Fällen liegt aber keine simple nicht offizielle Übersetzung vor. Das würde ich gegeben sehen, wenn irgendein Autor ein ausländisches Gesetz übersetzt hat (so wie hier). Hier ist es aber so, dass die Übersetzung schon eine "offizielle" ist (immerhin steht sie im Bundesgesetzblatt). Nur ist sie trotzdem (im Zweifelsfall) nicht verbindlich. Der deutsche Jurist konsultiert in der Regel aber nur die deutsche Sprachfassung, schaut bei Bedeutungsunsicherheiten in die englische, vielleicht noch in die spanische oder französische, und hofft, dass etwaige weitere Sprachfassungen (russisch, chinesisch, arabisch) ungefähr mit den anderen übereinstimmen (mitlesende Juristen mögen mir gerne widersprechen!). Daher gehört meines Erachtens der Hinweis auf die Unverbindlichkeit der gesetzlichen (!) Übersetzung schon in die Titelzusätze.
Diese Diskussion ist aber letztlich egal, denn wie Du ganz richtig sagst:
Alma wrote:Ein Feld mehr schadet ja nicht, zumal man damit irgendwie ja auch bei anderen Dokumententypen umgehen kann :-)

Zumal man das Feld der Titelzusätze ja auch anders nutzen könnte. Beispielsweise könnte man beim EU-Verfassungsvertrag im Titelzusatz angeben "nie in Kraft getreten".



@JJ:
Ich vermute, dass Du dir mit Deiner Programmierwut inzwischen Dein eigenes Citavi 6 geschrieben hast... ;-)
Der Preis für das Understatement des Jahres 2015 (traditionell am 1. Juli des Folgejahres verliehen) geht jedenfalls an Dich, für die Aussage:
jay-squared wrote:Ich bin nun gar nicht C#-affin [21.08.2015]

Deinen Ansatz zu Parallelfundstellen habe ich inzwischen auch bei mir umgesetzt und bin sehr dankbar dafür. Ich habe keine Ahnung, wie gut meine derzeitige Arbeit inhaltlich ist, aber rein optisch wird sie sicher die schönste Arbeit, die mein Prof je gelesen hat...

Zurück zu Deinem Vorschlag:
Ja, das scheint mir eine wirklich gute Idee zu sein. Wenn man nicht die vorgegebenen Vorlagenbedingungen verwendet, sondern sich seine eigene schreibt (basierend auf irgendeiner "Feld X enthält Y"-Bedingung), müsste man sogar auf das Notiz-Feld verzichten können. Ich stelle mir grade ungefähr folgendes vor:

Angabe im Feld "Sprache"
  1. off-ger
  2. off-eng
  3. ino-ger
Ausgabe im Dokument
  1. "authentische deutsche Sprachfassung"
  2. "authentische englische Sprachfassung"
  3. "nicht authentische deutsche Übersetzung"
Das ließe sich vielleicht sogar kombinieren, sodass man ino-ger off-eng off-fra ins Sprache-Feld eingibt und erhält "nicht authentische deutsche Übersetzung. Authentische Sprachfassungen: Englisch, Französisch"
Vermutlich kann man das sogar als nur eine Komponente basteln...Deine Parallelstellenlösung hat mich angefixt, jetzt will ich mehr davon ;-) Mal gucken, ob ich das aus Deinem Code basteln kann.


@Bebbi:
Soweit ich das System des Common Law verstanden habe (das ist aber nicht sehr weit), meint JJ keine der drei Bedeutungen, die die deutsche Wikipedia kennt. Wenn ich seine Ausführungen richtig verstehe, geht es hierum https://en.wikipedia.org/wiki/Jurisdiction_(area) bzw. (grob übertragen) https://de.wikipedia.org/wiki/Rechtsgebiet_(Geltungsbereich). JJ möge mich aber korrigieren, wenn ich falsch liege.



Gruß an alle,

Felix
Felix Magin
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby jay-squared » 2016-06-21 11:09

Hallo,

ich würde ggf. vorschlagen, statt auf Vorlagen zu setzen eine programmierte Komponente zu nehmen. Die hat den Vorteil, dass man nicht vier verschieden Vorlagen braucht (Sprachfeld leer, off-eng, off-ger, ino-ger), sondern sich mit einer Vorlage begnügt. Die Komponente hätte dann wieder nur ein Textfeld als einziges Element, bei dem vollkommen egal ist, was drin steht, da der gesamte Output durch den Filter erzeugt wird. Der könnte in etwa wie folgt aussehen:

Code: Select all
using System.Linq;
using System.Collections.Generic;
using SwissAcademic.Citavi;
using SwissAcademic.Citavi.Metadata;
using SwissAcademic.Collections;
using SwissAcademic.Drawing;

namespace SwissAcademic.Citavi.Citations
{
   public class ComponentPartFilter
      :
      IComponentPartFilter
   {
      public IEnumerable<ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
      {
         handled = true;
         
         var language = citation.Reference.Language;
         
         if (language == string.Empty || language == null) return null;
         
         string translationString = string.Empty;
         
         if (language == "off-ger")
         {
            translationString = "authentische deutsche Sprachfassung";
         }
         else if (language == "off-eng")
         {
            translationString = "authentische englische Sprachfassung";
         }
         else if (language == "ino-ger")
         {
            translationString = "nicht authentische deutsche Übersetzung";
         }         
         
         var output = new TextUnitCollection();
         var text = new LiteralTextUnit(translationString);
         output.Add(text);         

         return output;      
         
      }
   }
}


Der Hauptvorteil dieses Ansatzes gegenüber "wir schreiben die Info ins Feld 'Titelzusatz'" ist, daß ich die eigentliche Ausgabe durch den Zitierstil steuern kann. Wenn ich dann mal was auf Englisch schreibe, muss ich nur den Zitierstil ändern, also den Ausgabestring, statt bei allen Titeln die Daten. Der Ansatz folgt also dem Modell, Information von Ausgabe der Information zu trennen.

Das mit der Auslegung der Jurisdiktion stimmt. Ich möchte aber hinzufügen, dass ich mir angewöhnt habe, auch bei deutschen Entscheidungen zu erfassen, aus welchem Bundesland sie stammen (anhand der zweiten Hälfte der ISO 3166-2:DE-Codes). So richtig sinnvoll ist das wahrscheinlich nur bei Verwaltungsrechtsentscheidungen, aber trotzdem irgendwie eine charmante Information.

Beste Grüße
JJ
jay-squared
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby jay-squared » 2016-06-21 14:48

Ah, ich hab den Teil mit der Kombinierbarkeit überlesen. Ich hab da mal was entworfen, was das Feld "Sprache" als Leerzeichen-getrennte Liste interpretiert, wobei jedes Element der Liste dem Muster "Statuscode-Sprachcode" folgt. Als Status-Code wird erkannt "auth" für authentische Fassungen, "off" für offizielle Übersetzungen a la Bundesgesetzesblatt und "ino" für inoffizielle Übersetzungen a la Gesetze im Internet. Als Sprachcode wird erkannt "de", "en", und "fr".

Code: Select all
using System.Linq;
using System.Collections.Generic;
using SwissAcademic.Citavi;
using SwissAcademic.Citavi.Metadata;
using SwissAcademic.Collections;
using SwissAcademic.Drawing;

namespace SwissAcademic.Citavi.Citations
{
   public class ComponentPartFilter
      :
      IComponentPartFilter
   {
      public IEnumerable<ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
      {
         handled = true;
         
         var output = new TextUnitCollection();
         
         var languagesString = citation.Reference.Language;
         
         if (languagesString == string.Empty || languagesString == null) return null;
         
         LiteralTextUnit separatorLiteral = new LiteralTextUnit(", ");
         LiteralTextUnit prefixLiteral = new LiteralTextUnit(" (");
         LiteralTextUnit suffixLiteral = new LiteralTextUnit(")");
         
         FontStyle fontStyle = FontStyle.Neutral;
         
         List<string> languagesList = languagesString.Split(' ').ToList();
         
         List<Language> officialTranslationsList = new List<Language>() ;
         List<Language> authenticLanguagesList = new List<Language>() ;
         List<Language> inofficialTranslationsList = new List<Language>() ;
         
         List<Language> availableLanguagesList = new List<Language>();
         
         availableLanguagesList.Add(new Language("en", "englische", "Englisch"));
         availableLanguagesList.Add(new Language("fr", "französische", "Französisch"));
         availableLanguagesList.Add(new Language("de", "deutsche", "Deutsch"));
         
         string authenticString = "auth";
         string inofficialString = "ino";
         string officialString = "off";
         
         foreach (string language in languagesList)
         {
            string code = language.Split('-')[1];
            string status = language.Split('-')[0];
            if (status == authenticString) authenticLanguagesList.Add(availableLanguagesList.Where(i => i.LanguageCode == code).FirstOrDefault());
            if (status == inofficialString) inofficialTranslationsList.Add(availableLanguagesList.Where(i => i.LanguageCode == code).FirstOrDefault());
            if (status == officialString) officialTranslationsList.Add(availableLanguagesList.Where(i => i.LanguageCode == code).FirstOrDefault());
         }
         
         if (inofficialTranslationsList.Count == 1)
         {
            output.Add(new LiteralTextUnit("inoffizielle "));
            output.Add(new LiteralTextUnit(inofficialTranslationsList.FirstOrDefault().Adjective));
            output.Add(new LiteralTextUnit(" Übersetzung"));
         }
         else if (inofficialTranslationsList.Count > 1)
         {
            int i = 0;
            output.Add(new LiteralTextUnit("inoffizielle Übersetzungen: "));
            foreach (Language language in inofficialTranslationsList)
            {
               if (i > 0) output.Add(new LiteralTextUnit(", "));
               output.Add(new LiteralTextUnit(language.Noun));
               i = i + 1;
            }
         }
         
         if (officialTranslationsList.Count == 1)
         {
            if (output.Count > 0) output.Add(new LiteralTextUnit(", "));
            output.Add(new LiteralTextUnit("offizielle "));
            output.Add(new LiteralTextUnit(officialTranslationsList.FirstOrDefault().Adjective));
            output.Add(new LiteralTextUnit(" Übersetzung"));
         }
         else if (officialTranslationsList.Count > 1)
         {
            if (output.Count > 0) output.Add(new LiteralTextUnit(", "));
            int i = 0;
            output.Add(new LiteralTextUnit("offizielle Übersetzungen: "));
            foreach (Language language in officialTranslationsList)
            {
               if (i > 0) output.Add(new LiteralTextUnit(", "));
               output.Add(new LiteralTextUnit(language.Noun));
               i = i + 1;
            }
         }         
         
         if (authenticLanguagesList.Count == 1)
         {
            if (output.Count > 0) output.Add(new LiteralTextUnit(", "));
            output.Add(new LiteralTextUnit("authentische "));
            output.Add(new LiteralTextUnit(authenticLanguagesList.FirstOrDefault().Adjective));
            output.Add(new LiteralTextUnit(" Fassung"));
         }
         else if (authenticLanguagesList.Count > 1)
         {
            if (output.Count > 0) output.Add(new LiteralTextUnit(", "));
            int i = 0;
            output.Add(new LiteralTextUnit("authentische Fassungen: "));
            foreach (Language language in authenticLanguagesList)
            {
               if (i > 0) output.Add(new LiteralTextUnit(", "));
               output.Add(new LiteralTextUnit(language.Noun));
               i = i + 1;
            }
         }
                  
         if (output.Count > 0)
         {
            output.Insert(0, prefixLiteral);
            output.Add(suffixLiteral);
         }
         
         foreach (LiteralTextUnit text in output)
         {
            text.FontStyle = fontStyle;
         }

         return output;      
         
      }
   }
   public class Language
   {
      public string LanguageCode { get; set; }
      public string Adjective { get; set; }
      public string Noun { get; set; }
      
      public Language(string languageCode, string adjective, string noun)
       {
           this.LanguageCode = languageCode;
           this.Adjective = adjective;
           this.Noun = noun;
         }
   }
}


Damit kriegt man dann aus "auth-en ino-de auth-fr off-en" so lustige sinnbefreite Outputs wie "(inoffizielle deutsche Übersetzung, offizielle englische Übersetzung, authentische Fassungen: Englisch, Französisch)".

Das ganze hat keinen Error-Handler, wenn da also unerwarteter Input im Sprachfeld steht, scheitert die ganze Komponente. Aber vielleicht ein Anfang.
jay-squared
Citavi Expert
 

Re: Titelzusätze bei Gesetzen

Postby Felix Magin » 2016-06-21 16:41

War ja klar, während ich stundenlang an meinem ersten Code bastle, kommst Du um die Ecke und baust auch nochmal einen...

Gerade eben wollte ich folgende Nachricht absenden:

Felix Magin wrote:
Felix Magin wrote:Vermutlich kann man das sogar als nur eine Komponente basteln...


Auf die Idee, nur eine Komponente zu verwenden, war ich bereits gekommen *stolz*. Dass Du mir direkt einen Code dafür lieferst, ist natürlich riesig.

In einem plötzlichen Wahnanfall habe ich ihn noch erheblich ausgebaut:

Code: Select all
    using System.Linq;
    using System.Collections.Generic;
    using SwissAcademic.Citavi;
    using SwissAcademic.Citavi.Metadata;
    using SwissAcademic.Collections;
    using SwissAcademic.Drawing;

    namespace SwissAcademic.Citavi.Citations
    {
       public class ComponentPartFilter
          :
          IComponentPartFilter
       {
          public IEnumerable<ITextUnit> GetTextUnits(ComponentPart componentPart, Template template, Citation citation, out bool handled)
          {
             handled = true;
             
             var language = citation.Reference.Language;
             
             if (language == string.Empty || language == null) return null;
         
          string AuthenticString = "authentisch";
          string NotAuthenticString = "nicht authentisch";
          string VersionString = "Sprachfassung";
          string TranslationString = "Übersetzung";
          string ColonString = ":";
          string CommaString = ",";
          string SpaceString = " ";
          string Suffix_e_String = "e";
          string Suffix_n_String = "n";
          string OpenBracketString = "(";
          string CloseBracketString = ")";
         
         
          string ArabicString_1 = "Arabisch";
          string ChineseString_1 = "Chinesisch";
          string EnglishString_1 = "Englisch";
          string FrenchString_1 = "Französisch";
          string RussianString_1 = "Russisch";
          string SpanishString_1 = "Spanisch";
          string GermanString_1 = "Deutsch";
         
          string ArabicString_2 = "arabisch";
          string ChineseString_2 = "chinesisch";
          string EnglishString_2 = "englisch";
          string FrenchString_2 = "französisch";
          string RussianString_2 = "russisch";
          string SpanishString_2 = "spanisch";
          string GermanString_2 = "deutsch";
         
         var AuthenticLiteral = new LiteralTextUnit(AuthenticString);
         var NotAuthenticLiteral = new LiteralTextUnit(NotAuthenticString);
         var VersionLiteral = new LiteralTextUnit(VersionString);
         var TranslationLiteral = new LiteralTextUnit(TranslationString);
         var ColonLiteral = new LiteralTextUnit(ColonString);
         var CommaLiteral = new LiteralTextUnit(CommaString);
         var SpaceLiteral = new LiteralTextUnit(SpaceString);
         var Suffix_e_Literal = new LiteralTextUnit(Suffix_e_String);
         var Suffix_n_Literal = new LiteralTextUnit(Suffix_n_String);
         var OpenBracketLiteral = new LiteralTextUnit(OpenBracketString);
         var CloseBracketLiteral = new LiteralTextUnit(CloseBracketString);
         
         var ArabicLiteral_1 = new LiteralTextUnit(ArabicString_1);
         var ArabicLiteral_2 = new LiteralTextUnit(ArabicString_2);
         var ChineseLiteral_1 = new LiteralTextUnit(ChineseString_1);
         var ChineseLiteral_2 = new LiteralTextUnit(ChineseString_2);
         var EnglishLiteral_1 = new LiteralTextUnit(EnglishString_1);
         var EnglishLiteral_2 = new LiteralTextUnit(EnglishString_2);
         var FrenchLiteral_1 = new LiteralTextUnit(FrenchString_1);
         var FrenchLiteral_2 = new LiteralTextUnit(FrenchString_2);
         var RussianLiteral_1 = new LiteralTextUnit(RussianString_1);
         var RussianLiteral_2 = new LiteralTextUnit(RussianString_2);
         var SpanishLiteral_1 = new LiteralTextUnit(SpanishString_1);
         var SpanishLiteral_2 = new LiteralTextUnit(SpanishString_2);
         var GermanLiteral_1 = new LiteralTextUnit(GermanString_1);
         var GermanLiteral_2 = new LiteralTextUnit(GermanString_2);
             
             /*At first we identify every authentic text. Official languages of the UNO are:
            - Arabic   (ara)
            - English   (eng)
            - Chinese   (chi or zho) Careful! "tho" would be klingon... ;-)
            - French   (fre or fra)
            - Russian   (rus)
            - Spanish   (spa)

            The three letter codes follow ISO 639-2.
          To classify a language as authentic it is necessary to write "off-xxx" into the language-field (e.g. off-eng)
         
          In case we cite german law we also add german (ger or deu) as a possible authentic language.
         */
          bool AraIsAuthentic = false;
          bool ChiIsAuthentic = false;
          bool EngIsAuthentic = false;
          bool FreIsAuthentic = false;
          bool RusIsAuthentic = false;
          bool SpaIsAuthentic = false;
          bool GerIsAuthentic = false;// add more authentic languages if desired
         
          var AuthenticCounter = 0;
            
         
          if (language.Contains("off-ara"))
          {
            AraIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
         
          if (language.Contains("off-chi") | language.Contains("off-zho"))
          {
            ChiIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
         
          if (language.Contains("off-eng"))
          {
            EngIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
         
          if (language.Contains("off-fre") | language.Contains("off-fra"))
          {
            FreIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
         
          if (language.Contains("off-rus"))
          {
            RusIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
         
          if (language.Contains("off-spa"))
          {
            SpaIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
          }
             
             if (language.Contains("off-ger") | language.Contains("off-deu"))
             {
                GerIsAuthentic = true;
            AuthenticCounter = AuthenticCounter + 1;
             }
         
         /* Now we want to identify every non-authentic text (translations), marked by "ino-" and the language code.
         E.g. "ino-ger" for a german translation*/
         
          bool AraIsTranslation = false;
          bool ChiIsTranslation = false;
          bool EngIsTranslation = false;
          bool FreIsTranslation = false;
          bool RusIsTranslation = false;
          bool SpaIsTranslation = false;
          bool GerIsTranslation = false;
         
          var TranslationCounter = 0;
         
          if (language.Contains("ino-ara"))
          {
            AraIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-chi") | language.Contains("ino-zho"))
          {
            ChiIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-eng"))
          {
            EngIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-fre") | language.Contains("ino-fra"))
          {
            FreIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-rus"))
          {
            RusIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-spa"))
          {
            SpaIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
          if (language.Contains("ino-ger") | language.Contains("ino-deu"))
          {
            GerIsTranslation = true;
            TranslationCounter = TranslationCounter + 1;
          }
         
         /*Having this done, we start creating the output.
         The output shall look like "Deutsche Übersetzung (authentische Sprachfassungen: Arabisch, Chinesisch, Englisch, Französisch, Russisch, Spanisch)"
         */
                                    
             var output = new TextUnitCollection();
         
          if (TranslationCounter == 0 && AuthenticCounter == 0)
          {
            var DefaultText = new LiteralTextUnit(language);
            output.Add(DefaultText);
          }
         
         
          else if (TranslationCounter > 1)
          {
            var DefaultText = new LiteralTextUnit(language);
            output.Add(DefaultText); //You can only cite one translation at a time
          }
            
          else
          {
            var CitedAuthenticsCounter = 0;
            
            output.Add(OpenBracketLiteral);
            
            if (TranslationCounter == 1)
            {
               output.Add(NotAuthenticLiteral);
               output.Add(Suffix_e_Literal);
               output.Add(SpaceLiteral);
               
               if (AraIsTranslation == true) output.Add(ArabicLiteral_2);
               else if (ChiIsTranslation == true) output.Add(ChineseLiteral_2);
               else if (EngIsTranslation == true) output.Add(EnglishLiteral_2);
               else if (FreIsTranslation == true) output.Add(FrenchLiteral_2);
               else if (RusIsTranslation == true) output.Add(RussianLiteral_2);
               else if (SpaIsTranslation == true) output.Add(SpanishLiteral_2);
               else if (GerIsTranslation == true) output.Add(GermanLiteral_2);
                                 
               output.Add(Suffix_e_Literal);
               output.Add(SpaceLiteral);
               output.Add(TranslationLiteral);
               output.Add(CommaLiteral);
               output.Add(SpaceLiteral);
            }
            
               output.Add(AuthenticLiteral);
               output.Add(Suffix_e_Literal);
               output.Add(SpaceLiteral);
               output.Add(VersionLiteral);
            
            if (AuthenticCounter > 1)
            {
               output.Add(Suffix_e_Literal);
               output.Add(Suffix_n_Literal);
            }
            
            output.Add(ColonLiteral);
            output.Add(SpaceLiteral);
            
            if (AraIsAuthentic == true)
            {
               output.Add(ArabicLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (ChiIsAuthentic == true)
            {
               output.Add(ChineseLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (EngIsAuthentic == true)
            {
               output.Add(EnglishLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (FreIsAuthentic == true)
            {
               output.Add(FrenchLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (RusIsAuthentic == true)
            {
               output.Add(RussianLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (SpaIsAuthentic == true)
            {
               output.Add(SpanishLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               if (AuthenticCounter > CitedAuthenticsCounter)
               {
                  output.Add(CommaLiteral);
                  output.Add(SpaceLiteral);
               }
               else
               {
                  output.Add(CloseBracketLiteral);
               }
            }
            
            if (GerIsAuthentic == true)
            {
               output.Add(GermanLiteral_1);
               CitedAuthenticsCounter = CitedAuthenticsCounter + 1;
               
               output.Add(CloseBracketLiteral);
               
            }
            
          }
         
            
                   

             return output;     
             
          }
       }
    }


Jetzt kann ich in beliebiger Reihenfolge alle Amtssprachen der UNO und Deutsch als authentisch bezeichnen:
  • "off-ara" (Arabisch)
  • "off-chi" oder "off-zho" (Chinesisch)
  • "off-eng" (Englisch)
  • "off-fre" oder "off-fra" (Französisch)
  • "off-rus" (Russisch)
  • "off-spa" (Spanisch)
  • "off-ger" oder "off-deu" (Deutsch)

Außerdem kann ich eine Sprache als zitierte Übersetzung angeben, indem ich statt des "off" ein "ino" vor das Sprachkürzel setze. Ob es ein Trennzeichen gibt und wie das aussieht, ist egal.

Aus der Eingabe off-chi ino-ger off-ara; off-eng off-fraoff-rus off-spa gibt Citavi dann aus:
(nicht authentische deutsche Übersetzung, authentische Sprachfassungen: Arabisch, Chinesisch, Englisch, Französisch, Russisch, Spanisch)


Aus off-eng off-fre wird:
(authentische Sprachfassungen: Englisch, Französisch)


Aus off-deu wird:
(authentische Sprachfassung: Deutsch)

Die Reihenfolge der ausgegebenen Sprachfassungen ist innerhalb der UNO-Sprachen immer alphabetisch, deutsch kommt immer zuletzt (kann man aber leicht ändern).

Wenn der Code mit den gefundenen Daten nichts anfangen kann (bspw. wenn ich in geistiger Umnachtung einfach "französisch" ins Sprache-Feld schreibe statt "off-fra", gibt er aus, was er findet.

Was haltet Ihr davon?


Grüße,
Felix


Jetzt muss ich mir erstmal Deinen Code angucken und vermutlich feststellen, dass er eleganter ist als meiner. Auf den ersten Blick habe ich gesehen, dass Du Listen verwendest, mit sowas kann ich noch nicht umgehen. Ich habe erst gestern angefangen, mir anhand Deines Parallelstellencodes etwas C# beizubringen.
Ich danke Dir aber ehrlich für Deine viele Mühe (auch wenn ich jetzt etwas ärgerlich klinge, das ist nur ein bisschen verletzter Stolz).

Liebe Grüße,

Felix
Felix Magin
Citavi Expert
 

Next

Return to Wunschliste