diff options
Diffstat (limited to 'bindings/flatapi.cpp')
| -rw-r--r-- | bindings/flatapi.cpp | 1578 |
1 files changed, 1339 insertions, 239 deletions
diff --git a/bindings/flatapi.cpp b/bindings/flatapi.cpp index 55cf083..1c6872c 100644 --- a/bindings/flatapi.cpp +++ b/bindings/flatapi.cpp @@ -3,9 +3,9 @@ * flatapi.cpp - This file contains an api usable by non-C++ * environments * - * $Id: flatapi.cpp 2921 2013-07-28 17:21:44Z scribe $ + * $Id: flatapi.cpp 3226 2014-05-02 03:01:35Z greg.hellings $ * - * Copyright 2002-2013 CrossWire Bible Society (http://www.crosswire.org) + * Copyright 2002-2014 CrossWire Bible Society (http://www.crosswire.org) * CrossWire Bible Society * P. O. Box 2528 * Tempe, AZ 85280-2528 @@ -21,361 +21,1461 @@ * */ -#include <stdio.h> - -#include <rawtext.h> -#include <rawcom.h> -#include <rawld.h> -#include <strkey.h> -#include <listkey.h> -#include <versekey.h> +#include <iostream> +#include <vector> +#include <map> + +#include <swversion.h> #include <swmgr.h> -#include <markupfiltmgr.h> -#ifndef NO_SWORD_NAMESPACE -using namespace sword; -#endif +#include <installmgr.h> +#include <remotetrans.h> +#include <versekey.h> +#include <treekeyidx.h> +#include <filemgr.h> +#include <swbuf.h> +#include <localemgr.h> +#include <utilstr.h> +#include "corba/orbitcpp/webmgr.hpp" + extern "C" { -#include "flatapi.h" +#include <flatapi.h> } -typedef struct { - ModMap::iterator it; -// void *it; - ModMap::iterator end; -// void *end; -} ModItType; +using sword::VerseKey; +using sword::SWVersion; +using sword::SWBuf; +using sword::TreeKeyIdx; -//----------------------------------------------------------------- -// SWMgr methods +#define GETSWMGR(handle, failReturn) HandleSWMgr *hmgr = (HandleSWMgr *)handle; if (!hmgr) return failReturn; WebMgr *mgr = hmgr->mgr; if (!mgr) return failReturn; + +#define GETSWMODULE(handle, failReturn) HandleSWModule *hmod = (HandleSWModule *)handle; if (!hmod) return failReturn; SWModule *module = hmod->mod; if (!module) return failReturn; + +#define GETINSTMGR(handle, failReturn) HandleInstMgr *hinstmgr = (HandleInstMgr *)handle; if (!hinstmgr) return failReturn; InstallMgr *installMgr = hinstmgr->installMgr; if (!installMgr) return failReturn; + +namespace { + + +void clearStringArray(const char ***stringArray) { + if (*stringArray) { + for (int i = 0; true; ++i) { + if ((*stringArray)[i]) { + delete [] (*stringArray)[i]; + } + else break; + } + free((*stringArray)); + (*stringArray) = 0; + } +} + + +void clearModInfo(org_crosswire_sword_ModInfo **modInfo) { + if (*modInfo) { + for (int i = 0; true; ++i) { + if ((*modInfo)[i].name) { + delete [] (*modInfo)[i].name; + delete [] (*modInfo)[i].description; + delete [] (*modInfo)[i].category; + delete [] (*modInfo)[i].language; + delete [] (*modInfo)[i].version; + delete [] (*modInfo)[i].delta; + } + else break; + } + free((*modInfo)); + (*modInfo) = 0; + } +} + + +struct pu { + char last; + SWHANDLE progressReporter; + + void init(SWHANDLE pr) { progressReporter = pr; last = 0; } +/* + pu(JNIEnv *env, jobject pr) : env(env), progressReporter(pr), last(0) {} + JNIEnv *env; + jobject progressReporter; +*/ +}; +void percentUpdate(char percent, void *userData) { + struct pu *p = (struct pu *)userData; + + if (percent != p->last) { + p->last = percent; +/* + jclass cls = p->env->GetObjectClass(p->progressReporter); + jmethodID mid = p->env->GetMethodID(cls, "progressReport", "(I)V"); + if (mid != 0) { + p->env->CallVoidMethod(p->progressReporter, mid, (jint)percent); + } +*/ + } +} + +class MyStatusReporter : public StatusReporter { +public: + int last; + SWHANDLE statusReporter; + MyStatusReporter() : last(0), statusReporter(0) {} + void init(SWHANDLE sr) { statusReporter = sr; last = 0; } + virtual void update(unsigned long totalBytes, unsigned long completedBytes) { + int p = (totalBytes > 0) ? (int)(74.0 * ((double)completedBytes / (double)totalBytes)) : 0; + for (;last < p; ++last) { + if (!last) { + SWBuf output; + output.setFormatted("[ File Bytes: %ld", totalBytes); + while (output.size() < 75) output += " "; + output += "]"; +// cout << output.c_str() << "\n "; + } +// cout << "-"; + } +// cout.flush(); + } + virtual void preStatus(long totalBytes, long completedBytes, const char *message) { + SWBuf output; + output.setFormatted("[ Total Bytes: %ld; Completed Bytes: %ld", totalBytes, completedBytes); + while (output.size() < 75) output += " "; + output += "]"; +// cout << "\n" << output.c_str() << "\n "; +// int p = (int)(74.0 * (double)completedBytes/totalBytes); +// for (int i = 0; i < p; ++i) { cout << "="; } +// cout << "\n\n" << message << "\n"; + last = 0; + } +}; + +class HandleSWModule { +public: + SWModule *mod; + char *renderBuf; + char *stripBuf; + char *renderHeader; + char *rawEntry; + char *configEntry; + struct pu peeuuu; + // making searchHits cache static saves memory only having a single + // outstanding copy, but also is not threadsafe. Remove static here + // and fix compiling bugs and add clearSearchHits() to d-tor to change + static org_crosswire_sword_SearchHit *searchHits; + static const char **entryAttributes; + static const char **parseKeyList; + static const char **keyChildren; + + HandleSWModule(SWModule *mod) { + this->mod = mod; + this->renderBuf = 0; + this->stripBuf = 0; + this->renderHeader = 0; + this->rawEntry = 0; + this->configEntry = 0; + } + ~HandleSWModule() { + delete [] renderBuf; + delete [] stripBuf; + delete [] renderHeader; + delete [] rawEntry; + delete [] configEntry; + } + + static void clearSearchHits() { + if (searchHits) { + for (int i = 0; true; ++i) { + if (searchHits[i].modName) { + delete [] searchHits[i].key; + } + else break; + } + free(searchHits); + searchHits = 0; + } + } + static void clearEntryAttributes() { + clearStringArray(&entryAttributes); + } + static void clearParseKeyList() { + clearStringArray(&parseKeyList); + } + static void clearKeyChildren() { + clearStringArray(&keyChildren); + } +}; + + +class HandleSWMgr { +public: + WebMgr *mgr; + org_crosswire_sword_ModInfo *modInfo; + std::map<SWModule *, HandleSWModule *> moduleHandles; + SWBuf filterBuf; + static const char **globalOptions; + static const char **globalOptionValues; + static const char **availableLocales; + + HandleSWMgr(WebMgr *mgr) { + this->mgr = mgr; + this->modInfo = 0; + } + + void clearModInfo() { + ::clearModInfo(&modInfo); + } + + ~HandleSWMgr() { + clearModInfo(); + for (std::map<SWModule *, HandleSWModule *>::iterator it = moduleHandles.begin(); it != moduleHandles.end(); ++it) { + delete it->second; + } + delete mgr; + } + + HandleSWModule *getModuleHandle(SWModule *mod) { + if (!mod) return 0; + if (moduleHandles.find(mod) == moduleHandles.end()) { + moduleHandles[mod] = new HandleSWModule(mod); + } + return moduleHandles[mod]; + } + + static void clearGlobalOptions() { + clearStringArray(&globalOptions); + } + + static void clearGlobalOptionValues() { + clearStringArray(&globalOptionValues); + } + + static void clearAvailableLocales() { + clearStringArray(&availableLocales); + } +}; + + +class HandleInstMgr { +public: + static const char **remoteSources; + InstallMgr *installMgr; + org_crosswire_sword_ModInfo *modInfo; + std::map<SWModule *, HandleSWModule *> moduleHandles; + + MyStatusReporter statusReporter; + HandleInstMgr() : installMgr(0), modInfo(0) {} + HandleInstMgr(InstallMgr *mgr) { + this->installMgr = installMgr; + this->modInfo = 0; + } + + ~HandleInstMgr() { + clearModInfo(); + for (std::map<SWModule *, HandleSWModule *>::iterator it = moduleHandles.begin(); it != moduleHandles.end(); ++it) { + delete it->second; + } + delete installMgr; + } + + HandleSWModule *getModuleHandle(SWModule *mod) { + if (!mod) return 0; + if (moduleHandles.find(mod) == moduleHandles.end()) { + moduleHandles[mod] = new HandleSWModule(mod); + } + return moduleHandles[mod]; + } + + static void clearRemoteSources() { + clearStringArray(&remoteSources); + } + + void clearModInfo() { + ::clearModInfo(&modInfo); + } +}; + + +org_crosswire_sword_SearchHit *HandleSWModule::searchHits = 0; +const char **HandleSWModule::entryAttributes = 0; +const char **HandleSWModule::parseKeyList = 0; +const char **HandleSWModule::keyChildren = 0; + +const char **HandleSWMgr::globalOptions = 0; +const char **HandleSWMgr::globalOptionValues = 0; +const char **HandleSWMgr::availableLocales = 0; + +const char **HandleInstMgr::remoteSources = 0; + +class InitStatics { +public: + InitStatics() { +// these are redundant with the static declarations above, but ??? doesn't hurt + HandleSWModule::searchHits = 0; + HandleSWModule::entryAttributes = 0; + HandleSWModule::parseKeyList = 0; + HandleSWModule::keyChildren = 0; + + HandleSWMgr::globalOptions = 0; + HandleSWMgr::globalOptionValues = 0; + HandleSWMgr::availableLocales = 0; + + HandleInstMgr::remoteSources = 0; + } + ~InitStatics() { + HandleSWModule::clearSearchHits(); + HandleSWModule::clearEntryAttributes(); + HandleSWModule::clearParseKeyList(); + HandleSWModule::clearKeyChildren(); + + HandleSWMgr::clearGlobalOptions(); + HandleSWMgr::clearGlobalOptionValues(); + + HandleInstMgr::clearRemoteSources(); + } +} _initStatics; + + + +} + + + + +// +// SWModule methods +// // -extern "C" SWHANDLE SWMgr_new(char filterType) { - return (SWHANDLE) new SWMgr(new MarkupFilterMgr(filterType)); + +/* + * Class: org_crosswire_sword_SWModule + * Method: terminateSearch + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_terminateSearch + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, ); + + module->terminateSearch = true; } +/* + * Class: org_crosswire_sword_SWModule + * Method: search + * Signature: (Ljava/lang/String;IJLjava/lang/String;Lorg/crosswire/android/sword/SWModule/SearchProgressReporter;)[Lorg/crosswire/android/sword/SWModule/SearchHit; + */ +const struct org_crosswire_sword_SearchHit * SWDLLEXPORT org_crosswire_sword_SWModule_search + (SWHANDLE hSWModule, const char *searchString, int searchType, long flags, const char *scope, SWHANDLE progressReporter) { -// SWConfig *, SWConfig *, bool, SWFilterMgr * -SWHANDLE SWMgr_newEx(SWHANDLE hiconfig, SWHANDLE hisysconfig, char autoload, SWHANDLE hfilterMgr) { - SWConfig *iconfig = (SWConfig *)hiconfig; - SWConfig *isysconfig = (SWConfig *)hisysconfig; - SWFilterMgr *filterMgr = (SWFilterMgr *)hfilterMgr; + GETSWMODULE(hSWModule, 0); + + hmod->clearSearchHits(); + + sword::ListKey lscope; + sword::ListKey result; + + + hmod->peeuuu.init(progressReporter); + if ((scope) && (strlen(scope)) > 0) { + sword::SWKey *p = module->createKey(); + sword::VerseKey *parser = SWDYNAMIC_CAST(VerseKey, p); + if (!parser) { + delete p; + parser = new VerseKey(); + } + *parser = module->getKeyText(); + lscope = parser->parseVerseList(scope, *parser, true); + result = module->search(searchString, searchType, flags, &lscope, 0, &percentUpdate, &(hmod->peeuuu)); + delete parser; + } + else result = module->search(searchString, searchType, flags, 0, 0, &percentUpdate, &(hmod->peeuuu)); + + int count = 0; + for (result = sword::TOP; !result.popError(); result++) count++; + + // if we're sorted by score, let's re-sort by verse, because Java can always re-sort by score + result = sword::TOP; + if ((count) && (long)result.getElement()->userData) + result.sort(); + + struct org_crosswire_sword_SearchHit *retVal = (struct org_crosswire_sword_SearchHit *)calloc(count+1, sizeof(struct org_crosswire_sword_SearchHit)); - return (SWHANDLE) new SWMgr(iconfig, isysconfig, autoload, filterMgr); + int i = 0; + for (result = sword::TOP; !result.popError(); result++) { + // don't alloc this; we have a persistent const char * in SWModule we can just reference + retVal[i].modName = module->getName(); + stdstr(&(retVal[i].key), assureValidUTF8(result.getShortText())); + retVal[i++].score = (long)result.getElement()->userData; + // in case we limit count to a max number of hits + if (i >= count) break; + } + hmod->searchHits = retVal; + return retVal; } +/* + * Class: org_crosswire_sword_SWModule + * Method: error + * Signature: ()C + */ +char SWDLLEXPORT org_crosswire_sword_SWModule_popError + (SWHANDLE hSWModule) { -void SWMgr_delete(SWHANDLE hmgr) { - SWMgr *mgr = (SWMgr *)hmgr; - if (mgr) - delete mgr; + GETSWMODULE(hSWModule, -1); + + return module->popError(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getEntrySize + * Signature: ()J + */ +long SWDLLEXPORT org_crosswire_sword_SWModule_getEntrySize + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); -SWHANDLE SWMgr_getConfig(SWHANDLE hmgr) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? (SWHANDLE)mgr->config : 0; + return module->getEntrySize(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getEntryAttribute + * Signature: (Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Z)[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_SWModule_getEntryAttribute + (SWHANDLE hSWModule, const char *level1, const char *level2, const char *level3, char filteredBool) { + + GETSWMODULE(hSWModule, 0); -SWHANDLE SWMgr_getModulesIterator(SWHANDLE hmgr) { - static ModItType it; + hmod->clearEntryAttributes(); - SWMgr *mgr = (SWMgr *)hmgr; - if (mgr) { - it.it = mgr->Modules.begin(); - it.end = mgr->Modules.end(); + module->renderText(); // force parse + std::vector<SWBuf> results; + + sword::AttributeTypeList &entryAttribs = module->getEntryAttributes(); + sword::AttributeTypeList::iterator i1Start, i1End; + sword::AttributeList::iterator i2Start, i2End; + sword::AttributeValue::iterator i3Start, i3End; + + if ((level1) && (*level1)) { + i1Start = entryAttribs.find(level1); + i1End = i1Start; + if (i1End != entryAttribs.end()) + ++i1End; + } + else { + i1Start = entryAttribs.begin(); + i1End = entryAttribs.end(); } - return (SWHANDLE)⁢ + for (;i1Start != i1End; ++i1Start) { + if ((level2) && (*level2)) { + i2Start = i1Start->second.find(level2); + i2End = i2Start; + if (i2End != i1Start->second.end()) + ++i2End; + } + else { + i2Start = i1Start->second.begin(); + i2End = i1Start->second.end(); + } + for (;i2Start != i2End; ++i2Start) { + if ((level3) && (*level3)) { + i3Start = i2Start->second.find(level3); + i3End = i3Start; + if (i3End != i2Start->second.end()) + ++i3End; + } + else { + i3Start = i2Start->second.begin(); + i3End = i2Start->second.end(); + } + for (;i3Start != i3End; ++i3Start) { + results.push_back(i3Start->second); + } + if (i3Start != i3End) + break; + } + if (i2Start != i2End) + break; + } + + const char **retVal = (const char **)calloc(results.size()+1, sizeof(const char *)); + for (int i = 0; i < (int)results.size(); i++) { + if (filteredBool) { + stdstr((char **)&(retVal[i]), assureValidUTF8(module->renderText(results[i].c_str()))); + } + else { + stdstr((char **)&(retVal[i]), assureValidUTF8(results[i].c_str())); + } + } + + hmod->entryAttributes = retVal; + return retVal; +} + +/* + * Class: org_crosswire_sword_SWModule + * Method: parseKeyList + * Signature: (Ljava/lang/String;)[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_SWModule_parseKeyList + (SWHANDLE hSWModule, const char *keyText) { + + GETSWMODULE(hSWModule, 0); + + hmod->clearParseKeyList(); + + sword::VerseKey *parser = dynamic_cast<VerseKey *>(module->getKey()); + const char **retVal = 0; + if (parser) { + sword::ListKey result; + result = parser->parseVerseList(keyText, *parser, true); + int count = 0; + for (result = sword::TOP; !result.popError(); result++) { + count++; + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + for (result = sword::TOP; !result.popError(); result++) { + stdstr((char **)&(retVal[count++]), assureValidUTF8(VerseKey(result).getOSISRef())); + } + } + else { + retVal = (const char **)calloc(2, sizeof(const char *)); + stdstr((char **)&(retVal[0]), assureValidUTF8(keyText)); + } + + hmod->parseKeyList = retVal; + return retVal; +} + +/* + * Class: org_crosswire_sword_SWModule + * Method: setKeyText + * Signature: (Ljava/lang/String;)V + */ +// Special values handled for VerseKey modules: +// [+-][book|chapter] - [de|in]crement by chapter or book +// (e.g. "+chapter" will increment the VerseKey 1 chapter) +// [=][key] - position absolutely and don't normalize +// (e.g. "jn.1.0" for John Chapter 1 intro; "jn.0.0" For Book of John Intro) +void SWDLLEXPORT org_crosswire_sword_SWModule_setKeyText + (SWHANDLE hSWModule, const char *keyText) { + + GETSWMODULE(hSWModule, ); + + sword::SWKey *key = module->getKey(); + sword::VerseKey *vkey = SWDYNAMIC_CAST(VerseKey, key); + if (vkey) { + if ((*keyText=='+' || *keyText=='-')) { + if (!sword::stricmp(keyText+1, "book")) { + vkey->setBook(vkey->getBook() + ((*keyText=='+')?1:-1)); + return; + } + else if (!sword::stricmp(keyText+1, "chapter")) { + vkey->setChapter(vkey->getChapter() + ((*keyText=='+')?1:-1)); + return; + } + } + else if (*keyText=='=') { + vkey->setIntros(true); + vkey->setAutoNormalize(false); + vkey->setText(keyText+1); + return; + } + } + + module->setKey(keyText); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getKeyText + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getKeyText + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); -SWHANDLE SWMgr_getModuleByName(SWHANDLE hmgr, const char *name) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? (SWHANDLE) mgr->Modules[name] : 0; + return module->getKeyText(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: hasKeyChildren + * Signature: ()Z + */ +char SWDLLEXPORT org_crosswire_sword_SWModule_hasKeyChildren + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + sword::SWKey *key = module->getKey(); + char retVal = 0; -const char *SWMgr_getPrefixPath(SWHANDLE hmgr) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? mgr->prefixPath : 0; + TreeKeyIdx *tkey = SWDYNAMIC_CAST(TreeKeyIdx, key); + if (tkey) { + retVal = tkey->hasChildren()?1:0; + } + return retVal; } +/* + * Class: org_crosswire_sword_SWModule + * Method: getKeyChildren + * Signature: ()[Ljava/lang/String; + */ + +// This method returns child nodes for a genbook, +// but has special handling if called on a VerseKey module: +// [0..7] [testament, book, chapter, verse, chapterMax, verseMax, bookName, osisRef] +const char ** SWDLLEXPORT org_crosswire_sword_SWModule_getKeyChildren + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + hmod->clearKeyChildren(); + + sword::SWKey *key = module->getKey(); + const char **retVal = 0; + int count = 0; + + sword::VerseKey *vkey = SWDYNAMIC_CAST(VerseKey, key); + if (vkey) { + retVal = (const char **)calloc(9, sizeof(const char *)); + SWBuf num; + num.appendFormatted("%d", vkey->getTestament()); + stdstr((char **)&(retVal[0]), num.c_str()); + num = ""; + num.appendFormatted("%d", vkey->getBook()); + stdstr((char **)&(retVal[1]), num.c_str()); + num = ""; + num.appendFormatted("%d", vkey->getChapter()); + stdstr((char **)&(retVal[2]), num.c_str()); + num = ""; + num.appendFormatted("%d", vkey->getVerse()); + stdstr((char **)&(retVal[3]), num.c_str()); + num = ""; + num.appendFormatted("%d", vkey->getChapterMax()); + stdstr((char **)&(retVal[4]), num.c_str()); + num = ""; + num.appendFormatted("%d", vkey->getVerseMax()); + stdstr((char **)&(retVal[5]), num.c_str()); + stdstr((char **)&(retVal[6]), vkey->getBookName()); + stdstr((char **)&(retVal[7]), vkey->getOSISRef()); + } + else { + TreeKeyIdx *tkey = SWDYNAMIC_CAST(TreeKeyIdx, key); + if (tkey) { + if (tkey->firstChild()) { + do { + count++; + } + while (tkey->nextSibling()); + tkey->parent(); + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + if (tkey->firstChild()) { + do { + stdstr((char **)&(retVal[count++]), assureValidUTF8(tkey->getLocalName())); + } + while (tkey->nextSibling()); + tkey->parent(); + } + } + } -const char *SWMgr_getConfigPath(SWHANDLE hmgr) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? mgr->configPath : 0; + hmod->keyChildren = retVal; + return retVal; } +/* + * Class: org_crosswire_sword_SWModule + * Method: getName + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getName + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); -void SWMgr_setGlobalOption(SWHANDLE hmgr, const char *option, const char *value) { - SWMgr *mgr = (SWMgr *)hmgr; - if (mgr) - mgr->setGlobalOption(option, value); + return module->getName(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getDescription + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getDescription + (SWHANDLE hSWModule) { -const char *SWMgr_getGlobalOption(SWHANDLE hmgr, const char *option) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? (const char *)mgr->getGlobalOption(option) : 0; + GETSWMODULE(hSWModule, 0); + + return module->getDescription(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getCategory + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getCategory + (SWHANDLE hSWModule) { + + static SWBuf type; + + GETSWMODULE(hSWModule, 0); -const char *SWMgr_getGlobalOptionTip(SWHANDLE hmgr, const char *option) { - SWMgr *mgr = (SWMgr *)hmgr; - return (mgr) ? (const char *)mgr->getGlobalOptionTip(option) : 0; + type = module->getType(); + SWBuf cat = module->getConfigEntry("Category"); + if (cat.length() > 0) + type = cat; + + return type.c_str(); } +/* + * Class: org_crosswire_sword_SWModule + * Method: getKeyParent + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getKeyParent + (SWHANDLE hSWModule) { + + static SWBuf retVal; + + GETSWMODULE(hSWModule, 0); + + sword::SWKey *key = module->getKey(); -// ret: forward_iterator -SWHANDLE SWMgr_getGlobalOptionsIterator(SWHANDLE hmgr) { - SWMgr *mgr = (SWMgr *)hmgr; - static StringList::iterator it; - static StringList optionslist; - if (mgr) { - optionslist = mgr->getGlobalOptions(); - it = optionslist.begin(); + retVal = ""; + + TreeKeyIdx *tkey = SWDYNAMIC_CAST(TreeKeyIdx, key); + if (tkey) { + if (tkey->parent()) { + retVal = tkey->getText(); + } } - return (SWHANDLE)⁢ + return assureValidUTF8(retVal.c_str()); } +/* + * Class: org_crosswire_sword_SWModule + * Method: previous + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_previous + (SWHANDLE hSWModule) { -// ret: forward_iterator -SWHANDLE SWMgr_getGlobalOptionValuesIterator(SWHANDLE hmgr, const char *option) { - SWMgr *mgr = (SWMgr *)hmgr; - static StringList::iterator it; - - if (mgr) - it = mgr->getGlobalOptionValues(option).begin(); - return (SWHANDLE)⁢ + GETSWMODULE(hSWModule, ); + + module->decrement(); } -void SWMgr_setCipherKey(SWHANDLE hmgr, const char *modName, const char *key) { - SWMgr *mgr = (SWMgr *)hmgr; - if (mgr) - mgr->setCipherKey(modName, key); +/* + * Class: org_crosswire_sword_SWModule + * Method: next + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_next + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, ); + + module->increment(); } -//----------------------------------------------------------------- -// SWModule methods +/* + * Class: org_crosswire_sword_SWModule + * Method: begin + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_begin + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, ); -// static void nullPercent (char percent, void *userData); -void SWModule_terminateSearch(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - if (module) - module->terminateSearch = true; + module->setPosition(sword::TOP); } -// SWModule (const const char *imodname = 0, const const char *imoddesc = 0, SWDisplay * idisp = 0, const char *imodtype = 0, SWTextEncoding encoding = ENC_UNKNOWN, SWTextDirection dir = DIRECTION_LTR, SWTextMarkup markup = FMT_UNKNOWN, const char* modlang = 0); -// virtual ~ SWModule (); -SWHANDLE SWModule_doSearch(SWHANDLE hmodule, const char *searchString, int type, int params ,void (*percent) (char, void *), void *percentUserData) { - - static ListKey results; - SWKey * scope = 0; - SWModule *module = (SWModule *)hmodule; - if (!module) - return -1; - - results.clear(); - results = module->search(searchString, type, params, scope, 0, percent, (void *) &percentUserData); - - return (SWHANDLE)&results; +/* + * Class: org_crosswire_sword_SWModule + * Method: getStripText + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_stripText + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + stdstr(&(hmod->stripBuf), assureValidUTF8((const char *)module->stripText())); + + return hmod->stripBuf; +} + +/* + * Class: org_crosswire_sword_SWModule + * Method: getRenderText + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_renderText + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + stdstr(&(hmod->renderBuf), assureValidUTF8((const char *)module->renderText().c_str())); + + return hmod->renderBuf; +} + +/* + * Class: org_crosswire_sword_SWModule + * Method: getRenderHeader + * Signature: ()Ljava/lang/String; + */ +// CSS styles associated with this text +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getRenderHeader + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + stdstr(&(hmod->renderHeader), assureValidUTF8(((const char *)(module->getRenderHeader() ? module->getRenderHeader():"")))); + + return hmod->renderHeader; } - /** Gets and clears error status - * - * @return error status - */ -char SWModule_error(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (module) ? module->popError() : 0; + +/* + * Class: org_crosswire_sword_SWModule + * Method: getRawEntry + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getRawEntry + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + stdstr(&(hmod->rawEntry), assureValidUTF8(((const char *)module->getRawEntry()))); + + return hmod->rawEntry; } +/* + * Class: org_crosswire_sword_SWModule + * Method: setRawEntry + * Signature: (Ljava/lang/String;)V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_setRawEntry + (SWHANDLE hSWModule, const char *entryBuffer) { + + GETSWMODULE(hSWModule, ); -int SWModule_getEntrySize(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (module) ? module->getEntrySize() : 0; + module->setEntry(entryBuffer); } -void SWModule_setKeyText(SWHANDLE hmodule, const char *key) { - SWModule *module = (SWModule *)hmodule; - if (module) - module->setKey(key); +/* + * Class: org_crosswire_sword_SWModule + * Method: getConfigEntry + * Signature: (Ljava/lang/String;)Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWModule_getConfigEntry + (SWHANDLE hSWModule, const char *key) { + + GETSWMODULE(hSWModule, 0); + + stdstr(&(hmod->configEntry), (module->getConfigEntry(key) ? assureValidUTF8(module->getConfigEntry(key)).c_str() : 0)); + + return hmod->configEntry; } -// virtual char setKey (const SWKey &ikey); -// virtual SWKey & Key () const { - -const char *SWModule_getKeyText(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->getKeyText() : 0); +/* + * Class: org_crosswire_sword_SWModule + * Method: deleteSearchFramework + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWModule_deleteSearchFramework + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, ); + + module->deleteSearchFramework(); } - -// virtual char Display (); -// virtual SWDisplay *Disp (SWDisplay * idisp = 0); - -const char *SWModule_getName(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->getName() : 0); + +/* + * Class: org_crosswire_sword_SWModule + * Method: hasSearchFramework + * Signature: ()Z + */ +char SWDLLEXPORT org_crosswire_sword_SWModule_hasSearchFramework + (SWHANDLE hSWModule) { + + GETSWMODULE(hSWModule, 0); + + return (module->hasSearchFramework() && module->isSearchOptimallySupported("God", -4, 0, 0)); } - -const char *SWModule_getDescription(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->getDescription() : 0); + + + +// +// SWMgr methods +// +// + + +/* + * Class: org_crosswire_sword_SWMgr + * Method: new + * Signature: ()V + */ +SWHANDLE SWDLLEXPORT org_crosswire_sword_SWMgr_new() { + SWConfig *sysConf = 0; + return (SWHANDLE) new HandleSWMgr(new WebMgr(sysConf)); } -const char *SWModule_getType(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->getType() : 0); +/* + * Class: org_crosswire_sword_SWMgr + * Method: delete + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_SWMgr_delete(SWHANDLE hSWMgr) { + HandleSWMgr *hmgr = (HandleSWMgr *)hSWMgr; + if (hmgr) delete hmgr; } +/* + * Class: org_crosswire_sword_SWMgr + * Method: version + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_version + (SWHANDLE hSWMgr) { + // we don't actually need an SWMgr to get version + static SWVersion v; + return v.currentVersion; +} + +/* + * Class: org_crosswire_sword_SWMgr + * Method: getModInfoList + * Signature: ()[Lorg/crosswire/android/sword/SWMgr/ModInfo; + */ +const struct org_crosswire_sword_ModInfo * SWDLLEXPORT org_crosswire_sword_SWMgr_getModInfoList + (SWHANDLE hSWMgr) { + + GETSWMGR(hSWMgr, 0); + + sword::SWModule *module = 0; + + hmgr->clearModInfo(); + + int size = 0; + for (sword::ModMap::iterator it = mgr->Modules.begin(); it != mgr->Modules.end(); ++it) { + if ((!(it->second->getConfigEntry("CipherKey"))) || (*(it->second->getConfigEntry("CipherKey")))) + size++; + } -void SWModule_previous(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - if (module) - (*module)--; + struct org_crosswire_sword_ModInfo *milist = (struct org_crosswire_sword_ModInfo *)calloc(size+1, sizeof(struct org_crosswire_sword_ModInfo)); + int i = 0; + for (sword::ModMap::iterator it = mgr->Modules.begin(); it != mgr->Modules.end(); ++it) { + module = it->second; + if ((!(module->getConfigEntry("CipherKey"))) || (*(module->getConfigEntry("CipherKey")))) { + SWBuf type = module->getType(); + SWBuf cat = module->getConfigEntry("Category"); + SWBuf version = module->getConfigEntry("Version"); + if (cat.length() > 0) type = cat; + stdstr(&(milist[i].name), assureValidUTF8(module->getName())); + stdstr(&(milist[i].description), assureValidUTF8(module->getDescription())); + stdstr(&(milist[i].category), assureValidUTF8(type.c_str())); + stdstr(&(milist[i++].language), assureValidUTF8(module->getLanguage())); + stdstr(&(milist[i++].version), assureValidUTF8(version.c_str())); + stdstr(&(milist[i++].delta), ""); + if (i >= size) break; + } + } + hmgr->modInfo = milist; + return milist; } +/* + * Class: org_crosswire_sword_SWMgr + * Method: getModuleByName + * Signature: (Ljava/lang/String;)Lorg/crosswire/android/sword/SWModule; + */ +SWHANDLE SWDLLEXPORT org_crosswire_sword_SWMgr_getModuleByName + (SWHANDLE hSWMgr, const char *moduleName) { + + GETSWMGR(hSWMgr, 0); -void SWModule_next(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - if (module) - (*module)++; + return (SWHANDLE)hmgr->getModuleHandle(hmgr->mgr->getModule(moduleName)); } +/* + * Class: org_crosswire_sword_SWMgr + * Method: getPrefixPath + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_getPrefixPath + (SWHANDLE hSWMgr) { + + GETSWMGR(hSWMgr, 0); -void SWModule_begin(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - if (module) - (*module) = TOP; + return mgr->prefixPath; } - - -const char *SWModule_getStripText(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->stripText() : 0); + +/* + * Class: org_crosswire_sword_SWMgr + * Method: getConfigPath + * Signature: ()Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_getConfigPath + (SWHANDLE hSWMgr) { + + GETSWMGR(hSWMgr, 0); + + return mgr->configPath; } - - -const char *SWModule_getRenderText(SWHANDLE hmodule) { - SWModule *module = (SWModule *)hmodule; - return (const char *)((module) ? module->renderText().c_str() : 0); + +/* + * Class: org_crosswire_sword_SWMgr + * Method: setGlobalOption + * Signature: (Ljava/lang/String;Ljava/lang/String;)V + */ +void SWDLLEXPORT org_crosswire_sword_SWMgr_setGlobalOption + (SWHANDLE hSWMgr, const char *option, const char *value) { + + GETSWMGR(hSWMgr, ); + mgr->setGlobalOption(option, value); } -const char *SWModule_getEntryAttributes(SWHANDLE hmodule, const char *level1, const char *level2, const char *level3) { - SWModule *module = (SWModule *)hmodule; - static SWBuf retval; - module->renderText(); - retval = module->getEntryAttributes()[level1][level2][level3].c_str(); - return (retval.length()) ? (const char*)retval.c_str() : NULL; +/* + * Class: org_crosswire_sword_SWMgr + * Method: getGlobalOption + * Signature: (Ljava/lang/String;)Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_getGlobalOption + (SWHANDLE hSWMgr, const char *option) { + + GETSWMGR(hSWMgr, 0); + + return mgr->getGlobalOption(option); } -const char *SWModule_getPreverseHeader(SWHANDLE hmodule, const char *key, int pvHeading) { - SWModule *module = (SWModule *)hmodule; - static SWBuf preverseHeading; - char buf[12]; - sprintf(buf, "%i", pvHeading); - module->setKey(key); - module->renderText(); - preverseHeading = module->getEntryAttributes()["Heading"]["Preverse"][buf].c_str(); - return (preverseHeading.length()) ? (const char*)preverseHeading.c_str() : NULL; +/* + * Class: org_crosswire_sword_SWMgr + * Method: getGlobalOptionTip + * Signature: (Ljava/lang/String;)Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_getGlobalOptionTip + (SWHANDLE hSWMgr, const char *option) { + + GETSWMGR(hSWMgr, 0); + + return mgr->getGlobalOptionTip(option); } -const char *SWModule_getFootnoteType(SWHANDLE hmodule, const char *key, const char *note) { - SWModule *module = (SWModule *)hmodule; - static SWBuf type; - module->popError(); - module->setKey(key); - module->renderText(); - type = module->getEntryAttributes()["Footnote"][note]["type"].c_str(); - return (type) ? (const char*)type.c_str() : NULL; +/* + * Class: org_crosswire_sword_SWMgr + * Method: filterText + * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_filterText + (SWHANDLE hSWMgr, const char *filterName, const char *text) { + + GETSWMGR(hSWMgr, 0); + + hmgr->filterBuf = text; + +// why was this in bindings/corba/omniorb? +// mgr->setGlobalOption("Greek Accents", "Off"); + + char errStatus = mgr->filterText(filterName, hmgr->filterBuf); + (void)errStatus; + return hmgr->filterBuf.c_str(); } -const char *SWModule_getFootnoteBody(SWHANDLE hmodule, const char *key, const char *note) { - SWModule *module = (SWModule *)hmodule; - static SWBuf body; - module->popError(); - module->setKey(key); - module->renderText(); - body = module->getEntryAttributes()["Footnote"][note]["body"].c_str(); - SWKey *keybuf = module->getKey();; - module->renderFilter(body, keybuf); - return (body) ? (const char*)body.c_str() : NULL; +/* + * Class: org_crosswire_sword_SWMgr + * Method: getGlobalOptions + * Signature: ()[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_SWMgr_getGlobalOptions + (SWHANDLE hSWMgr) { + + GETSWMGR(hSWMgr, 0); + + const char **retVal; + hmgr->clearGlobalOptions(); + + sword::StringList options = mgr->getGlobalOptions(); + int count = 0; + for (sword::StringList::iterator it = options.begin(); it != options.end(); ++it) { + count++; + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + for (sword::StringList::iterator it = options.begin(); it != options.end(); ++it) { + stdstr((char **)&(retVal[count++]), it->c_str()); + } + + hmgr->globalOptions = retVal; + return retVal; } -const char *SWModule_getFootnoteRefList(SWHANDLE hmodule, const char *key, const char *note) { - SWModule *module = (SWModule *)hmodule; - static SWBuf refList; - module->popError(); - module->setKey(key); - module->renderText(); - refList = module->getEntryAttributes()["Footnote"][note]["refList"].c_str(); - return (refList) ? (const char*)refList.c_str() : NULL; +/* + * Class: org_crosswire_sword_SWMgr + * Method: getGlobalOptionValues + * Signature: (Ljava/lang/String;)[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_SWMgr_getGlobalOptionValues + (SWHANDLE hSWMgr, const char *option) { + + GETSWMGR(hSWMgr, 0); + + const char **retVal = 0; + hmgr->clearGlobalOptionValues(); + + sword::StringList options = mgr->getGlobalOptionValues(option); + int count = 0; + for (sword::StringList::iterator it = options.begin(); it != options.end(); ++it) { + count++; + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + for (sword::StringList::iterator it = options.begin(); it != options.end(); ++it) { + stdstr((char **)&(retVal[count++]), it->c_str()); + } + + hmgr->globalOptionValues = retVal; + return retVal; } +/* + * Class: org_crosswire_sword_SWMgr + * Method: setCipherKey + * Signature: (Ljava/lang/String;Ljava/lang/String;)V + */ +void SWDLLEXPORT org_crosswire_sword_SWMgr_setCipherKey + (SWHANDLE hSWMgr, const char *modName, const char *key) { + GETSWMGR(hSWMgr, ); -SWHANDLE listkey_getVerselistIterator(const char *list, const char *key, const char *v11n) { - VerseKey versekey; - versekey.setVersificationSystem(v11n); - static ListKey verses; - - versekey.setText(key); - verses.clear(); - verses = versekey.parseVerseList(list, versekey); - return (SWHANDLE)&verses; + mgr->setCipherKey(modName, key); } -//----------------------------------------------------------------- -// stringlist_iterator methods +/* + * Class: org_crosswire_sword_SWMgr + * Method: setJavascript + * Signature: (Z)V + */ +void SWDLLEXPORT org_crosswire_sword_SWMgr_setJavascript + (SWHANDLE hSWMgr, char valueBool) { -void stringlist_iterator_next(SWHANDLE hsli) { - StringList::iterator *sli = (StringList::iterator *)hsli; - (*sli)++; + GETSWMGR(hSWMgr, ); + + mgr->setJavascript(valueBool); +} + +/* + * Class: org_crosswire_sword_SWMgr + * Method: getAvailableLocales + * Signature: ()[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_SWMgr_getAvailableLocales + (SWHANDLE hSWMgr) { + + GETSWMGR(hSWMgr, 0); + + hmgr->clearAvailableLocales(); + sword::StringList localeNames = LocaleMgr::getSystemLocaleMgr()->getAvailableLocales(); + const char **retVal = 0; + int count = 0; + for (sword::StringList::iterator it = localeNames.begin(); it != localeNames.end(); ++it) { + count++; + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + for (sword::StringList::iterator it = localeNames.begin(); it != localeNames.end(); ++it) { + stdstr((char **)&(retVal[count++]), it->c_str()); + } + + hmgr->availableLocales = retVal; + return retVal; +} + +/* + * Class: org_crosswire_sword_SWMgr + * Method: setDefaultLocale + * Signature: (Ljava/lang/String;)V + */ +void SWDLLEXPORT org_crosswire_sword_SWMgr_setDefaultLocale + (SWHANDLE hSWMgr, const char *name) { + + // we don't actually need an SWMgr instance for this + GETSWMGR(hSWMgr, ); + + LocaleMgr::getSystemLocaleMgr()->setDefaultLocaleName(name); +} + +/* + * Class: org_crosswire_sword_SWMgr + * Method: translate + * Signature: (Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String; + */ +const char * SWDLLEXPORT org_crosswire_sword_SWMgr_translate + (SWHANDLE hSWMgr, const char *text, const char *localeName) { + + GETSWMGR(hSWMgr, 0); + + return LocaleMgr::getSystemLocaleMgr()->translate(text, localeName); +} + + + + +// +// InstallMgr methods +// +// + + +/* + * Class: org_crosswire_sword_InstallMgr + * Method: new + * Signature: (Ljava/lang/String;Lorg/crosswire/android/sword/SWModule/SearchProgressReporter;)V + */ +SWHANDLE SWDLLEXPORT org_crosswire_sword_InstallMgr_new + (const char *baseDir, SWHANDLE statusReporter) { + SWBuf confPath = SWBuf(baseDir) + "/InstallMgr.conf"; + // be sure we have at least some config file already out there + if (!FileMgr::existsFile(confPath.c_str())) { + FileMgr::createParent(confPath.c_str()); +// remove(confPath.c_str()); + + SWConfig config(confPath.c_str()); + config["General"]["PassiveFTP"] = "true"; + config.Save(); + } + HandleInstMgr *hinstmgr = new HandleInstMgr(); + hinstmgr->statusReporter.init(statusReporter); + hinstmgr->installMgr = new InstallMgr(baseDir, &(hinstmgr->statusReporter)); + return (SWHANDLE) hinstmgr; +} + +/* + * Class: org_crosswire_sword_InstallMgr + * Method: setUserDisclaimerConfirmed + * Signature: ()V + */ +void SWDLLEXPORT org_crosswire_sword_InstallMgr_setUserDisclaimerConfirmed + (SWHANDLE hInstallMgr) { + + GETINSTMGR(hInstallMgr, ); + + installMgr->setUserDisclaimerConfirmed(true); +} + +/* + * Class: org_crosswire_sword_InstallMgr + * Method: syncConfig + * Signature: ()I + */ +int SWDLLEXPORT org_crosswire_sword_InstallMgr_syncConfig + (SWHANDLE hInstallMgr) { + + GETINSTMGR(hInstallMgr, -1); + + return installMgr->refreshRemoteSourceConfiguration(); } +/* + * Class: org_crosswire_sword_InstallMgr + * Method: uninstallModule + * Signature: (Lorg/crosswire/android/sword/SWMgr;Ljava/lang/String;)I + */ +int SWDLLEXPORT org_crosswire_sword_InstallMgr_uninstallModule + (SWHANDLE hInstallMgr, SWHANDLE hSWMgr_removeFrom, const char *modName) { + + GETINSTMGR(hInstallMgr, -1); + GETSWMGR(hSWMgr_removeFrom, -1); -const char *stringlist_iterator_val(SWHANDLE hsli) { - StringList::iterator *sli = (StringList::iterator *)hsli; - return (const char *)(*sli)->c_str(); + SWModule *module; + ModMap::iterator it = mgr->Modules.find(modName); + if (it == mgr->Modules.end()) { + return -2; + } + module = it->second; + return installMgr->removeModule(mgr, module->getName()); } +/* + * Class: org_crosswire_sword_InstallMgr + * Method: getRemoteSources + * Signature: ()[Ljava/lang/String; + */ +const char ** SWDLLEXPORT org_crosswire_sword_InstallMgr_getRemoteSources + (SWHANDLE hInstallMgr) { + GETINSTMGR(hInstallMgr, 0); -//----------------------------------------------------------------- -// listkey_iterator methods + hinstmgr->clearRemoteSources(); + sword::StringList vals = LocaleMgr::getSystemLocaleMgr()->getAvailableLocales(); + const char **retVal = 0; + int count = 0; + for (InstallSourceMap::iterator it = installMgr->sources.begin(); it != installMgr->sources.end(); ++it) { + count++; + } + retVal = (const char **)calloc(count+1, sizeof(const char *)); + count = 0; + for (InstallSourceMap::iterator it = installMgr->sources.begin(); it != installMgr->sources.end(); ++it) { + stdstr((char **)&(retVal[count++]), it->second->caption.c_str()); + } -void listkey_iterator_next(SWHANDLE lki) { - ListKey *lk = (ListKey*)lki; - (*lk)++; + hinstmgr->remoteSources = retVal; + return retVal; } +/* + * Class: org_crosswire_sword_InstallMgr + * Method: refreshRemoteSource + * Signature: (Ljava/lang/String;)I + */ +int SWDLLEXPORT org_crosswire_sword_InstallMgr_refreshRemoteSource + (SWHANDLE hInstallMgr, const char *sourceName) { + + GETINSTMGR(hInstallMgr, -1); -const char *listkey_iterator_val(SWHANDLE lki) { - ListKey *lk = (ListKey*)lki; - if(!lk->popError()) - return (const char *) lk->getText(); - return NULL; + InstallSourceMap::iterator source = installMgr->sources.find(sourceName); + if (source == installMgr->sources.end()) { + return -3; + } + + return installMgr->refreshRemoteSource(source->second); } +/* + * Class: org_crosswire_sword_InstallMgr + * Method: getRemoteModInfoList + * Signature: (Lorg/crosswire/android/sword/SWMgr;Ljava/lang/String;)[Lorg/crosswire/android/sword/SWMgr/ModInfo; + */ +const struct org_crosswire_sword_ModInfo * SWDLLEXPORT org_crosswire_sword_InstallMgr_getRemoteModInfoList + (SWHANDLE hInstallMgr, SWHANDLE hSWMgr_deltaCompareTo, const char *sourceName) { + GETINSTMGR(hInstallMgr, 0); + GETSWMGR(hSWMgr_deltaCompareTo, 0); -//----------------------------------------------------------------- -// modmap methods + struct org_crosswire_sword_ModInfo *retVal = 0; -void ModList_iterator_next(SWHANDLE hmmi) { - ModItType *it = (ModItType *)hmmi; - if (it->it != it->end) - it->it++; + hinstmgr->clearModInfo(); + + InstallSourceMap::iterator source = installMgr->sources.find(sourceName); + if (source == installMgr->sources.end()) { + retVal = (struct org_crosswire_sword_ModInfo *)calloc(1, sizeof(struct org_crosswire_sword_ModInfo)); + hinstmgr->modInfo = retVal; + return retVal; + } + + std::map<SWModule *, int> modStats = installMgr->getModuleStatus(*mgr, *source->second->getMgr()); + + int size = 0; + for (std::map<SWModule *, int>::iterator it = modStats.begin(); it != modStats.end(); ++it) { + size++; + } + retVal = (struct org_crosswire_sword_ModInfo *)calloc(size+1, sizeof(struct org_crosswire_sword_ModInfo)); + int i = 0; + for (std::map<SWModule *, int>::iterator it = modStats.begin(); it != modStats.end(); ++it) { + SWModule *module = it->first; + int status = it->second; + + SWBuf version = module->getConfigEntry("Version"); + SWBuf statusString = " "; + if (status & InstallMgr::MODSTAT_NEW) statusString = "*"; + if (status & InstallMgr::MODSTAT_OLDER) statusString = "-"; + if (status & InstallMgr::MODSTAT_UPDATED) statusString = "+"; + + SWBuf type = module->getType(); + SWBuf cat = module->getConfigEntry("Category"); + if (cat.length() > 0) type = cat; + + stdstr(&(retVal[i].name), assureValidUTF8(module->getName())); + stdstr(&(retVal[i].description), assureValidUTF8(module->getDescription())); + stdstr(&(retVal[i].category), assureValidUTF8(type.c_str())); + stdstr(&(retVal[i].language), assureValidUTF8(module->getLanguage())); + stdstr(&(retVal[i].version), assureValidUTF8(version.c_str())); + stdstr(&(retVal[i++].delta), assureValidUTF8(statusString.c_str())); + if (i >= size) break; + } + hinstmgr->modInfo = retVal; + return retVal; } +/* + * Class: org_crosswire_sword_InstallMgr + * Method: remoteInstallModule + * Signature: (Lorg/crosswire/android/sword/SWMgr;Ljava/lang/String;Ljava/lang/String;)I + */ +int SWDLLEXPORT org_crosswire_sword_InstallMgr_remoteInstallModule + (SWHANDLE hInstallMgr_from, SWHANDLE hSWMgr_to, const char *sourceName, const char *modName) { + + GETINSTMGR(hInstallMgr_from, -1); + GETSWMGR(hSWMgr_to, -1); + + InstallSourceMap::iterator source = installMgr->sources.find(sourceName); + + if (source == installMgr->sources.end()) { + return -3; + } + + InstallSource *is = source->second; + SWMgr *rmgr = is->getMgr(); + SWModule *module; + + ModMap::iterator it = rmgr->Modules.find(modName); + + if (it == rmgr->Modules.end()) { + return -4; + } + + module = it->second; + + int error = installMgr->installModule(mgr, 0, module->getName(), is); + + return error; +} + +/* + * Class: org_crosswire_sword_InstallMgr + * Method: getRemoteModuleByName + * Signature: (Ljava/lang/String;Ljava/lang/String;)Lorg/crosswire/android/sword/SWModule; + */ +SWHANDLE SWDLLEXPORT org_crosswire_sword_InstallMgr_getRemoteModuleByName + (SWHANDLE hInstallMgr, const char *sourceName, const char *modName) { + + GETINSTMGR(hInstallMgr, 0); + + InstallSourceMap::iterator source = installMgr->sources.find(sourceName); + + if (source == installMgr->sources.end()) { + return 0; + } + + SWMgr *mgr = source->second->getMgr(); + + sword::SWModule *module = mgr->getModule(modName); + + if (!module) { + return 0; + } + + return (SWHANDLE)hinstmgr->getModuleHandle(module); -SWHANDLE ModList_iterator_val(SWHANDLE hmmi) { - ModItType *it = (ModItType *)hmmi; - return (it->it != it->end) ? (SWHANDLE)it->it->second : 0; } |