Optional : you can download those audio files from Wheelock's website for free. decompress them directly into the c:\latin\ directory and the computer will detect them and figure out what to do.
at this point your hard-drive should look something like this (minus those two mega files) :
Now you're all set!
no, not quite. the program is good to go like that but you'll be missing out on the main feature the 'Look-Up Table' or LUT. I'll tell you more about that later, for now, when you run the program it'll tell you that it doesn't have the files for the LUT and you'll have to let it do some work on its own before you can have this very handy feature. The reason for this extra work is that the files which the program uses when its done are close to 1GB in size, and are therefore too big to include with this article. But no worries, when it prompts you and asks if you want to create the LUT files just say 'no' for now and it'll ask you again next time. I'll write more about the LUT down below.
Latina est Gaudium
Yes, Latin is a joy! but first you'll have to pick up on the language because this isn't pig-latin we're talkin' you know! The language is old and for all intents and purposes currently considered dead but that's no reason to kick it when its down. Let me tell you a bit about Latin and why this program is more than just an electronic text-book. Nouns all have a gender including a third gender called 'neuter', which means 'neither' in Latin(bet you didn't know that!). Then each noun and adjective has six cases & two numbers(singular & plural). What's more is adjectives have three different types of ways to be used positive, comparative & superlative, all adjectives have three genders, all have two numbers, and all have six cases :
3 (genders) x 3 (types) x 2 (number) x 6 cases = 108 different ways to spell the same adjective.
every adjective.
and verbs?!? between passive & active, plural & singular, you have the persons 1st, 2nd & 3rd, present past & future, subjunctive? participles, infinitives... there's a lot! and they're all very similar but different one from the next. and that's if you figure out if the verb is 1st conjugation, 2nd or 3rd! or maybe its a third IO. then there's this scary thing called the 'passive periphrastic'.
In short, what I'm saying is, if you're trying to learn latin with nothing but a textbook you're going to run into some trouble. and that's where this program comes in.
Opifex : skilled worker
when you first launch the program you'll be looking at the front cover to Wheelock's Latin. The gray underlined-type print beneath the image are all links to other parts of the book. The textbook part of the program works in a way similar to HTML and the internet, except that its a network of files that are all contained in a single directory on your hard-drive which you can navigate through. This is done using a class called xmlRecord in combination with classGraphics which I talked about in GCIDE : A Complete English Language Dictionary.
The classXmlLatin is similar but does not have the links between files which join the network of files that make up the textbook. This is because the dictionary files which it handles do not require any network and are loaded exclusively using references from the Look-Up Table. Remember the LUT mentioned earlier? This is where the Latin actually happens. The classLatin relies on classXmlLatin to retrieve the dictionary entries which it uses to create the look-up table.
When you finally get around to letting the program build you your LUT you'll find that the program will be very MIPs needy while in the process of building this database. It will keep your computer particularly busy for nearly 24 hours! You can stop and restart it any time you like at no extra cost and you may want to just let it work overnight. That seems like a long time but if you're downloading this program because you need (or want) to learn latin then you won't want to go without it.
classLatin uses an opifex, or skilled worker, to do all the work. The program only needs to instantiate one classLatin, this class then creates itself a resource handler as well as that famous opifex on which it relies. The resource handler manages the classWordInfo. These word-info objects hold all the information from the dictionary entries which the opifex requires to conjugate or decline, whatever the case may be. The classWordInfo also has two combo boxes which can be put on the screen if need be. Any number of these can be requested from the resource-manager and whenever the user makes a selection change on either combo boxes the classWordInfo will pass itself over to the opifex to deliver the Latin.
The actual code for classOpifex is not altogether very complicated because all the work is divided into a multitude of functions that are named with their specific tasks in mind. For most conjugation/declension functions the opifex receives as parameter an instance of a classWordInfo. Since each function is written for one exclusive purpose that's all any of these functions need. In the original Visual Basic version of this program I made the mistake of trying to have one function do everything and discovered that that created new problems with every new chapter of the textbook. This C# version doesn't have any one function with an "I can do it all" attitude but rather relies on a small army of functions that each handle a different latin conjugation or declension.
here's an example ....
public classLatin_C.udtSolution conjugate_Present_Active_Indicative(classWordInfo word)
{
if (verbIsDeponent(word))
return conjugate_Present_Active_Indicative_Deponent(word);
classLatin_C.udtSolution udrRetVal = new classLatin_C.udtSolution();
string[,] strSolution = new string[2, 3];
udrRetVal.strSolution = strSolution;
udrRetVal.typeSolution = getTypeSolution(classLatin_C.enuVerbTenses.Present_Active_Indicative );
string[, ,] strEndings = {{{"ō", "ās","at"}, {"āmus","ātis","ant"}},
{{"eō", "ēs","et"}, {"ēmus","ētis","ent"}},
{{"ō", "is","it"}, {"imus","itis","unt"}},
{{"iō", "īs","it"}, {"īmus","ītis","iunt"}},
{{"iō", "is","it"}, {"imus","itis","iunt"}}};
string strBase = word.strWords[1];
strBase = strBase.Substring(0, strBase.Length - "are".Length);
classLatin_C.enuVerbConjugations verbConjugation = getVerbConjugationFromWordType(word.wordType);
for (classLatin_C.enuNumber numberCounter = classLatin_C.enuNumber.Singular;
numberCounter <= classLatin_C.enuNumber.Plural;
numberCounter++)
for (classLatin_C.enuPerson personCounter = classLatin_C.enuPerson.First;
personCounter <= classLatin_C.enuPerson.Third;
personCounter++)
udrRetVal.strSolution[(int)numberCounter, (int)personCounter] = shortenLongVowels(strBase + strEndings[(int)verbConjugation, (int)numberCounter, (int)personCounter]);
udrRetVal.strRowNames = getRowNamesOfConjugation();
udrRetVal.strColumnNames = getColumnNamesOfDeclension();
return udrRetVal;
}
In this example the opifex is being requested to conjugate the word it is provided in the Present Active Indicative. It will first ask "is this a deponent verb?" and if so branch off to the opifex function which will take care of it if it is. Otherwise it creates an instance of a structure called udtSolution, translate the verb tense into a typeSolution(two enumerated types). Then, because the latin rule for this case is to chop off the last letters of the verb's second participle (strWord[1] in the classWordInfo) before adding the personal endings, it generates a variable called strBase and proceeds to add the appropriate endings, fetches the row-names & column-names for this type of solution and wires it all back to the calling function.
If you take a closer look at these functions you'll find that they all pretty much do the same thing with only minor variations for their specific tasks. Because there are so many ways to conjugate and decline nouns, adjectives and verbs in latin it was just easier to do things this way than to worry about saving code-space by consolidating them all into one, or even only just a few functions. This design makes debugging much easier. This way, if next year I find that I've been declining 3rd declension feminine superlative adjectives incorrectly, there's only one function to fix and it won't affect anything else when I debug it.
bada-bing, bada-boom.
in Combo two
Whenever a dictionary entry appears on the screen you'll find it comes with a few extra features besides the definition. Looking at the two combo-boxes above the word's entry you'll see that the one on the left tells you what kind of word you're looking at, e.g. magnus, -a, -um : first declension adjective. Listed below this you would see the three genders for each of the three ways this adjective can be declined : positive, comparative & superlative. You can choose any one of these entries and get an output. Selecting any specific gender will give you the 2 numbers & 6 case spellings for this adjective for the gender/type you've chosen. Clicking on the Comparative heading, somewhere near the middle of the list, will produce another form with all 3 genders x 2 numbers x 6 cases(all the comparative spellings of magnus!) and if you're still not sure what you're looking for the top most heading with the word's type-info I mentioned earlier will spit out all 108 ways this particular adjective can be spelled onto the screen in one clean sweep.
verbs & nouns are similar but with tenses, passive & active or in the case of nouns just the same as adjectives but only for the one gender. just play around with it you'll see what I mean.
and in the right corner!
the other combo-box is something I call Latin logic. This is loaded with links to the Wheelock's Latin textbook's pages that are specifically related for the particular word you're looking at. You might be curious to know what a 3rd Conjugation-IO verb is when you popup a dictionary form with the definition for the word capio, -ere and scanning over the list of entries there you'll find exactly what you're looking for. Then when you select an entry from the Latin Logic combobox a whole new instance of your Latin textbook pops up on exactly the right page, chapter 10, sub-chapter "IO verbs" for you to read at your delight.
there's a LUT to do
You really should have your program build you a Look-up table because without it you're missing out on a lut!(sic). Let me explain. if you haven't been able to actually see a dictionary entry and tell the opifex to get to work for you, that's because you haven't yet got your look-up table on-line. once you do, its a wiz. What the look-up table does is very similar to what the GCIDE article mentioned above does : it helps you find what you're looking for. It tells you what a word is, how many ways that particular spelling can be derived, and where to find the root of the word you're looking at. To do this the program goes over every entry in the Latin/English dictionary, it loads each word-entry one at a time, generates every possible spelling it knows how for all of these words then stores them into a database along with the means by which each spelling was obtained. Then when the user asks it what the word capiunt is, for example, it scans the database and tells you that capiunt is the word you would have found in your pocket Latin dictionary listed under capio, -ere, cepi, captum had you picked it up off the shelf, however, the LUT will also tell you that its conjugated in the Present Active Indicative, third person, plural, which you would otherwise have to figure out for yourself.
The image above shows you the textbook page 'On a Temperamental Friend' at the top, clicking on the word difficilis which appears in the first latin sentence shows you the difficilis form which lists all the possible ways this particular spelling can be derived and selecting the first one pops up the next form in front of it(Dictionary entry with its two combo-boxes - F1) or the blue form in front of that one (positive masculine declension - F3). You'll notice that this word also shows the "audio" button which when pressed audibly tells you how the root of this word is pronounced (that is, if you've downloaded the audio files). Notice the pretty blue? feminine nouns & adjectives are displayed in pink and neuters in gray.
Latin's particular because had you been looking for the word "ceperant" in your pocket dictionary you'd probably not think to look under "capio" and may or may not find it. But with this LUT all that is done for you! Unfortunately so is most of the thinking which makes it very easy to rely entirely on the program and not do any actual latin-learning at all, as I have so happily discovered.
The LUT first gives you a list of ways the word can be derived. From there you can ask it to give you the dictionary form of the entry you've selected, or to just put the solution to the screen straightaway. You can do either of these by clicking F1 for the one or F3 for the other. Alternately you can click the left half of the form or the right and a pop-up helpful text tells you which you're about to select.
The program's mode selection allows you to choose between workbook, textbook and vocabulary. The textbook is the default start-up value and this is where you click on words, links or images. Clicking on a latin word will cause the program to search the LUT for the word you clicked making reading latin just a little bit less daunting for any newbies. If you happen to click a word it doesn't find in the LUT the program won't scowl or argue but rather it'll kick back and wait for your next request. This way you can click an english-word and need not worry about confusing it though this would be a good place to include the GCIDE project if you already have it up and running on your computer. The picBox's mouse-click event in the form classGraphicOutputPanel below shows you where :
void pic_MouseClick(object sender, MouseEventArgs e)
{
if (wordUnderMouse != null)
{
switch (wordUnderMouse.eWordImageType)
{
case enuWordImageType.link:
loadFile(wordUnderMouse.strAddress);
cutNavigation();
addNavigationPage();
break;
case enuWordImageType.solution:
frmPopUp.Owner = mainForm;
frmPopUp.showText(wordUnderMouse.strAddress);
break;
case enuWordImageType.image:
Form frmPic = new Form();
PictureBox pic = new PictureBox();
frmPic.Controls.Add(pic);
pic.SizeMode = PictureBoxSizeMode.AutoSize;
pic.Image = wordUnderMouse.bmp;
frmPic.Size = new Size(pic.Width + 15, pic.Height + 35);
frmPic.Text = wordUnderMouse.strText;
pic.Location = new Point(0, 0);
frmPic.KeyDown += new KeyEventHandler(cLibLatin.frm_KeyDown);
frmPic.Show();
break;
case enuWordImageType.plain:
cLibLatin.searchLUT(cLib.removeNonAlpha(wordUnderMouse.strText));
// add GCIDE project break;
}
}
}
The textbook is nothing more than a textbox with one extra feature, you guessed it, it is a Latin-LUT friendly zone. Just place the cursor on the word you've typed and want to know more about and then press F3.
