preferenceloader.java

SANCHO

/*
 * Copyright (C) 2004-2005 Rutger M. Ovidius for use with the sancho project.
 * See LICENSE.txt for license information.
 */

package sancho.view.preferences;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.preference.PreferenceConverter;
import org.eclipse.jface.preference.PreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;

import sancho.model.mldonkey.enums.EnumHostState;
import sancho.utility.SwissArmy;
import sancho.utility.VersionInfo;
import sancho.view.friends.clientDirectories.ClientDirectoriesTableView;
import sancho.view.server.ServerTableView;
import sancho.view.transfer.downloads.DownloadTableTreeView;
import sancho.view.utility.IDSelector;

public class PreferenceLoader {
  private static List colorArray = new ArrayList();
  private static Map colorMap = new Hashtable();
  private static List fontArray = new ArrayList();
  private static Map fontMap = new Hashtable();
  private static PreferenceStore preferenceStore = null;
  public static boolean customPrefFile; // winreg
  public static boolean customHomeDir; // winreg
  private static String prefFileName;
  private static String localeString;
  private static String homeDirectory;
  private static String ENTRY_SEPARATOR = ";";

  private PreferenceLoader() {
  }

  public static void cleanUp() {
    for (int i = 0; i < fontArray.size(); i++) {
      Font font = (Font) fontArray.get(i);
      if (font != null && !font.isDisposed())
        font.dispose();
    }
    for (int i = 0; i < colorArray.size(); i++) {
      Color color = (Color) colorArray.get(i);
      if (color != null && !color.isDisposed())
        color.dispose();
    }
  }

  public static boolean contains(String preferenceString) {
    return preferenceStore.contains(preferenceString);
  }

  public static PreferenceStore getPreferenceStore() {
    return preferenceStore;
  }

  public static String getLocaleString() {
    return localeString;
  }

  public static String getPrefFile() {
    return prefFileName;
  }

  public static void initialize() throws IOException {

    if (preferenceStore == null) {
      prefFileName = VersionInfo.getName() + ".pref";

      if (new File(prefFileName).exists())
        preferenceStore = new PreferenceStore(prefFileName);
      else {
        prefFileName = VersionInfo.getHomeDirectory() + prefFileName;

        File prefFile = new File(prefFileName);
        if (!prefFile.exists()) {
          File parentDir = new File(prefFile.getParent());
          parentDir.mkdirs();
        }
        preferenceStore = new PreferenceStore(prefFileName);
      }
    }

    try {
      preferenceStore.load();

    } catch (IOException e) {
      preferenceStore.save();
    }

    // preferenceStore = (PreferenceStore) setDefaults(preferenceStore);
  }

  public static void initialize2() {
    preferenceStore = (PreferenceStore) setDefaults(preferenceStore);
  }

  public static boolean loadBoolean(String preferenceString) {
    if (preferenceStore.contains(preferenceString))
      return preferenceStore.getBoolean(preferenceString);

    return false;
  }

  public static Color loadColor(String preferenceString) {
    if (preferenceStore.contains(preferenceString)) {
      Color newColor = new Color(null, PreferenceConverter.getColor(preferenceStore, preferenceString));
      if (colorMap.containsKey(preferenceString) && !((Color) colorMap.get(preferenceString)).isDisposed()) {
        if (newColor.getRGB().equals(((Color) colorMap.get(preferenceString)).getRGB()))
          newColor.dispose();
        else {
          colorArray.add(newColor);
          colorMap.put(preferenceString, newColor);
        }
      } else {
        colorArray.add(newColor);
        colorMap.put(preferenceString, newColor);
      }
      return (Color) colorMap.get(preferenceString);
    }
    return null;
  }

  public static Font loadFont(String preferenceString) {
    if (preferenceStore.contains(preferenceString)) {
      Font newFont = new Font(null, PreferenceConverter.getFontDataArray(preferenceStore, preferenceString));
      if (fontMap.containsKey(preferenceString) && !((Font) fontMap.get(preferenceString)).isDisposed()) {
        if (newFont.getFontData()[0].equals(((Font) fontMap.get(preferenceString)).getFontData()[0]))
          newFont.dispose();
        else {
          fontArray.add(newFont);
          fontMap.put(preferenceString, newFont);
        }
      } else {
        fontArray.add(newFont);
        fontMap.put(preferenceString, newFont);
      }
      return (Font) fontMap.get(preferenceString);
    }
    return null;
  }

  public static int loadInt(String preferenceString) {
    if (preferenceStore.contains(preferenceString))
      return preferenceStore.getInt(preferenceString);
    return 0;
  }

  public static int loadOrientation(String preferenceString) {
    if (preferenceStore.contains(preferenceString)) {
      int orientation = preferenceStore.getInt(preferenceString);
      if ((orientation == SWT.VERTICAL) || (orientation == SWT.HORIZONTAL))
        return orientation;
    }
    return SWT.HORIZONTAL;
  }

  public static Rectangle loadRectangle(String preferenceString) {
    if (preferenceStore.contains(preferenceString))
      return PreferenceConverter.getRectangle(preferenceStore, preferenceString);
    return null;
  }

  public static String loadString(String preferenceString) {
    if (preferenceStore.contains(preferenceString))
      return preferenceStore.getString(preferenceString).intern();
    return "";
  }

  public static String[] loadStringArray(String preferenceString) {
    StringTokenizer tokenizer = new StringTokenizer(loadString(preferenceString), ENTRY_SEPARATOR);
    int numTokens = tokenizer.countTokens();
    String[] stringArray = new String[numTokens];
    for (int i = 0; i < numTokens; i++) {
      stringArray[i] = tokenizer.nextToken();
    }
    return stringArray;
  }

  public static void setValue(String preferenceString, String[] stringArray) {
    StringBuffer buffer = new StringBuffer();
    for (int i = 0; i < stringArray.length; i++) {
      buffer.append(stringArray[i]);
      buffer.append(ENTRY_SEPARATOR);
    }

    preferenceStore.setValue(preferenceString, buffer.toString().intern());
  }

  public static void setValue(String preferenceString, String[] stringArray, int maxLength) {
    if (stringArray.length > maxLength) {
      String[] newArray = new String[maxLength];
      for (int i = 0; i < maxLength; i++)
        newArray[i] = stringArray[i];
      stringArray = newArray;
    }
    setValue(preferenceString, stringArray);
  }

  public static void saveStore() {
    try {
      preferenceStore.save();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }

  static void setDColor(IPreferenceStore pS, Display d, String string, int colorInt) {
    PreferenceConverter.setDefault(pS, string, d.getSystemColor(colorInt).getRGB());
  }

  static IPreferenceStore setDefaults(IPreferenceStore pS) {
    Display d = Display.getDefault();
    FontData[] dFontData = JFaceResources.getDefaultFont().getFontData();

    pS.setDefault("initialized", false);
    pS.setDefault("windowMaximized", false);
    pS.setDefault("coolbarLocked", true);
    pS.setDefault("toolbarSmallButtons", true);
    pS.setDefault("flatInterface", false);
    pS.setDefault("useGraident", true);
    pS.setDefault("splashScreen", true);
    pS.setDefault("killCoreOnExit", false);
    pS.setDefault("killSpawnedCoreOnExit", true);
    pS.setDefault("hostManagerOnStart", false);
    pS.setDefault("downloadCompleteDialog", false);
    pS.setDefault("downloadCompleteLog", true);
    pS.setDefault("explorerExecutable", SWT.getPlatform().equals("win32") ? "explorer" : "");
    pS.setDefault("explorerOpenFolder", "");
    pS.setDefault("linkRipperShowAll", false);

    pS.setDefault("dndBox", false);

    pS.setDefault("ircAutoConnect", false);
    pS.setDefault("ircServer", "irc.freenode.net");
    pS.setDefault("ircNickname", SwissArmy.getRandomString(7));
    pS.setDefault("ircChannel", "#mldonkey");
    pS.setDefault("consoleMaxLines", 300);

    pS.setDefault("mldonkey.InterestedInSources", true);

    pS.setDefault("tableAlternateBGColors", false);
    setDColor(pS, d, "tableAlternateBGColor", SWT.COLOR_INFO_BACKGROUND);
    setDColor(pS, d, "tablesBackgroundColor", SWT.COLOR_LIST_BACKGROUND);

    pS.setDefault("tableHilightSorted", false);
    setDColor(pS, d, "tableSortedColumnBGColor", SWT.COLOR_INFO_BACKGROUND);

    PreferenceConverter.setDefault(pS, "downloadCompleteWindowBounds", new Rectangle(0, 0, 320, 300));
    PreferenceConverter.setDefault(pS, "windowBounds", new Rectangle(40, 40, 580, 420));
    PreferenceConverter.setDefault(pS, "graphHistoryWindowBounds", new Rectangle(40, 40, 580, 420));
    PreferenceConverter.setDefault(pS, "dndBoxWindowBounds", new Rectangle(-1, 0, 0, 0));
    PreferenceConverter.setDefault(pS, "ircWindowBounds", new Rectangle(40, 40, 580, 420));

    setDColor(pS, d, "dndBackgroundColor", SWT.COLOR_WIDGET_BACKGROUND);
    setDColor(pS, d, "dndForegroundColor", SWT.COLOR_BLACK);
    PreferenceConverter.setDefault(pS, "dndFontData", dFontData);
    pS.setDefault("dndWidth", 15);

    setDColor(pS, d, "consoleBackground", SWT.COLOR_BLACK);
    setDColor(pS, d, "consoleForeground", SWT.COLOR_GREEN);
    setDColor(pS, d, "consoleHighlight", SWT.COLOR_WHITE);
    setDColor(pS, d, "consoleInputBackground", SWT.COLOR_BLACK);
    setDColor(pS, d, "consoleInputForeground", SWT.COLOR_GREEN);