path: root/apps/X11/cheatah/cheatah.cpp

/*  cheatah
 *  Copyright (C) 1999, CrossWire Bible Society
 *			P. O. Box 2528
 *			Tempe, AZ  85280-2528
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/

#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "cheatsig.h"
#include "cheatah.h"
#include <swmgr.h>
#include <versekey.h>
#include <regex.h>
#include <gbfplain.h>
#include <thmlplain.h>
#include <string.h>


MainWindow *cheatahWindow = NULL;

/*	I'm going to try commenting out get_widget() - it no longer seems to be used	*/
/*	Note: this doesn't seem to have caused any problems so far.			*/
/*
GtkWidget*
get_widget                             (GtkWidget       *widget,
                                        gchar           *widget_name)
{
  GtkWidget *found_widget;

  if (widget->parent)
    widget = gtk_widget_get_toplevel (widget);
  found_widget = (GtkWidget*) gtk_object_get_data (GTK_OBJECT (widget),
                                                   widget_name);
  if (!found_widget)
    g_warning ("Widget not found: %s", widget_name);
  return found_widget;
}		
*/

/* This is an internally used function to set notebook tab widgets. */
void
set_notebook_tab                       (GtkWidget       *notebook,
                                        gint             page_num,
                                        GtkWidget       *widget)
{
  GtkNotebookPage *page;
  GtkWidget *notebook_page;

  page = (GtkNotebookPage*) g_list_nth (GTK_NOTEBOOK (notebook)->children, page_num)->data;
  notebook_page = page->child;
  gtk_widget_ref (notebook_page);
  gtk_notebook_remove_page (GTK_NOTEBOOK (notebook), page_num);
  gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), notebook_page,
                            widget, page_num);
  gtk_widget_unref (notebook_page);
}



MainWindow::MainWindow() {
	searchType_group = NULL;
	mainMgr          = new SWMgr();
	curMod           = NULL;
	chapDisplay      = 0;	// set in create
	entryDisplay     = 0;	// set in create
}


MainWindow::~MainWindow() {
	delete mainMgr;
	if (chapDisplay)
		delete chapDisplay;
	if (entryDisplay)
		delete entryDisplay;
}


GtkWidget* create_mainWindow () {
	GtkWidget *retWidget;
	cheatahWindow = new MainWindow();
	retWidget = cheatahWindow->create();
	cheatahWindow->initSWORD();
	return retWidget;
}

/*								*/
/*	Note: this seems to be a poor choice of a name for this function .	*/
/*	When  I accidentally left off the  parenthesis when trying to call it,	*/
/*	the compiler didn't complain, but it didn't execute, either.		*/
/* 	Could there be a macro or something by the same name?		*/
/*	At any rate, be careful with it.				*/
/*								*/
void destroy_mainWindow () {
	delete cheatahWindow;
}

GtkWidget *MainWindow::create() {
	mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_object_set_data (GTK_OBJECT (mainWindow), "mainWindow", mainWindow);
	gtk_window_set_title (GTK_WINDOW (mainWindow), "Cheatah - SWORD Quick Lookup / Search");
	gtk_window_set_policy (GTK_WINDOW (mainWindow), TRUE, TRUE, FALSE);
	gtk_widget_set_usize(GTK_WIDGET(mainWindow), 580, 360);
	gtk_signal_connect(GTK_OBJECT(mainWindow),
		       "destroy",
		       GTK_SIGNAL_FUNC(gtk_main_quit),
		       NULL);


	mainPanel = gtk_vbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "mainPanel", mainPanel);
  gtk_widget_show (mainPanel);
  gtk_container_add (GTK_CONTAINER (mainWindow), mainPanel);

  headerPanel = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "headerPanel", headerPanel);
  gtk_widget_show (headerPanel);
  gtk_box_pack_start (GTK_BOX (mainPanel), headerPanel, FALSE, TRUE, 0);

  handlebox3 = gtk_handle_box_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "handlebox3", handlebox3);
  gtk_widget_show (handlebox3);
  gtk_box_pack_start (GTK_BOX (headerPanel), handlebox3, TRUE, TRUE, 0);

  menubar4 = gtk_menu_bar_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menubar4", menubar4);
  gtk_widget_show (menubar4);
  gtk_container_add (GTK_CONTAINER (handlebox3), menubar4);

  File = gtk_menu_item_new_with_label ("File");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "File", File);
  gtk_widget_show (File);
  gtk_container_add (GTK_CONTAINER (menubar4), File);

  menuFile = gtk_menu_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menuFile", menuFile);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (File), menuFile);

  Exit3 = gtk_menu_item_new_with_label ("Exit");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "Exit3", Exit3);
  gtk_widget_show (Exit3);
  gtk_container_add (GTK_CONTAINER (menuFile), Exit3);
  gtk_signal_connect (GTK_OBJECT (Exit3), "activate",
                      GTK_SIGNAL_FUNC (gtk_main_quit),
                      NULL);

  
  View3 = gtk_menu_item_new_with_label ("View");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "View3", View3);
  gtk_widget_show (View3);
  gtk_container_add (GTK_CONTAINER (menubar4), View3);
  gtk_signal_connect (GTK_OBJECT (View3), "activate",
                      GTK_SIGNAL_FUNC (on_View3_activate),
                      NULL);

  menuView = gtk_menu_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menuView", menuView);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (View3), menuView);

  commentaries = gtk_menu_item_new_with_label ("Commentaries");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "commentaries", commentaries);
  gtk_widget_show (commentaries);

  menuCommentaries = gtk_menu_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menuCommentaries", menuCommentaries);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (commentaries), menuCommentaries);

  dictionaries = gtk_menu_item_new_with_label ("Dictionaries");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "Dictionaries", dictionaries);
  gtk_widget_show (dictionaries);

  menuDictionaries = gtk_menu_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menuDictionaries", menuDictionaries);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (dictionaries), menuDictionaries);



  Help = gtk_menu_item_new_with_label ("Help");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "Help", Help);
  gtk_widget_show (Help);
  gtk_container_add (GTK_CONTAINER (menubar4), Help);
  gtk_signal_connect (GTK_OBJECT (Help), "activate",
                      GTK_SIGNAL_FUNC (on_Help_activate),
                      NULL);
  gtk_menu_item_right_justify (GTK_MENU_ITEM (Help));

  menuHelp = gtk_menu_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "menuHelp", menuHelp);
  gtk_menu_item_set_submenu (GTK_MENU_ITEM (Help), menuHelp);

  About = gtk_menu_item_new_with_label ("About");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "About", About);
  gtk_widget_show (About);
  gtk_container_add (GTK_CONTAINER (menuHelp), About);
  gtk_signal_connect (GTK_OBJECT (About), "activate",
                      GTK_SIGNAL_FUNC (on_About_activate),
                      NULL);

  handlebox4 = gtk_handle_box_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "handlebox4", handlebox4);
  gtk_widget_show (handlebox4);
  gtk_box_pack_start (GTK_BOX (headerPanel), handlebox4, TRUE, TRUE, 0);

  hbox6 = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "hbox6", hbox6);
  gtk_widget_show (hbox6);
  gtk_container_add (GTK_CONTAINER (handlebox4), hbox6);

  label2 = gtk_label_new ("FreeForm Lookup:");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "label2", label2);
  gtk_widget_show (label2);
  gtk_box_pack_start (GTK_BOX (hbox6), label2, FALSE, TRUE, 0);
  gtk_label_set_justify (GTK_LABEL (label2), GTK_JUSTIFY_RIGHT);
  gtk_misc_set_padding (GTK_MISC (label2), 2, 0);

  lookupText = gtk_entry_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "lookupText", lookupText);
  gtk_widget_show (lookupText);
  gtk_box_pack_start (GTK_BOX (hbox6), lookupText, FALSE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (lookupText), "changed",
                      GTK_SIGNAL_FUNC (on_lookupText_changed),
                      NULL);

  hbox2 = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "hbox2", hbox2);
  gtk_widget_show (hbox2);
  gtk_box_pack_start (GTK_BOX (mainPanel), hbox2, TRUE, TRUE, 0);


/*
  textScrolledWindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "textScrolledWindow", textScrolledWindow);
  gtk_widget_show (textScrolledWindow);
  gtk_box_pack_start (GTK_BOX (hbox2), textScrolledWindow, FALSE, FALSE, 0);
*/

  moduleText = gtk_text_new (NULL, NULL);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "moduleText", moduleText);
  gtk_widget_show (moduleText);
//  gtk_container_add (GTK_CONTAINER (textScrolledWindow), moduleText);
  gtk_box_pack_start (GTK_BOX (hbox2), moduleText, TRUE, TRUE, 0);
  gtk_text_set_editable (GTK_TEXT (moduleText), FALSE);
  gtk_text_set_word_wrap (GTK_TEXT (moduleText), TRUE);
  gtk_widget_realize (moduleText);

	/* Add a vertical scrollbar to the GtkText widget */
	textScrollbar = gtk_vscrollbar_new (GTK_TEXT (moduleText)->vadj);
	gtk_box_pack_start (GTK_BOX (hbox2), textScrollbar, FALSE, FALSE, 0);
	gtk_widget_show (textScrollbar);


/*
  handlebox5 = gtk_handle_box_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "handlebox5", handlebox5);
  gtk_widget_show (handlebox5);
  gtk_box_pack_start (GTK_BOX (hbox2), handlebox5, FALSE, FALSE, 0);
  gtk_container_border_width (GTK_CONTAINER (handlebox5), 5);
*/

  searchPanel = gtk_vbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchPanel", searchPanel);
  gtk_widget_show (searchPanel);
  gtk_box_pack_start (GTK_BOX (hbox2), searchPanel, FALSE, FALSE, 0);
//  gtk_container_add (GTK_CONTAINER (handlebox5), searchPanel);

  hbox4 = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "hbox4", hbox4);
  gtk_widget_show (hbox4);
  gtk_box_pack_start (GTK_BOX (searchPanel), hbox4, FALSE, FALSE, 0);

  searchText = gtk_entry_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchText", searchText);
  gtk_widget_show (searchText);
  gtk_box_pack_start (GTK_BOX (hbox4), searchText, TRUE, TRUE, 0);

  searchButton = gtk_button_new_with_label ("Search");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchButton", searchButton);
  gtk_widget_show (searchButton);
  gtk_box_pack_start (GTK_BOX (hbox4), searchButton, FALSE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (searchButton), "clicked",
                      GTK_SIGNAL_FUNC (on_searchButton_clicked),
                      NULL);

  searchSettingsPanel = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchSettingsPanel", searchSettingsPanel);
  gtk_widget_show (searchSettingsPanel);
  gtk_box_pack_start (GTK_BOX (searchPanel), searchSettingsPanel, FALSE, FALSE, 0);

  searchTypePanel = gtk_vbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchTypePanel", searchTypePanel);
  gtk_widget_show (searchTypePanel);
  gtk_box_pack_start (GTK_BOX (searchSettingsPanel), searchTypePanel, FALSE, FALSE, 0);

  multiWordSearch = gtk_radio_button_new_with_label (searchType_group, "Multi Word");
  searchType_group = gtk_radio_button_group (GTK_RADIO_BUTTON (multiWordSearch));
  gtk_object_set_data (GTK_OBJECT (mainWindow), "multiWordSearch", multiWordSearch);
  gtk_widget_show (multiWordSearch);
  gtk_box_pack_start (GTK_BOX (searchTypePanel), multiWordSearch, FALSE, FALSE, 0);

  phraseSearch = gtk_radio_button_new_with_label (searchType_group, "Exact Phrase");
  searchType_group = gtk_radio_button_group (GTK_RADIO_BUTTON (phraseSearch));
  gtk_object_set_data (GTK_OBJECT (mainWindow), "phraseSearch", phraseSearch);
  gtk_widget_show (phraseSearch);
  gtk_box_pack_start (GTK_BOX (searchTypePanel), phraseSearch, FALSE, FALSE, 0);

  regexSearch = gtk_radio_button_new_with_label (searchType_group, "Regular Expression");
  searchType_group = gtk_radio_button_group (GTK_RADIO_BUTTON (regexSearch));
  gtk_object_set_data (GTK_OBJECT (mainWindow), "regexSearch", regexSearch);
  gtk_widget_show (regexSearch);
  gtk_box_pack_start (GTK_BOX (searchTypePanel), regexSearch, FALSE, FALSE, 0);


  searchOptionsPanel = gtk_vbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "searchOptionsPanel", searchOptionsPanel);
  gtk_widget_show (searchOptionsPanel);
  gtk_box_pack_start (GTK_BOX (searchSettingsPanel), searchOptionsPanel, FALSE, FALSE, 0);

  caseSensitive = gtk_check_button_new_with_label ("Case Sensitive");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "caseSensitive", caseSensitive);
  gtk_widget_show (caseSensitive);
  gtk_box_pack_start (GTK_BOX (searchOptionsPanel), caseSensitive, FALSE, FALSE, 0);

  GtkWidget *resultPanel = gtk_hbox_new (FALSE, 0);
  gtk_object_set_data (GTK_OBJECT (mainWindow), "resultPanel", resultPanel);
  gtk_widget_show (resultPanel);
  gtk_box_pack_start (GTK_BOX (searchPanel), resultPanel, TRUE, TRUE, 0);
  resultList = gtk_clist_new(1);
  gtk_object_set_data(GTK_OBJECT (mainWindow), "resultList", resultList);
//  gtk_clist_set_policy(GTK_CLIST(resultList), GTK_POLICY_AUTOMATIC, 0);
//  gtk_clist_set_border(GTK_CLIST(resultList), GTK_SHADOW_ETCHED_IN);
  gtk_widget_show (resultList);
  gtk_box_pack_start (GTK_BOX (resultPanel), resultList, TRUE, TRUE, 0);
  gtk_signal_connect (GTK_OBJECT (resultList), "select_row",
                      GTK_SIGNAL_FUNC (on_resultList_selection_changed),
                      NULL);
	/* Add a vertical scrollbar to the GtkCList widget */
	textScrollbar = gtk_vscrollbar_new (NULL);
	gtk_clist_set_vadjustment (GTK_CLIST(resultList), gtk_range_get_adjustment(GTK_RANGE(textScrollbar)));
	gtk_box_pack_start (GTK_BOX (resultPanel), textScrollbar, FALSE, FALSE, 0);
	gtk_widget_show (textScrollbar);


/*
  statusbar1 = gtk_statusbar_new ();
  gtk_object_set_data (GTK_OBJECT (mainWindow), "statusbar1", statusbar1);
  gtk_widget_show (statusbar1);
  gtk_box_pack_start (GTK_BOX (mainPanel), statusbar1, FALSE, TRUE, 0);
*/

  arrow1 = gtk_button_new_with_label ("[<]");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "arrow1", arrow1);
  gtk_widget_show (arrow1);
  gtk_box_pack_start (GTK_BOX (headerPanel), arrow1, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (arrow1), "clicked",
                      GTK_SIGNAL_FUNC (on_arrow1_button_press_event),
                      NULL);

  arrow2 = gtk_button_new_with_label ("[>]");
  gtk_object_set_data (GTK_OBJECT (mainWindow), "arrow2", arrow2);
  gtk_widget_show (arrow2);
  gtk_box_pack_start (GTK_BOX (headerPanel), arrow2, FALSE, FALSE, 0);
  gtk_signal_connect (GTK_OBJECT (arrow2), "clicked",
                      GTK_SIGNAL_FUNC (on_arrow2_button_press_event),
                      NULL);


	statusbar1 = gtk_label_new ("");
	gtk_object_set_data (GTK_OBJECT (mainWindow), "statusbar1", statusbar1);
	gtk_widget_show (statusbar1);
	gtk_box_pack_start (GTK_BOX (mainPanel), statusbar1, FALSE, FALSE, 0);
	gtk_label_set_justify (GTK_LABEL (statusbar1), GTK_JUSTIFY_LEFT);
	gtk_misc_set_padding (GTK_MISC (statusbar1), 2, 0);


	GTKEntryDisp::__initialize();
	chapDisplay = new GTKChapDisp(moduleText);
	entryDisplay = new GTKEntryDisp(moduleText);

	return mainWindow;
}

void MainWindow::initSWORD() {

	GtkWidget *menuChoice;
	int viewNumber = 1;
	char menuName[64];
	ModMap::iterator it;
	SectionMap::iterator sit;
	ConfigEntMap::iterator eit;
	char *font;
	SWModule *curMod;

/*	First, check and see whether SWMgr found any installed books.  If not, tell the user what the problem is.	*/
/*	Print a short notice to stderr, for use when the program is invoked from the command line,		*/
/*	and also put  a bit longer message into the spot where bible text would otherwise show up. 		*/
/*	Then, return out of this function, because there's nothing left to do.					*/

	if (mainMgr->Modules.empty()==TRUE) {
		fprintf(stderr,"SWMgr: Can't find 'mods.conf' or 'mods.d'.  Try setting:\n\tSWORD_PATH=<directory containing mods.conf>\n\tOr see the README file for a full description of setup options.\n\t");

		gtk_text_set_point(GTK_TEXT(moduleText), 0);
		gtk_text_forward_delete (GTK_TEXT (moduleText), gtk_text_get_length((GTK_TEXT(moduleText))));
		int curPos = 0;
		gtk_text_freeze (GTK_TEXT(moduleText));
		gtk_text_insert(GTK_TEXT(moduleText), NULL, &moduleText->style->black, NULL, "\nCheatah was unable to find any books installed!\n\n", -1);
		gtk_text_insert(GTK_TEXT(moduleText), NULL, &moduleText->style->black, NULL, "They should be listed in a configuration file named either: ", -1);
		gtk_text_insert(GTK_TEXT(moduleText), NULL, &moduleText->style->black, NULL, "'mods.conf' or 'mods.d'. \n\n", -1);
		gtk_text_insert(GTK_TEXT(moduleText), NULL, &moduleText->style->black, NULL, "Try setting:\n\tSWORD_PATH=<directory containing mods.conf>\n\t",-1);
		gtk_text_insert(GTK_TEXT(moduleText), NULL, &moduleText->style->black, NULL, "Or see the README file for a full description of setup options.\n", -1);
		gtk_text_set_point(GTK_TEXT(moduleText), curPos);
		gtk_text_thaw(GTK_TEXT(moduleText));
						
		return;
	}

/*
* Create filters to use, depending on the needs of the installed modules.
* Right now, basically just handling GBF files and converting them to plain
* text for display.  So far, I haven't found any modules that specify
* anything other than GBF, but I've dropped in code to 
* install the thtml to plain filter just in case, since it's available.
* Question: I'm installing this as a display filter - would it make more
* sense to install it is a raw filter, so that I could use "plain" as the
* base for any strip filters we may need?  Or is that used for something else,
* like compression or decyphering locked books?
*/

	gbftoplain = new GBFPlain();
	thmlplain = new ThMLPlain();

/*
*	Next, if SWMgr did find  some book modules installed , hook them up to any filters needed
*	and set up the menues to reflect them.
*	Pick a default module to show on startup.
*/
		
	for (it = mainMgr->Modules.begin(); it != mainMgr->Modules.end(); it++) {
		curMod = (*it).second;
		menuChoice = gtk_menu_item_new_with_label (curMod->Name());
		sprintf(menuName, "viewMod%d", viewNumber++);
		gtk_object_set_data (GTK_OBJECT (mainWindow), menuName, menuChoice);
		gtk_widget_show (menuChoice);
		gtk_signal_connect(GTK_OBJECT (menuChoice), "activate",
			      GTK_SIGNAL_FUNC (on_viewMod_activate),
			      g_strdup(curMod->Name()));

		if ((sit = mainMgr->config->Sections.find(curMod->Name())) != mainMgr->config->Sections.end()) {
			if ((eit = (*sit).second.find("SourceType")) != (*sit).second.end()) {
				if (!strcasecmp((*eit).second.c_str(), "GBF")) {
					curMod->AddRenderFilter(gbftoplain);
				}
				else if (!strcasecmp((*eit).second.c_str(), "ThML")) {
					curMod->AddRenderFilter(thmlplain);
				}
			}
		}

		if (!strcmp((*it).second->Type(), "Biblical Texts")) {
			gtk_container_add (GTK_CONTAINER (menuView), menuChoice);
			font = 0;
			if ((sit = mainMgr->config->Sections.find(curMod->Name())) != mainMgr->config->Sections.end()) {
				if ((eit = (*sit).second.find("Font")) != (*sit).second.end()) {
					font = (char *)(*eit).second.c_str();
				}
			}
//			CreateTextPane((*it).second, font);
			curMod->Disp(chapDisplay);	// set our GTKChapDisp object up for the diplayer of each Biblical Text module
			if (!this->curMod) 	// set currently selected module for app to first module from SWMgr (Bible Texts get first preference
				this->curMod = curMod;
		}
		else	{
			curMod->Disp(entryDisplay);	// set our GTKEntryDisp object up for the diplayer of each module other than Biblical Texts
			if (!strcmp(curMod->Type(), "Commentaries")) {
				gtk_container_add (GTK_CONTAINER (menuCommentaries), menuChoice);
	//			CreateCommentPane((*it).second);
			}
			if (!strcmp(curMod->Type(), "Lexicons / Dictionaries")) {
				gtk_container_add (GTK_CONTAINER (menuDictionaries), menuChoice);
	//			CreateLDPane((*it).second);
			}
		}


	}
	gtk_container_add (GTK_CONTAINER (menuView), commentaries);
	gtk_container_add (GTK_CONTAINER (menuView), dictionaries);

	if (!this->curMod)			// We didn't find a bible text, so set currently selected module for app to first module from SWMgr
		this->curMod = curMod;	// Should be o.k. to do this, because we've already tested to see if SWMgr thinks it found something
	assert(this->curMod!=NULL);
	if(this->curMod!=NULL)		// Go ahead and display default module
		lookupTextChanged();
}


void MainWindow::lookupTextChanged() {
	string keyText;
	gchar *entryText;
	char tmpBuf[255];

	entryText = gtk_entry_get_text(GTK_ENTRY(lookupText));
	keyText = entryText;

	if (curMod) {
		SWKey *key = curMod->CreateKey();
		VerseKey *vkey = SWDYNAMIC_CAST(VerseKey, key);
		key->Persist(1);
		if (vkey) {
			vkey->Headings(1);
			vkey->AutoNormalize(0);
		}
		*key = keyText.c_str();
		curMod->setKey(*key);
		curMod->Display();
		sprintf(tmpBuf, "%s (%s)", curMod->KeyText(), curMod->Name());
		gtk_label_set(GTK_LABEL(statusbar1), tmpBuf);
		curMod->setKey(keyText.c_str());
		delete key;
	}
}

void MainWindow::viewModActivate(GtkMenuItem *sender, gchar *modName) {
	ModMap::iterator it;

	it = mainMgr->Modules.find(modName);
	if (it != mainMgr->Modules.end()) {
		curMod = (*it).second;
		lookupTextChanged();
	}
	else	curMod = 0;
}


void MainWindow::navigateButtonClicked(int direction) {
	if (curMod) {
		if (direction)
			(*curMod)++;
		else	(*curMod)--;
		(const char *)*curMod;  // snap to closest locations
		const gchar *text = curMod->KeyText();
		gtk_entry_set_text(GTK_ENTRY(lookupText), text);
//		curMod->Display();
	}
}


void MainWindow::searchButtonClicked() {
	string srchText;
	gchar *entryText;
	const gchar *resultText;
	gchar **clistText = (gchar **)&resultText;


	gtk_clist_clear(GTK_CLIST(resultList));

	entryText = gtk_entry_get_text(GTK_ENTRY(searchText));
	srchText = entryText;

	if (curMod) {
		int searchType = GTK_TOGGLE_BUTTON(regexSearch)->active ? 0 : GTK_TOGGLE_BUTTON(phraseSearch)->active ? -1 : -2;
		int searchParams = GTK_TOGGLE_BUTTON(caseSensitive)->active ? 0 : REG_ICASE;
		gtk_clist_freeze(GTK_CLIST(resultList));
		for (ListKey searchResults = curMod->Search(srchText.c_str(), searchType, searchParams); !searchResults.Error(); searchResults++) {
			resultText = (const char *)searchResults;
			gtk_clist_append(GTK_CLIST(resultList), clistText);
		}
		gtk_clist_thaw(GTK_CLIST(resultList));
	}
}


void MainWindow::resultListSelectionChanged(GtkWidget *clist, gint row, gint column, GdkEventButton *event, gpointer data) {
	gchar *text;

	gtk_clist_get_text(GTK_CLIST(resultList), row, column, &text);

	if (text) {
		gtk_entry_set_text(GTK_ENTRY(lookupText), text);
	}
}

GdkColor GTKEntryDisp::colourBlue;
GdkColor GTKEntryDisp::colourGreen;

/*										*/
/*	Note: we have a warning that should be fixed here.  GTKEntryDisp::Display() is defined	*/
/*	as returning char, but doesn't have a return statement				*/
/*	What was intended - a return code?  That doesn't seem right, because those are	*/
/*	usually int's.  But it isn't defined as returning a char*, so it doesn't seem		*/
/*	likely that it's intended to return the text involved.					*/
/*										*/
char GTKEntryDisp::Display(SWModule &imodule) {
	char tmpBuf[255];

	gtk_text_set_point(GTK_TEXT(gtkText), 0);
	gtk_text_forward_delete (GTK_TEXT (gtkText), gtk_text_get_length((GTK_TEXT(gtkText))));
	int curPos = 0;
	(const char *)imodule;	// snap to entry
	gtk_text_freeze (GTK_TEXT(gtkText));
	sprintf(tmpBuf, "[%s] ", imodule.KeyText());
	gtk_text_insert(GTK_TEXT(gtkText), NULL, &colourBlue, NULL, tmpBuf, -1);
	gtk_text_insert(GTK_TEXT(gtkText), NULL, &gtkText->style->black, NULL, (const char *)imodule, -1);
	gtk_text_set_point(GTK_TEXT(gtkText), curPos);
	gtk_text_thaw(GTK_TEXT(gtkText));
}

/*											*/
/*	Note: we have a warning that should be fixed here.  GTKChapDisp::Display() is defined		*/
/*	as returning char, but doesn't have a return statement.					*/
/*	What was intended - a return code?  That doesn't seem right, because those are		*/
/*	usually int's.  But it isn't defined as returning a char*, so it doesn't seem			*/
/*	likely that it's intended to return the text involved.						*/
/*											*/

char GTKChapDisp::Display(SWModule &imodule) {
	char tmpBuf[255];

	gtk_text_set_point(GTK_TEXT(gtkText), 0);
	gtk_text_forward_delete (GTK_TEXT (gtkText), gtk_text_get_length((GTK_TEXT(gtkText))));
	VerseKey *key = (VerseKey *)(SWKey *)imodule;
	int curVerse = key->Verse();
	int curChapter = key->Chapter();
	int curBook = key->Book();
	int curPos = 0;
	gfloat adjVal;
	gtk_text_freeze (GTK_TEXT(gtkText));
	for (key->Verse(1); (key->Book() == curBook && key->Chapter() == curChapter && !imodule.Error()); imodule++) {
		sprintf(tmpBuf, "%d. ", key->Verse());
		gtk_text_insert(GTK_TEXT(gtkText), NULL, &colourBlue, NULL, tmpBuf, -1);
		if (key->Verse() == curVerse) {
			gtk_text_thaw(GTK_TEXT(gtkText));
			adjVal = GTK_TEXT(gtkText)->vadj->upper;
			curPos = gtk_text_get_length(GTK_TEXT(gtkText));
			gtk_text_insert(GTK_TEXT(gtkText), NULL, &colourGreen, NULL, (const char *)imodule, -1);
			gtk_text_freeze (GTK_TEXT(gtkText));
		}
		else {
			gtk_text_insert(GTK_TEXT(gtkText), NULL, &gtkText->style->black, NULL, (const char *)imodule, -1);
		}
		gtk_text_insert(GTK_TEXT(gtkText), NULL, &gtkText->style->black, NULL, "  ", -1);
	}
	gtk_text_set_point(GTK_TEXT(gtkText), curPos);
	gtk_text_thaw(GTK_TEXT(gtkText));
	adjVal -= (GTK_TEXT(gtkText)->vadj->page_size / 2);
	gtk_adjustment_set_value(GTK_TEXT(gtkText)->vadj, (adjVal>0)?adjVal:0);
	key->Verse(1);
	key->Chapter(1);
	key->Book(curBook);
	key->Chapter(curChapter);
	key->Verse(curVerse);
}