JNIEXPORT jint JNICALL XPCOMInit_NATIVE(_1GRE_1GetGREPathWithProperties) (JNIEnv *env, jclass that, jobject arg0, jint arg1, jobject arg2, jint arg3, jintLong arg4, jint arg5) { GREVersionRange _arg0, *lparg0=NULL; GREProperty _arg2, *lparg2=NULL; jint rc = 0; XPCOMInit_NATIVE_ENTER(env, that, _1GRE_1GetGREPathWithProperties_FUNC); if (arg0) if ((lparg0 = getGREVersionRangeFields(env, arg0, &_arg0)) == NULL) goto fail; if (arg2) if ((lparg2 = getGREPropertyFields(env, arg2, &_arg2)) == NULL) goto fail; rc = (jint)GRE_GetGREPathWithProperties((const GREVersionRange *)lparg0, arg1, (const GREProperty *)lparg2, arg3, (char *)arg4, arg5); fail: if (arg2 && lparg2) setGREPropertyFields(env, arg2, lparg2); if (arg0 && lparg0) setGREVersionRangeFields(env, arg0, lparg0); XPCOMInit_NATIVE_EXIT(env, that, _1GRE_1GetGREPathWithProperties_FUNC); return rc; }
int main (int argc, char **argv) { gtk_init (&argc, &argv); runtime_init (RUNTIME_INIT_BROWSER); window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL)); char xpcom_lib_path [PATH_MAX]; char* xpcom_dir_path; GRE_GetGREPathWithProperties (&gre_version, 1, nsnull, 0, xpcom_lib_path, sizeof (xpcom_lib_path)); xpcom_dir_path = g_path_get_dirname (xpcom_lib_path); gtk_moz_embed_set_path (xpcom_dir_path); g_free (xpcom_dir_path); GtkWidget *moz_embed = gtk_moz_embed_new(); gtk_container_add (GTK_CONTAINER (window), moz_embed); gtk_widget_set_usize (moz_embed, 416, 416); char *current_directory = g_get_current_dir (); char *html_path = g_strdup_printf ("file://%s/test.html", current_directory); gtk_moz_embed_load_url (GTK_MOZ_EMBED (moz_embed), html_path); g_free (current_directory); g_free (html_path); gtk_widget_show_all (moz_embed); gtk_widget_show_all (GTK_WIDGET (window)); g_timeout_add (500, setup, NULL); runtime_flags_set_manual_timesource (TRUE); runtime_flags_set_use_shapecache (FALSE); runtime_flags_set_show_fps (FALSE); gtk_main (); return 0; }
int main(int argc, char *argv[]) { GtkWidget *window; GtkWidget *label; GtkWidget *mozembed; GtkWidget *container; char *url; gtk_init(&argc, &argv); static const GREVersionRange greVersion = { "1.9a", PR_TRUE, "2", PR_TRUE }; char xpcomPath[PATH_MAX]; nsresult rv = GRE_GetGREPathWithProperties(&greVersion, 1, nsnull, 0, xpcomPath, sizeof(xpcomPath)); if (NS_FAILED(rv)) { fprintf(stderr, "Couldn't find a compatible GRE.\n"); return 1; } rv = XPCOMGlueStartup(xpcomPath); if (NS_FAILED(rv)) { fprintf(stderr, "Couldn't start XPCOM."); return 1; } rv = GTKEmbedGlueStartup(); if (NS_FAILED(rv)) { fprintf(stderr, "Couldn't find GTKMozEmbed symbols."); return 1; } char *lastSlash = strrchr(xpcomPath, '/'); if (lastSlash) *lastSlash = '\0'; gtk_moz_embed_set_path(xpcomPath); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); container = gtk_notebook_new(); mozembed = gtk_moz_embed_new(); label = gtk_label_new("Can you see this message?\n" "Once you switch to mozembed page " "you never see this message."); g_signal_connect(GTK_OBJECT(mozembed), "destroy", G_CALLBACK(gtk_main_quit), NULL); gtk_container_add(GTK_CONTAINER(window), container); gtk_notebook_append_page(GTK_NOTEBOOK(container), label, gtk_label_new("gtk label")); gtk_notebook_append_page(GTK_NOTEBOOK(container), mozembed, gtk_label_new("mozembed")); gtk_widget_set_size_request(window, 400, 300); gtk_widget_show(mozembed); gtk_widget_show(label); gtk_widget_show_all(window); url = (argc > 1) ? argv[1] : (char *)"localhost"; gtk_moz_embed_load_url(GTK_MOZ_EMBED(mozembed), url); gtk_main(); return 0; }
extern "C" void gecko_utils_init(void) { if (!g_thread_supported()) g_thread_init(NULL); nsresult rv; #ifdef XPCOM_GLUE NS_LogInit(); static const GREVersionRange greVersion = { "1.9a", PR_TRUE, "1.9.*", PR_TRUE }; char xpcomLocation[4096]; rv = GRE_GetGREPathWithProperties(&greVersion, 1, nsnull, 0, xpcomLocation, 4096); if (NS_FAILED (rv)) { g_warning ("Could not determine locale!\n"); return; } // Startup the XPCOM Glue that links us up with XPCOM. rv = XPCOMGlueStartup(xpcomLocation); if (NS_FAILED (rv)) { g_warning ("Could not determine locale!\n"); return; } rv = GTKEmbedGlueStartup(); if (NS_FAILED (rv)) { g_warning ("Could not startup embed glue!\n"); return; } rv = GTKEmbedGlueStartupInternal(); if (NS_FAILED (rv)) { g_warning ("Could not startup embed glue (internal)!\n"); return; } char *lastSlash = strrchr(xpcomLocation, '/'); if (lastSlash) *lastSlash = '\0'; gtk_moz_embed_set_path(xpcomLocation); #else gtk_moz_embed_set_comp_path(GECKO_LIB_ROOT); #endif gchar *profile_dir = g_build_filename(g_get_home_dir(), ".chmsee", NULL); gtk_moz_embed_set_profile_path(profile_dir, "mozilla"); g_free(profile_dir); gtk_moz_embed_push_startup(); gecko_utils_init_prefs(); }
int StartXPCOM(){ nsresult rv = NS_ERROR_BASE; const GREVersionRange vr = { "1.9.2", PR_TRUE, "2.0", PR_FALSE }; char xpcomPath[_MAX_PATH]; rv = GRE_GetGREPathWithProperties(&vr, 1, nsnull, 0, xpcomPath, sizeof(xpcomPath)); if (NS_FAILED(rv)){ char *fxXpcomPath = "C:\\Program Files\\Mozilla Firefox\\xpcom.dll"; if(::PathFileExistsA( fxXpcomPath )){ strcpy(xpcomPath, fxXpcomPath); rv = NS_OK; }else{ rv = NS_ERROR_BASE; } } if (NS_FAILED(rv)) return 1; char *lastslash = ns_strrpbrk(xpcomPath, "/\\"); if (!lastslash) return 2; rv = XPCOMGlueStartup(xpcomPath); if (NS_FAILED(rv)) return 3; *lastslash = '\0'; char xulPath[_MAX_PATH]; _snprintf(xulPath, sizeof(xulPath), "%s\\xul.dll", xpcomPath); xulPath[sizeof(xulPath) - 1] = '\0'; HINSTANCE xulModule = LoadLibraryEx(CString(xulPath), NULL, 0); if (!xulModule) return 4; TCHAR temp[_MAX_PATH]; GetModuleFileName(xulModule, temp, sizeof(temp)); XRE_InitEmbedding = (XRE_InitEmbeddingType) GetProcAddress(xulModule, "XRE_InitEmbedding"); if (!XRE_InitEmbedding) { //fprintf(stderr, "Error: %i\n", GetLastError()); return 5; } XRE_TermEmbedding = (XRE_TermEmbeddingType) GetProcAddress(xulModule, "XRE_TermEmbedding"); if (!XRE_TermEmbedding) { fprintf(stderr, "Error: %i\n", GetLastError()); return 5; } XRE_NotifyProfile = (XRE_NotifyProfileType) GetProcAddress(xulModule, "XRE_NotifyProfile"); if (!XRE_NotifyProfile) { fprintf(stderr, "Error: %i\n", GetLastError()); return 5; } // Scope all the XPCOM stuff { nsCOMPtr<nsILocalFile> xuldir; rv = NS_NewNativeLocalFile(nsCString(xpcomPath), PR_FALSE, getter_AddRefs(xuldir)); if (NS_FAILED(rv)) return 6; TCHAR self[_MAX_PATH]; HINSTANCE hInstanceApp = NULL; hInstanceApp = GetModuleHandle(NULL); GetModuleFileName(hInstanceApp, self, sizeof(self)); lastslash = ns_strrpbrk(xpcomPath, "/\\"); if (!lastslash) return 7; *lastslash = '\0'; nsCOMPtr<nsILocalFile> appdir; nsEmbedCString cself; NS_UTF16ToCString(nsEmbedString(self), NS_CSTRING_ENCODING_UTF8, cself); rv = NS_NewNativeLocalFile(cself, PR_FALSE, getter_AddRefs(appdir)); if (NS_FAILED(rv)) return 8; kDirSvcProvider = new DonutDirectoryServiceProvider(); kDirSvcProvider->AddRef(); rv = XRE_InitEmbedding(xuldir, appdir, kDirSvcProvider, nsnull, 0); if (NS_FAILED(rv)) return 9; XRE_NotifyProfile(); RegisterAdditionalComponents(); } return rv; }
int main(int argc, char **argv) { nsresult rv; char *lastSlash; char iniPath[MAXPATHLEN]; char tmpPath[MAXPATHLEN]; char greDir[MAXPATHLEN]; PRBool greFound = PR_FALSE; #if defined(XP_MACOSX) CFBundleRef appBundle = CFBundleGetMainBundle(); if (!appBundle) return 1; CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(appBundle); if (!resourcesURL) return 1; CFURLRef absResourcesURL = CFURLCopyAbsoluteURL(resourcesURL); CFRelease(resourcesURL); if (!absResourcesURL) return 1; CFURLRef iniFileURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorDefault, absResourcesURL, CFSTR("application.ini"), false); CFRelease(absResourcesURL); if (!iniFileURL) return 1; CFStringRef iniPathStr = CFURLCopyFileSystemPath(iniFileURL, kCFURLPOSIXPathStyle); CFRelease(iniFileURL); if (!iniPathStr) return 1; CFStringGetCString(iniPathStr, iniPath, sizeof(iniPath), kCFStringEncodingUTF8); CFRelease(iniPathStr); #else #ifdef XP_WIN wchar_t wide_path[MAX_PATH]; if (!::GetModuleFileNameW(NULL, wide_path, MAX_PATH)) return 1; WideCharToMultiByte(CP_UTF8, 0, wide_path,-1, iniPath, MAX_PATH, NULL, NULL); #elif defined(XP_OS2) PPIB ppib; PTIB ptib; DosGetInfoBlocks(&ptib, &ppib); DosQueryModuleName(ppib->pib_hmte, sizeof(iniPath), iniPath); #elif defined(XP_BEOS) BEntry e((const char *)argv[0], true); // traverse symlink BPath p; status_t err; err = e.GetPath(&p); NS_ASSERTION(err == B_OK, "realpath failed"); if (err == B_OK) // p.Path returns a pointer, so use strcpy to store path in iniPath strcpy(iniPath, p.Path()); #else // on unix, there is no official way to get the path of the current binary. // instead of using the MOZILLA_FIVE_HOME hack, which doesn't scale to // multiple applications, we will try a series of techniques: // // 1) use realpath() on argv[0], which works unless we're loaded from the // PATH // 2) manually walk through the PATH and look for ourself // 3) give up struct stat fileStat; if (!realpath(argv[0], iniPath) || stat(iniPath, &fileStat)) { const char *path = getenv("PATH"); if (!path) return 1; char *pathdup = strdup(path); if (!pathdup) return 1; PRBool found = PR_FALSE; char *token = strtok(pathdup, ":"); while (token) { sprintf(tmpPath, "%s/%s", token, argv[0]); if (realpath(tmpPath, iniPath) && stat(iniPath, &fileStat) == 0) { found = PR_TRUE; break; } token = strtok(NULL, ":"); } free (pathdup); if (!found) return 1; } #endif lastSlash = strrchr(iniPath, PATH_SEPARATOR_CHAR); if (!lastSlash) return 1; *(++lastSlash) = '\0'; // On Linux/Win, look for XULRunner in appdir/xulrunner snprintf(greDir, sizeof(greDir), "%sxulrunner" XPCOM_FILE_PATH_SEPARATOR XPCOM_DLL, iniPath); greFound = FolderExists(greDir); strncpy(lastSlash, "application.ini", sizeof(iniPath) - (lastSlash - iniPath)); #endif // If -app parameter was passed in, it is now time to take it under // consideration. const char *appDataFile; appDataFile = getenv("XUL_APP_FILE"); if (!appDataFile || !*appDataFile) if (argc > 1 && IsArg(argv[1], "app")) { if (argc == 2) { Output(PR_FALSE, "specify APP-FILE (optional)\n"); return 1; } argv[1] = argv[0]; ++argv; --argc; appDataFile = argv[1]; argv[1] = argv[0]; ++argv; --argc; char kAppEnv[MAXPATHLEN]; snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile); if (putenv(kAppEnv)) Output(PR_FALSE, "Couldn't set %s.\n", kAppEnv); char *result = (char*) calloc(sizeof(char), MAXPATHLEN); if (NS_FAILED(GetRealPath(appDataFile, &result))) { Output(PR_TRUE, "Invalid application.ini path.\n"); return 1; } // We have a valid application.ini path passed in to the -app parameter // but not yet a valid greDir, so lets look for it also on the same folder // as the stub. if (!greFound) { lastSlash = strrchr(iniPath, PATH_SEPARATOR_CHAR); if (!lastSlash) return 1; *(++lastSlash) = '\0'; snprintf(greDir, sizeof(greDir), "%s" XPCOM_DLL, iniPath); greFound = FolderExists(greDir); } // copy it back. strcpy(iniPath, result); } nsINIParser parser; rv = parser.Init(iniPath); if (NS_FAILED(rv)) { fprintf(stderr, "Could not read application.ini\n"); return 1; } #ifdef WINCE // On Windows Mobile and WinCE, we can save a lot of time by not // waiting for XUL and XPCOM to load up. Let's see if we can find // an existing app window to forward our command-line to now. // Shouldn't attempt this if the -no-remote parameter has been provided. bool noRemote = false; for (int i = 1; i < argc; i++) { if (IsArg(argv[i], "no-remote")) { noRemote = true; break; } } if (!noRemote) { char windowName[512]; // Is there a const for appname like VERSION_MAXLEN? rv = parser.GetString("App", "Name", windowName, sizeof(windowName)); if (NS_FAILED(rv)) { fprintf(stderr, "Couldn't figure out the application name\n"); return 1; } // Lookup the hidden message window created by nsNativeAppSupport strncat(windowName, "MessageWindow", sizeof(windowName) - strlen(windowName)); WCHAR wWindowName[512]; MultiByteToWideChar(CP_UTF8, 0, windowName, -1, wWindowName, sizeof(wWindowName)); HWND wnd = ::FindWindowW(wWindowName, NULL); if (wnd) { // Forward the command-line and bail out ForwardToWindow(wnd); return 0; } } #endif if (!greFound) { char minVersion[VERSION_MAXLEN]; // If a gecko maxVersion is not specified, we assume that the app uses only // frozen APIs, and is therefore compatible with any xulrunner 1.x. char maxVersion[VERSION_MAXLEN] = "1.*"; GREVersionRange range = { minVersion, PR_TRUE, maxVersion, PR_TRUE }; rv = parser.GetString("Gecko", "MinVersion", minVersion, sizeof(minVersion)); if (NS_FAILED(rv)) { fprintf(stderr, "The application.ini does not specify a [Gecko] MinVersion\n"); return 1; } rv = parser.GetString("Gecko", "MaxVersion", maxVersion, sizeof(maxVersion)); if (NS_SUCCEEDED(rv)) range.upperInclusive = PR_TRUE; static const GREProperty kProperties[] = { { "xulrunner", "true" } }; rv = GRE_GetGREPathWithProperties(&range, 1, kProperties, NS_ARRAY_LENGTH(kProperties), greDir, sizeof(greDir)); if (NS_FAILED(rv)) { // XXXbsmedberg: Do something much smarter here: notify the // user/offer to download/? Output(PR_FALSE, "Could not find compatible GRE between version %s and %s.\n", range.lower, range.upper); return 1; } #ifdef XP_UNIX // Using a symlinked greDir will fail during startup. Not sure why, but if // we resolve the symlink, everything works as expected. char resolved_greDir[MAXPATHLEN] = ""; if (realpath(greDir, resolved_greDir) && *resolved_greDir) { strncpy(greDir, resolved_greDir, MAXPATHLEN); } #endif } #ifdef XP_OS2 // On OS/2 we need to set BEGINLIBPATH to be able to find XULRunner DLLs strcpy(tmpPath, greDir); lastSlash = strrchr(tmpPath, PATH_SEPARATOR_CHAR); if (lastSlash) { *lastSlash = '\0'; } DosSetExtLIBPATH(tmpPath, BEGIN_LIBPATH); #endif rv = XPCOMGlueStartup(greDir); if (NS_FAILED(rv)) { if (rv == NS_ERROR_OUT_OF_MEMORY) { char applicationName[2000] = "this application"; parser.GetString("App", "Name", applicationName, sizeof(applicationName)); Output(PR_TRUE, "Not enough memory available to start %s.\n", applicationName); } else { Output(PR_TRUE, "Couldn't load XPCOM.\n"); } return 1; } static const nsDynamicFunctionLoad kXULFuncs[] = { { "XRE_CreateAppData", (NSFuncPtr*) &XRE_CreateAppData }, { "XRE_FreeAppData", (NSFuncPtr*) &XRE_FreeAppData }, { "XRE_main", (NSFuncPtr*) &XRE_main }, { nsnull, nsnull } }; rv = XPCOMGlueLoadXULFunctions(kXULFuncs); if (NS_FAILED(rv)) { Output(PR_TRUE, "Couldn't load XRE functions.\n"); return 1; } NS_LogInit(); int retval; { // Scope COMPtr and AutoAppData nsCOMPtr<nsILocalFile> iniFile; #ifdef XP_WIN // On Windows and Windows CE, iniPath is UTF-8 encoded, // so we need to convert it. rv = NS_NewLocalFile(NS_ConvertUTF8toUTF16(iniPath), PR_FALSE, getter_AddRefs(iniFile)); #else rv = NS_NewNativeLocalFile(nsDependentCString(iniPath), PR_FALSE, getter_AddRefs(iniFile)); #endif if (NS_FAILED(rv)) { Output(PR_TRUE, "Couldn't find application.ini file.\n"); return 1; } AutoAppData appData(iniFile); if (!appData) { Output(PR_TRUE, "Error: couldn't parse application.ini.\n"); return 1; } NS_ASSERTION(appData->directory, "Failed to get app directory."); if (!appData->xreDirectory) { // chop "libxul.so" off the GRE path lastSlash = strrchr(greDir, PATH_SEPARATOR_CHAR); if (lastSlash) { *lastSlash = '\0'; } #ifdef XP_WIN // same as iniPath. NS_NewLocalFile(NS_ConvertUTF8toUTF16(greDir), PR_FALSE, &appData->xreDirectory); #else NS_NewNativeLocalFile(nsDependentCString(greDir), PR_FALSE, &appData->xreDirectory); #endif } retval = XRE_main(argc, argv, appData); } NS_LogTerm(); XPCOMGlueShutdown(); return retval; }
int main(int argc, char* argv[]) { if (argc > 1 && (IsArg(argv[1], "h") || IsArg(argv[1], "help") || IsArg(argv[1], "?"))) { Usage(); return 0; } if (argc == 2 && (IsArg(argv[1], "v") || IsArg(argv[1], "version"))) { Output(PR_FALSE, "Mozilla XULRunner %s\n", GRE_BUILD_ID); return 0; } if (argc > 1) { PRBool registerGlobal = IsArg(argv[1], "register-global"); PRBool registerUser = IsArg(argv[1], "register-user"); if (registerGlobal || registerUser) { if (argc != 2) { Usage(); return 1; } nsCOMPtr<nsIFile> regDir; nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir)); if (NS_FAILED(rv)) return 2; return RegisterXULRunner(registerGlobal, regDir, kGREProperties, NS_ARRAY_LENGTH(kGREProperties)) ? 0 : 2; } registerGlobal = IsArg(argv[1], "unregister-global"); registerUser = IsArg(argv[1], "unregister-user"); if (registerGlobal || registerUser) { if (argc != 2) { Usage(); return 1; } nsCOMPtr<nsIFile> regDir; nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir)); if (NS_FAILED(rv)) return 2; UnregisterXULRunner(registerGlobal, regDir); return 0; } if (IsArg(argv[1], "find-gre")) { if (argc != 3) { Usage(); return 1; } char path[MAXPATHLEN]; static const GREVersionRange vr = { argv[2], PR_TRUE, argv[2], PR_TRUE }; static const GREProperty kProperties[] = { { "xulrunner", "true" } }; nsresult rv = GRE_GetGREPathWithProperties(&vr, 1, kProperties, NS_ARRAY_LENGTH(kProperties), path, sizeof(path)); if (NS_FAILED(rv)) return 1; printf("%s\n", path); return 0; } if (IsArg(argv[1], "gre-version")) { if (argc != 2) { Usage(); return 1; } printf("%s\n", GRE_BUILD_ID); return 0; } if (IsArg(argv[1], "install-app")) { if (argc < 3 || argc > 5) { Usage(); return 1; } char *appLocation = argv[2]; char *installTo = nsnull; if (argc > 3) { installTo = argv[3]; if (!*installTo) // left blank? installTo = nsnull; } char *leafName = nsnull; if (argc > 4) { leafName = argv[4]; if (!*leafName) leafName = nsnull; } nsCOMPtr<nsIFile> regDir; nsresult rv = GetXULRunnerDir(argv[0], getter_AddRefs(regDir)); if (NS_FAILED(rv)) return 2; return InstallXULApp(regDir, appLocation, installTo, leafName); } } geckoVersion = ParseVersion(GRE_BUILD_ID); const char *appDataFile = PR_GetEnv("XUL_APP_FILE"); if (!(appDataFile && *appDataFile)) { if (argc < 2) { Usage(); return 1; } if (IsArg(argv[1], "app")) { if (argc == 2) { Usage(); return 1; } argv[1] = argv[0]; ++argv; --argc; } appDataFile = argv[1]; argv[1] = argv[0]; ++argv; --argc; static char kAppEnv[MAXPATHLEN]; PR_snprintf(kAppEnv, MAXPATHLEN, "XUL_APP_FILE=%s", appDataFile); PR_SetEnv(kAppEnv); } nsCAutoString vendor, name, version, buildID, appID, copyright; nsXREAppData appData = { sizeof(nsXREAppData), 0 }; int rv = LoadAppData(appDataFile, &appData, vendor, name, version, buildID, appID, copyright); if (!rv) rv = XRE_main(argc, argv, &appData); NS_IF_RELEASE(appData.directory); return rv; }
extern "C" gboolean gecko_init (void) { d("gecko_init()\n"); nsresult rv; #ifdef HAVE_GECKO_1_9 NS_LogInit (); #endif #ifdef XPCOM_GLUE static const GREVersionRange greVersion = { "1.9a", PR_TRUE, "2.0", PR_TRUE, }; char xpcomLocation[4096]; d("init XPCOM_GLUE\n"); rv = GRE_GetGREPathWithProperties( &greVersion, 1, nsnull, 0, xpcomLocation, 4096); if (NS_FAILED (rv)) { g_warning ("Could not determine locale!\n"); return FALSE; } // Startup the XPCOM Glue that links us up with XPCOM. rv = XPCOMGlueStartup(xpcomLocation); if (NS_FAILED (rv)) { g_warning ("Could not determine locale!\n"); return FALSE; } rv = GTKEmbedGlueStartup(); if (NS_FAILED (rv)) { g_warning ("Could not startup glue!\n"); return FALSE; } rv = GTKEmbedGlueStartupInternal(); if (NS_FAILED (rv)) { g_warning ("Could not startup internal glue!\n"); return FALSE; } char *lastSlash = strrchr(xpcomLocation, '/'); if (lastSlash) *lastSlash = '\0'; gtk_moz_embed_set_path(xpcomLocation); #else d(g_print("doing old gecko init\n")); #ifdef HAVE_GECKO_1_9 gtk_moz_embed_set_path (GECKO_HOME); #else gtk_moz_embed_set_comp_path (GECKO_HOME); #endif d("end gecko init()\n"); #endif /* XPCOM_GLUE */ d("load gecko prefs\n"); gchar *profile_dir = g_build_filename ( g_get_home_dir (), ".evolution", "mail", "rss", NULL); gtk_moz_embed_set_profile_path (profile_dir, "mozembed-rss"); g_free (profile_dir); d("embed push startup()\n"); gtk_moz_embed_push_startup (); nsCOMPtr<nsIPrefService> prefService ( do_GetService (NS_PREFSERVICE_CONTRACTID, &rv)); NS_ENSURE_SUCCESS (rv, FALSE); rv = CallQueryInterface (prefService, &gPrefBranch); NS_ENSURE_SUCCESS (rv, FALSE); d("finished all gecko init\n"); return TRUE; }