/* 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 #include #include "cheatsig.h" #include "cheatah.h" #include #include #include #include #include #include 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=\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=\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, >kText->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, >kText->style->black, NULL, (const char *)imodule, -1); } gtk_text_insert(GTK_TEXT(gtkText), NULL, >kText->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); }