BOOL
CPublishPrefs::InitDialog()
{

	// Composer/Publishing Preferences
	EnableDlgItem(IDC_AUTOADJUST_LINKS, !PREF_PrefIsLocked("editor.publish_keep_links"));
	EnableDlgItem(IDC_KEEP_IMAGE_WITH_DOC, !PREF_PrefIsLocked("editor.publish_keep_images"));
	EnableDlgItem(IDC_PUBLISH_FTP, !PREF_PrefIsLocked("editor.publish_location"));
	EnableDlgItem(IDC_PUBLISH_HTTP, !PREF_PrefIsLocked("editor.publish_browse_location"));
	
	return CEditorPropertyPage::InitDialog();;
}
BOOL
CEditorPrefs2::InitDialog()
{
	// Composer/Publishing Preferences
    EnableDlgItem(IDC_PAGEUPDOWN, !PREF_PrefIsLocked("editor.page_updown_move_cursor"));
	return CEditorPropertyPage::InitDialog();;
}
BOOL
CEditorPrefs::InitDialog()
{
	// Composer preferences
	EnableDlgItem(IDC_HTML_EDITOR, !PREF_PrefIsLocked("editor.html_editor"));
	EnableDlgItem(IDC_CHOOSE_HTML_EDITOR, !PREF_PrefIsLocked("editor.html_editor"));
	EnableDlgItem(IDC_IMAGE_EDITOR, !PREF_PrefIsLocked("editor.image_editor"));
	EnableDlgItem(IDC_CHOOSE_IMAGE_EDITOR, !PREF_PrefIsLocked("editor.image_editor"));
	EnableDlgItem(IDC_AUTO_SAVE, !PREF_PrefIsLocked("editor.auto_save"));
	EnableDlgItem(IDC_AUTO_SAVE_MINUTES, !PREF_PrefIsLocked("editor.auto_save_delay"));
	EnableDlgItem(IDC_FONTSIZE_MODE, !PREF_PrefIsLocked("editor.fontsize_mode"));
	EnableDlgItem(IDC_FONTSIZE_MODE2, !PREF_PrefIsLocked("editor.fontsize_mode"));
	EnableDlgItem(IDC_FONTSIZE_MODE3, !PREF_PrefIsLocked("editor.fontsize_mode"));
	
	return CEditorPropertyPage::InitDialog();;
}
Exemple #4
0
void XFE_PrefsProxiesViewDialog::initPage()
{
	XP_ASSERT(m_prefsDataProxiesView);

	PrefsDataProxiesView  *fep = m_prefsDataProxiesView;
	XFE_GlobalPrefs       *prefs = &fe_globalPrefs;
    char buf[1024];
    char* host;
    int port;

#define FROB(SLOT,SUFFIX,DEF)                               \
    host = prefs->SLOT##_##SUFFIX;                          \
    port = prefs->SLOT##_##SUFFIX##_port;                   \
    if ( port == 0 ) {                                      \
        strcpy(buf, DEF);                                   \
    } else {                                                \
	    sprintf(buf, "%d", port);                           \
    }                                                       \
	fe_SetTextField(fep->SLOT##_##SUFFIX##_text, host); \
	fe_SetTextField(fep->SLOT##_port_text, buf)

	FROB(ftp,      proxy, "");
    FROB(gopher,   proxy, "");
    FROB(http,     proxy, "");
#ifndef NO_SECURITY
    FROB(https,    proxy, "");
#endif
	FROB(wais,     proxy, "");
	FROB(socks,    host,  "1080");
#undef FROB
	
	XtSetSensitive(fep->ftp_proxy_text, !PREF_PrefIsLocked("network.proxy.ftp"));
	XtSetSensitive(fep->ftp_port_text, !PREF_PrefIsLocked("network.proxy.ftp_port"));
	XtSetSensitive(fep->gopher_proxy_text, !PREF_PrefIsLocked("network.proxy.gopher"));
	XtSetSensitive(fep->gopher_port_text, !PREF_PrefIsLocked("network.proxy.gopher_port"));
	XtSetSensitive(fep->http_proxy_text, !PREF_PrefIsLocked("network.proxy.http"));
	XtSetSensitive(fep->http_port_text, !PREF_PrefIsLocked("network.proxy.http_port"));
	XtSetSensitive(fep->https_proxy_text, !PREF_PrefIsLocked("network.proxy.ssl"));
	XtSetSensitive(fep->https_port_text, !PREF_PrefIsLocked("network.proxy.ssl_port"));
	XtSetSensitive(fep->wais_proxy_text, !PREF_PrefIsLocked("network.proxy.wais"));
	XtSetSensitive(fep->wais_port_text, !PREF_PrefIsLocked("network.proxy.wais_port"));
	XtSetSensitive(fep->no_proxy_text, !PREF_PrefIsLocked("network.proxy.no_proxies_on"));
	XtSetSensitive(fep->socks_host_text, !PREF_PrefIsLocked("network.hosts.socks_server"));
	XtSetSensitive(fep->socks_port_text, !PREF_PrefIsLocked("network.hosts.socks_serverport"));

	fe_SetTextField(fep->no_proxy_text, prefs->no_proxy);
}
Exemple #5
0
NS_IMETHODIMP nsPrefBranch::GetComplexValue(const char *aPrefName, const nsIID & aType, void * *_retval)
{
  nsresult       rv;
  nsXPIDLCString utf8String;

  // we have to do this one first because it's different than all the rest
  if (aType.Equals(NS_GET_IID(nsIPrefLocalizedString))) {
    nsCOMPtr<nsIPrefLocalizedString> theString(do_CreateInstance(NS_PREFLOCALIZEDSTRING_CONTRACTID, &rv));

    if (NS_SUCCEEDED(rv)) {
      const char *pref;
      PRBool  bNeedDefault = PR_FALSE;

      rv = getValidatedPrefName(aPrefName, &pref);
      if (NS_FAILED(rv))
        return rv;

      if (mIsDefault) {
        bNeedDefault = PR_TRUE;
      } else {
        // if there is no user (or locked) value
        if (!PREF_HasUserPref(pref) && !PREF_PrefIsLocked(pref)) {
          bNeedDefault = PR_TRUE;
        }
      }

      // if we need to fetch the default value, do that instead, otherwise use the
      // value we pulled in at the top of this function
      if (bNeedDefault) {
        nsXPIDLString utf16String;
        rv = GetDefaultFromPropertiesFile(pref, getter_Copies(utf16String));
        if (NS_SUCCEEDED(rv)) {
          rv = theString->SetData(utf16String.get());
        }
      } else {
        rv = GetCharPref(aPrefName, getter_Copies(utf8String));
        if (NS_SUCCEEDED(rv)) {
          rv = theString->SetData(NS_ConvertUTF8toUCS2(utf8String).get());
        }
      }
      if (NS_SUCCEEDED(rv)) {
        nsIPrefLocalizedString *temp = theString;

        NS_ADDREF(temp);
        *_retval = (void *)temp;
      }
    }

    return rv;
  }

  // if we can't get the pref, there's no point in being here
  rv = GetCharPref(aPrefName, getter_Copies(utf8String));
  if (NS_FAILED(rv)) {
    return rv;
  }

  if (aType.Equals(NS_GET_IID(nsILocalFile))) {
    nsCOMPtr<nsILocalFile> file(do_CreateInstance(NS_LOCAL_FILE_CONTRACTID, &rv));

    if (NS_SUCCEEDED(rv)) {
      rv = file->SetPersistentDescriptor(utf8String);
      if (NS_SUCCEEDED(rv)) {
        nsILocalFile *temp = file;

        NS_ADDREF(temp);
        *_retval = (void *)temp;
        return NS_OK;
      }
    }
    return rv;
  }

  if (aType.Equals(NS_GET_IID(nsIRelativeFilePref))) {
    nsACString::const_iterator keyBegin, strEnd;
    utf8String.BeginReading(keyBegin);
    utf8String.EndReading(strEnd);    

    // The pref has the format: [fromKey]a/b/c
    if (*keyBegin++ != '[')        
        return NS_ERROR_FAILURE;
    nsACString::const_iterator keyEnd(keyBegin);
    if (!FindCharInReadable(']', keyEnd, strEnd))
        return NS_ERROR_FAILURE;
    nsCAutoString key(Substring(keyBegin, keyEnd));
    
    nsCOMPtr<nsILocalFile> fromFile;        
    nsCOMPtr<nsIProperties> directoryService(do_GetService(NS_DIRECTORY_SERVICE_CONTRACTID, &rv));
    if (NS_FAILED(rv))
      return rv;
    rv = directoryService->Get(key.get(), NS_GET_IID(nsILocalFile), getter_AddRefs(fromFile));
    if (NS_FAILED(rv))
      return rv;
    
    nsCOMPtr<nsILocalFile> theFile;
    rv = NS_NewNativeLocalFile(EmptyCString(), PR_TRUE, getter_AddRefs(theFile));
    if (NS_FAILED(rv))
      return rv;
    rv = theFile->SetRelativeDescriptor(fromFile, Substring(++keyEnd, strEnd));
    if (NS_FAILED(rv))
      return rv;
    nsCOMPtr<nsIRelativeFilePref> relativePref;
    rv = NS_NewRelativeFilePref(theFile, key, getter_AddRefs(relativePref));
    if (NS_FAILED(rv))
      return rv;

    *_retval = relativePref;
    NS_ADDREF(NS_STATIC_CAST(nsIRelativeFilePref*, *_retval));
    return NS_OK;
  }