src/cx/fbn/nevernote/Global.java

   1 /*
   2  * This file is part of NixNote/NeighborNote
   3  * Copyright 2009 Randy Baumgarte
   4  * Copyright 2013 Yuki Takahashi
   5  *
   6  * This file may be licensed under the terms of of the
   7  * GNU General Public License Version 2 (the ``GPL'').
   8  *
   9  * Software distributed under the License is distributed
  10  * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
  11  * express or implied. See the GPL for the specific language
  12  * governing rights and limitations.
  13  *
  14  * You should have received a copy of the GPL along with this
  15  * program. If not, go to http://www.gnu.org/licenses/gpl.html
  16  * or write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  *
  19 */
  20
  21 package cx.fbn.nevernote;
  22
  23
  24 import java.io.ByteArrayInputStream;
  25 import java.io.ByteArrayOutputStream;
  26 import java.io.IOException;
  27 import java.io.ObjectInputStream;
  28 import java.io.ObjectOutputStream;
  29 import java.text.SimpleDateFormat;
  30 import java.util.ArrayList;
  31 import java.util.Calendar;
  32 import java.util.HashMap;
  33 import java.util.List;
  34
  35 import org.apache.commons.lang3.StringEscapeUtils;
  36
  37 import com.evernote.edam.type.Accounting;
  38 import com.evernote.edam.type.PrivilegeLevel;
  39 import com.evernote.edam.type.User;
  40 import com.evernote.edam.type.UserAttributes;
  41 import com.swabunga.spell.engine.Configuration;
  42 import com.trolltech.qt.core.QByteArray;
  43 import com.trolltech.qt.core.QSettings;
  44 import com.trolltech.qt.core.QSize;
  45 import com.trolltech.qt.gui.QPalette;
  46 import com.trolltech.qt.gui.QSystemTrayIcon;
  47
  48 import cx.fbn.nevernote.config.FileManager;
  49 import cx.fbn.nevernote.config.InitializationException;
  50 import cx.fbn.nevernote.config.StartupConfig;
  51 import cx.fbn.nevernote.gui.ContainsAttributeFilterTable;
  52 import cx.fbn.nevernote.gui.DateAttributeFilterTable;
  53 import cx.fbn.nevernote.gui.ShortcutKeys;
  54 import cx.fbn.nevernote.utilities.ApplicationLogger;
  55 import cx.fbn.nevernote.utilities.Pair;
  56
  57
  58 //*****************************************************
  59 //*****************************************************
  60 //* Global constants & static functions used by
  61 //* multiple threads.
  62 //*****************************************************
  63 //*****************************************************
  64
  65 public class Global {
  66         // Set current version and the known versions.
  67         // ICHANGED 自分用に変更
  68         public static String version = "0.1";
  69         public static String[] validVersions = {"0.1"};
  70
  71     public static String username = "";
  72     //public static String password = "";
  73
  74
  75     // Each thread has an ID.  This is used primarily to check the status
  76     // of running threads.
  77     public static final int mainThreadId=0;
  78     public static final int syncThreadId=1;
  79     public static final int tagCounterThreadId=2;
  80     public static final int trashCounterThreadId=3;   // This should always be the highest thread ID
  81     public static final int indexThreadId=4;    // Thread for indexing words
  82     public static final int saveThreadId=5;     // Thread used for processing data to saving content
  83     public static final int notebookCounterThreadId=6;   // Notebook Thread
  84     public static final int indexThread03Id=7;   // unused
  85     public static final int indexThread04Id=8;   // unused
  86     public static final int dbThreadId=9;   // This should always be the highest thread ID
  87     public static final int threadCount = 10;
  88
  89
  90     // These variables deal with where the list of notes appears
  91     // They will either be vertical (View_List_Narrow) or will be
  92     // on top of the note (View_List_Wide).  It also has the size of
  93     // thumbnails displayed in each view
  94     public static int View_List_Wide = 1;
  95     public static int View_List_Narrow = 2;
  96     public static QSize smallThumbnailSize = new QSize(100,75);
  97     public static QSize largeThumbnailSize = new QSize(300,225);
  98
  99     // This is used to keep a running list of passwords that the user
 100     // wants us to remember.
 101     public static HashMap<String,Pair<String,String>> passwordSafe = new HashMap<String, Pair<String,String>>();
 102     public static List<Pair<String,String>> passwordRemember = new ArrayList<Pair<String,String>>();
 103
 104
 105     //public static String currentNotebookGuid;
 106
 107     // These deal with Evernote user settings
 108     public static User user;
 109     public static long authTimeRemaining;
 110     public static long authRefreshTime;
 111     public static long failedRefreshes = 0;
 112     public static String userStoreUrl;
 113     public static String noteStoreUrl;
 114     public static String noteStoreUrlBase;
 115
 116     // When we want to shut down we set this to true to short
 117     // circut other threads
 118     public static boolean keepRunning;
 119
 120     // In the note list, these are the column numbers
 121     // so I don't need to hard code numbers.
 122     public static int noteTableCreationPosition = 0;
 123     public static int noteTableTitlePosition = 1;
 124     public static int noteTableTagPosition = 2;
 125     public static int noteTableNotebookPosition = 3;
 126     public static int noteTableChangedPosition = 4;
 127     public static int noteTableGuidPosition = 5;
 128     public static int noteTableAuthorPosition = 6;
 129     public static int noteTableSourceUrlPosition = 7;
 130     public static int noteTableSubjectDatePosition = 8;
 131     public static int noteTableSynchronizedPosition = 9;
 132     public static int noteTableThumbnailPosition = 10;
 133     public static int noteTablePinnedPosition = 11;
 134     public static int noteTableColumnCount = 12;
 135     public static Integer cryptCounter = 0;
 136
 137     //public static int minimumWordCount = 2;
 138
 139     // Regular expression to parse text with when indexing
 140     private static String wordRegex;
 141
 142     // Experimental fixes.  Set via Edit/Preferences/Debugging
 143     public static boolean enableCarriageReturnFix = false;
 144     public static boolean enableHTMLEntitiesFix = false;
 145
 146     // Used to set & retrieve ini & Windows registry settings
 147     public static QSettings     settings;     // Set & get ini settings
 148     public static boolean isConnected;    // Are we connected to Evernote
 149     public static boolean showDeleted = false;   // Show deleted notes?
 150     public static boolean disableUploads = false;  // Should we disable uploads (used in testing features)
 151         public static int messageLevel;   // The level of messages to write to the log files
 152         public static String tagDelimeter = ",";   // This is used to separate out tag names when entering above note
 153         public static String attachmentNameDelimeter = "------";  // Used to separate out attachment names in the res directory
 154
 155
 156         //* Database fields
 157         public static String    databaseName = new String("NeverNote");  // database name.  used for multiple databases to separate settings.
 158         public static String    indexDatabaseName = new String("Index"); // searchable words database
 159         public static String    resourceDatabaseName = new String("Resources");  // attachments database
 160
 161         // ICHANGED
 162         public static String behaviorDatabaseName = new String("Behavior"); // 操作履歴データベース
 163
 164         public static DateAttributeFilterTable createdSinceFilter;
 165         public static DateAttributeFilterTable createdBeforeFilter;
 166         public static DateAttributeFilterTable changedSinceFilter;
 167         public static DateAttributeFilterTable changedBeforeFilter;
 168         public static ContainsAttributeFilterTable containsFilter;
 169
 170         // Log file used for debugging
 171         public static ApplicationLogger    logger;
 172         //PrintStream stdoutStream;
 173
 174         // Application key shortcuts & appearance
 175         public static QPalette                          originalPalette;
 176         public static ShortcutKeys                      shortcutKeys;
 177
 178         public static boolean                           disableViewing;  // used to disable the editor
 179
 180         // When saving a note, this is a list of things we strip out because Evernote hates them
 181         public static List<String>                              invalidElements = new ArrayList<String>();
 182         public static HashMap<String, ArrayList<String>>        invalidAttributes = new HashMap<String, ArrayList<String>>();
 183
 184         public static boolean mimicEvernoteInterface; // Try to mimic Evernote or allow multiple notebook selection
 185         public static HashMap<String,String> resourceMap;   // List of attachments for a note.
 186         public static String cipherPassword = "";    // If the database is encrypted, this stores the password
 187         public static String databaseCache = "16384";  // Default DB cache size
 188
 189         // These are used for performance testing
 190         static Calendar startTraceTime;
 191         static Calendar intervalTraceTime;
 192
 193         static boolean syncOnly;
 194
 195         private static FileManager fileManager;  // Used to access files & directories
 196
 197     // Do initial setup
 198     public static void setup(StartupConfig startupConfig) throws InitializationException  {
 199         // ICHANGED 設定値の保存先を変更
 200         settings = new QSettings("NeighborNote.ini", QSettings.Format.IniFormat);
 201
 202         disableViewing = startupConfig.getDisableViewing();
 203         syncOnly = startupConfig.isSyncOnly();
 204
 205         fileManager = new FileManager(startupConfig.getHomeDirPath(), startupConfig.getProgramDirPath());
 206
 207
 208                 getServer();  // Setup URL to connect to
 209
 210                 // Get regular expressions used to parse out words
 211                 settings.beginGroup("General");
 212                 String regex = (String) settings.value("regex", "[,\\s]+");
 213                 setWordRegex(regex);
 214                 settings.endGroup();
 215
 216                 //Setup debugging information
 217                 settings.beginGroup("Debug");
 218                 String msglevel = (String) settings.value("messageLevel", "Low");
 219                 settings.endGroup();
 220
 221
 222                 //messageLevel = 1;
 223                 setMessageLevel(msglevel);
 224                 keepRunning = true;  // Make sure child threads stay running
 225                 disableUploads = disableUploads();  // Should we upload anything?  Normally false.\r
 226                 //disableUploads = true;  //***** DELETE THIS LINE *******\r
 227                 enableCarriageReturnFix = enableCarriageReturnFix();  // Enable test fix?
 228                 enableHTMLEntitiesFix = enableHtmlEntitiesFix();  // Enable test fix?
 229
 230                 logger = new ApplicationLogger("global.log");  // Setup log for this class
 231                 shortcutKeys = new ShortcutKeys();  // Setup keyboard shortcuts.
 232                 mimicEvernoteInterface = getMimicEvernoteInterface();  // Should we mimic Evernote's notebook behavior
 233                 resourceMap = new HashMap<String,String>();  // Setup resource map used to store attachments when editing
 234
 235                 databaseCache = getDatabaseCacheSize();  // Set database cache size
 236
 237                 Global.username = getUserInformation().getUsername();
 238     }
 239
 240     // Get/Set word parsing regular expression
 241     public static String getWordRegex() {
 242         return wordRegex;
 243     }
 244     public static void setWordRegex(String r) {
 245         wordRegex = r;
 246     }
 247
 248    // Set the debug message level
 249    public static void setMessageLevel(String msglevel) {
 250         if (msglevel.equalsIgnoreCase("low"))
 251                         messageLevel = 1;
 252                 if (msglevel.equalsIgnoreCase("medium"))
 253                         messageLevel = 2;
 254                 if (msglevel.equalsIgnoreCase("high"))
 255                                 messageLevel = 3;
 256                 if (msglevel.equalsIgnoreCase("extreme"))
 257                                         messageLevel = 4;
 258                 settings.beginGroup("Debug");
 259                 settings.setValue("messageLevel", msglevel);
 260                 settings.endGroup();
 261     }
 262
 263    //****************************************************
 264    //****************************************************
 265    //** Save user account information from Evernote
 266    //****************************************************
 267    //****************************************************
 268     public static void saveUserInformation(User user) {
 269         settings.beginGroup("User");
 270                 settings.setValue("id", user.getId());
 271                 settings.setValue("username", user.getUsername());
 272                 settings.setValue("email", user.getEmail());
 273                 settings.setValue("name", user.getName());
 274                 settings.setValue("timezone", user.getTimezone());
 275                 settings.setValue("privilege", user.getPrivilege().getValue());
 276                 settings.setValue("created", user.getCreated());
 277                 settings.setValue("updated", user.getUpdated());
 278                 settings.setValue("deleted", user.getDeleted());
 279                 settings.setValue("shard", user.getShardId());
 280                 settings.endGroup();
 281                 isPremium();
 282                 if (user.getAttributes()!=null)
 283                         saveUserAttributes(user.getAttributes());
 284                 if (user.getAccounting()!=null)
 285                         saveUserAccounting(user.getAccounting());
 286
 287     }
 288     public static User getUserInformation() {
 289         User user = new User();
 290         settings.beginGroup("User");
 291         try {
 292                 user.setId((Integer)settings.value("id", 0));
 293         } catch  (java.lang.ClassCastException e) {
 294                 user.setId(new Integer((String)settings.value("id", "0")));
 295         }
 296                 String username = (String)settings.value("username", "");
 297                 String email = (String)settings.value("email", "");
 298                 String name = (String)settings.value("name", "");
 299                 String timezone = (String)settings.value("timezone", "");
 300                 Integer privilege = 0;
 301                 try {
 302                         privilege = new Integer((String)settings.value("privilege", "0"));
 303                 } catch (java.lang.ClassCastException e) {
 304                         privilege = (Integer)settings.value("privilege", 0);
 305                 }
 306
 307                 try {
 308                         String date = (String)settings.value("created", "0");
 309                         user.setCreated(new Long(date));
 310                         date = (String)settings.value("updated", "0");
 311                         user.setUpdated(new Long(date));
 312                         date = (String)settings.value("deleted", "0");
 313                         user.setDeleted(new Long(date));
 314                 } catch (java.lang.ClassCastException e) {
 315                         Long date = (Long)settings.value("created", 0);
 316                         user.setCreated(date);
 317                         date = (Long)settings.value("updated", 0);
 318                         user.setUpdated(date);
 319                         date = (Long)settings.value("deleted", 0);
 320                         user.setDeleted(date);
 321                 }
 322
 323                 String shard = (String)settings.value("shard", "");
 324         settings.endGroup();
 325
 326         user.setUsername(username);
 327         user.setEmail(email);
 328         user.setName(name);
 329         user.setTimezone(timezone);
 330         PrivilegeLevel userLevel = PrivilegeLevel.findByValue(privilege);
 331         user.setPrivilege(userLevel);
 332         user.setShardId(shard);
 333         return user;
 334     }
 335
 336     public static void saveUserAttributes(UserAttributes attrib) {
 337         settings.beginGroup("UserAttributes");
 338                 settings.setValue("defaultLocationName", attrib.getDefaultLocationName());
 339                 settings.setValue("defaultLatitude", attrib.getDefaultLocationName());
 340                 settings.setValue("defaultLongitude", attrib.getDefaultLocationName());
 341                 settings.setValue("incomingEmailAddress", attrib.getIncomingEmailAddress());
 342                 settings.endGroup();
 343     }
 344     public static UserAttributes getUserAttributes() {
 345         settings.beginGroup("UserAttributes");
 346         UserAttributes attrib = new UserAttributes();
 347                 attrib.setDefaultLocationName((String)settings.value("defaultLocationName",""));
 348                 attrib.setDefaultLatitudeIsSet(false);
 349                 attrib.setDefaultLongitudeIsSet(false);
 350                 attrib.setIncomingEmailAddress((String)settings.value("incomingEmailAddress", ""));
 351                 settings.endGroup();
 352                 return attrib;
 353     }
 354     public static void saveUserAccounting(Accounting acc) {
 355         settings.beginGroup("UserAccounting");
 356                 settings.setValue("uploadLimit", acc.getUploadLimit());
 357                 settings.setValue("uploadLimitEnd", acc.getUploadLimitEnd());
 358                 settings.setValue("uploadLimitNextMonth", acc.getUploadLimitNextMonth());
 359                 settings.setValue("premiumServiceStart", acc.getPremiumServiceStart());
 360                 settings.setValue("nextPaymentDue", acc.getNextPaymentDue());
 361                 settings.setValue("uploadAmount", acc.getUpdated());
 362                 settings.endGroup();
 363     }
 364     public static long getUploadLimitEnd() {
 365         Long limit;
 366         settings.beginGroup("UserAccounting");
 367
 368         // Upload limit
 369                 try {
 370                         String val  = (String)settings.value("uploadLimitEnd", "0");
 371                         limit = new Long(val.trim());
 372                 } catch (Exception e) {
 373                         try {
 374                                 limit = (Long)settings.value("uploadLimitEnd", 0);
 375                         } catch (Exception e1) {
 376                                 limit = new Long(0);
 377                         }
 378                 }
 379
 380                 // return value
 381         settings.endGroup();
 382         return limit;
 383     }
 384     public static void saveUploadAmount(long amount) {
 385         settings.beginGroup("UserAccounting");
 386                 settings.setValue("uploadAmount", amount);
 387                 settings.endGroup();
 388    }
 389     public static long getUploadAmount() {
 390                 long amt=0;
 391                 settings.beginGroup("UserAccounting");
 392                 try {
 393                         String num = (String)settings.value("uploadAmount", "0");
 394                         amt = new Long(num.trim());
 395                 } catch (Exception e) {
 396                         try {
 397                                 amt = (Integer)settings.value("uploadAmount", 0);
 398                         } catch (Exception e1) {
 399                                 amt = 0;
 400                         }
 401                 }
 402                 settings.endGroup();
 403                 return amt;
 404     }
 405     public static void saveEvernoteUpdateCount(long amount) {
 406         settings.beginGroup("UserAccounting");
 407                 settings.setValue("updateCount", amount);
 408                 settings.endGroup();
 409     }
 410     public static long getEvernoteUpdateCount() {
 411                 long amt;
 412                 settings.beginGroup("UserAccounting");
 413                 try {
 414                         String num = (String)settings.value("updateCount", new Long(0).toString());
 415                         amt = new Long(num.trim());
 416                 } catch (java.lang.ClassCastException e) {
 417                         amt = 0;
 418                 }
 419                 settings.endGroup();
 420                 return amt;
 421     }
 422     public static boolean isPremium() {
 423                 int level;
 424                 settings.beginGroup("User");
 425                 try {
 426                         String num = (String)settings.value("privilege", "1");
 427                         level = new Integer(num.trim());
 428                 } catch (java.lang.ClassCastException e) {
 429                         try {
 430                                 level = (Integer)settings.value("privilege", 1);
 431                         } catch (Exception e1) {
 432                                 level = 1;
 433                         }
 434                 }
 435                 settings.endGroup();
 436                 PrivilegeLevel userLevel = PrivilegeLevel.findByValue(level);
 437                 if (userLevel == PrivilegeLevel.NORMAL)
 438                         return false;
 439                 return true;
 440
 441    }
 442     public static long getUploadLimit() {
 443                 settings.beginGroup("UserAccounting");
 444                 long limit;
 445                 try {
 446                         String num = (String)settings.value("uploadLimit", new Long(0).toString());
 447                         limit = new Long(num.trim());
 448                 } catch (java.lang.ClassCastException e) {
 449                         limit = 0;
 450                 }
 451                 settings.endGroup();
 452                 return limit;
 453     }
 454
 455
 456
 457     //****************************************************
 458     //****************************************************
 459     //** View settings.  Used to restore settings
 460     //** when starting and to control how the program
 461     //** behaves.
 462     //****************************************************
 463     //****************************************************
 464
 465     //* Get/Set if we should show a tray icon
 466     public static boolean showTrayIcon() {
 467                 settings.beginGroup("General");
 468                 try {
 469                         String max = (String) settings.value("showTrayIcon", "false");
 470                         settings.endGroup();
 471                         if (!max.equalsIgnoreCase("true") || !QSystemTrayIcon.isSystemTrayAvailable())
 472                                 return false;
 473                         else
 474                                 return true;
 475                 } catch (java.lang.ClassCastException e) {
 476                         Boolean value = (Boolean) settings.value("showTrayIcon", false);
 477                         settings.endGroup();
 478                         return value;
 479                 }
 480     }
 481     public static void setShowTrayIcon(boolean val) {
 482                 settings.beginGroup("General");
 483                 if (val)
 484                         settings.setValue("showTrayIcon", "true");
 485                 else
 486                         settings.setValue("showTrayIcon", "false");
 487                 settings.endGroup();
 488     }
 489
 490     // Get/Set window maximized when closed last
 491     public static boolean wasWindowMaximized() {
 492         try {
 493                         settings.beginGroup("General");
 494                         String max = (String) settings.value("isMaximized", "true");
 495                         settings.endGroup();
 496                         if (!max.equalsIgnoreCase("true"))
 497                                 return false;
 498                         return true;
 499                 } catch (java.lang.ClassCastException e) {
 500                         Boolean value = (Boolean) settings.value("isMaximized", true);
 501                         settings.endGroup();
 502                         return value;
 503                 }
 504     }
 505     public static void saveWindowMaximized(boolean isMax) {
 506                 settings.beginGroup("General");
 507                 if (isMax)
 508                         settings.setValue("isMaximized", "true");
 509                 else
 510                         settings.setValue("isMaximized", "false");
 511                 settings.endGroup();
 512     }
 513
 514     // Get/set currently viewed note Guid
 515     public static String getLastViewedNoteGuid() {
 516                 settings.beginGroup("General");
 517                 String guid = (String) settings.value("lastViewedNote", "");
 518                 settings.endGroup();
 519                 return guid;
 520     }
 521     public static void saveCurrentNoteGuid(String guid) {
 522                 settings.beginGroup("General");
 523                 if (guid != null)
 524                         settings.setValue("lastViewedNote", guid);
 525                 else
 526                         settings.setValue("lastViewedNote", "");
 527                 settings.endGroup();
 528     }
 529
 530     // Get/Set the note column we are sorted on and the order
 531     public static void setSortColumn(int i) {
 532         int view = Global.getListView();
 533                 settings.beginGroup("General");
 534         if (view == Global.View_List_Wide)
 535                 settings.setValue("sortColumn", i);
 536         else
 537                 settings.setValue("sortColumn-Narrow", i);
 538                 settings.endGroup();
 539     }
 540     public static int getSortColumn() {;
 541     String key;
 542         if (Global.getListView() == Global.View_List_Wide)
 543                 key = "sortColumn";
 544         else
 545                 key = "sortColumn-Narrow";
 546
 547         settings.beginGroup("General");
 548         int order;
 549         try {
 550                 String val  = settings.value(key, new Integer(0)).toString();
 551                 order = new Integer(val.trim());
 552         } catch (Exception e) {
 553                 try {
 554                         order = (Integer)settings.value(key, 0);
 555                 } catch (Exception e1) {
 556                     order = 0;
 557                 }
 558         }
 559
 560         settings.endGroup();
 561         return order;
 562     }
 563     public static void setSortOrder(int i) {
 564         int view = Global.getListView();
 565                 settings.beginGroup("General");
 566         if (view == Global.View_List_Wide)
 567                 settings.setValue("sortOrder", i);
 568         else
 569                 settings.setValue("sortOrder-Narrow", i);
 570                 settings.endGroup();
 571     }
 572     public static int getSortOrder() {
 573         int view = Global.getListView();
 574                 settings.beginGroup("General");
 575                 String key;
 576         if (view == Global.View_List_Wide)
 577                 key = "sortOrder";
 578                 else
 579                         key = "sortOrder-Narrow";
 580
 581                 int order;
 582                 try {
 583                         String val  = settings.value(key, new Integer(0)).toString();
 584                         order = new Integer(val.trim());
 585                 } catch (Exception e) {
 586                         try {
 587                                 order = (Integer)settings.value(key, 0);
 588                         } catch (Exception e1) {
 589                             order = 0;
 590                         }
 591                 }
 592
 593                 settings.endGroup();
 594                 return order;
 595     }
 596
 597     // Should we automatically log in to Evernote when starting?
 598     public static boolean automaticLogin() {
 599         try {
 600                 settings.beginGroup("General");
 601                 String text = (String)settings.value("automaticLogin", "false");
 602                 settings.endGroup();
 603                 if (text.equalsIgnoreCase("true"))
 604                         return true;
 605                 else
 606                         return false;
 607         } catch (java.lang.ClassCastException e) {
 608                 Boolean value = (Boolean) settings.value("automaticLogin", false);
 609                 settings.endGroup();
 610                 return value;
 611         }
 612     }
 613     public static void setAutomaticLogin(boolean val) {
 614                 settings.beginGroup("General");
 615                 if (val)
 616                         settings.setValue("automaticLogin", "true");
 617                 else
 618                         settings.setValue("automaticLogin", "false");
 619                 settings.endGroup();
 620     }
 621
 622     // Get/set the Evernote server Url.
 623     public static void setServer(String server) {
 624                 settings.beginGroup("General");
 625                 settings.setValue("server", server);
 626                 settings.endGroup();
 627     }
 628     public static String getServer() {
 629                 settings.beginGroup("General");
 630                 String text = (String)settings.value("server", "www.evernote.com");
 631                 if (text.equals("www.evernote.com")) {
 632                         userStoreUrl = "https://www.evernote.com/edam/user";
 633                     noteStoreUrlBase = "www.evernote.com/edam/note/";
 634                 } else {
 635                         userStoreUrl = "https://sandbox.evernote.com/edam/user";
 636                         noteStoreUrlBase = "sandbox.evernote.com/edam/note/";
 637                 }
 638                 settings.endGroup();
 639 //              if (isPremium())
 640                         noteStoreUrlBase = "https://" + noteStoreUrlBase;
 641 //              else
 642 //                      noteStoreUrlBase = "http://" + noteStoreUrlBase;
 643                 return text;
 644     }
 645
 646     // Get/Set if we should disable uploads to Evernote
 647     public static boolean disableUploads() {
 648         settings.beginGroup("General");
 649         try {
 650                 String text = (String)settings.value("disableUploads", "false");
 651                 settings.endGroup();
 652                 if (text.equalsIgnoreCase("true"))
 653                         return true;
 654                 else
 655                         return false;
 656                 } catch (java.lang.ClassCastException e) {
 657                         Boolean value = (Boolean) settings.value("disableUploads", false);
 658                         settings.endGroup();
 659                         return value;
 660                 }
 661     }
 662     public static void setDisableUploads(boolean val) {
 663                 settings.beginGroup("General");
 664                 if (val)
 665                         settings.setValue("disableUploads", "true");
 666                 else
 667                         settings.setValue("disableUploads", "false");
 668                 settings.endGroup();
 669                 disableUploads = val;
 670     }
 671
 672     // Should we view PDF documents inline?
 673     public static boolean pdfPreview() {
 674                 settings.beginGroup("General");
 675                 try {
 676                         String text = (String)settings.value("pdfPreview", "true");
 677                         settings.endGroup();
 678                         if (text.equalsIgnoreCase("true"))
 679                                 return true;
 680                         else
 681                                 return false;
 682                 } catch (java.lang.ClassCastException e) {
 683                         Boolean value = (Boolean) settings.value("pdfPreview", true);
 684                         settings.endGroup();
 685                         return value;
 686                 }
 687     }
 688     public static void setPdfPreview(boolean val) {
 689                 settings.beginGroup("General");
 690                 if (val)
 691                         settings.setValue("pdfPreview", "true");
 692                 else
 693                         settings.setValue("pdfPreview", "false");
 694                 settings.endGroup();
 695     }
 696
 697     // When creating a new note, should it inherit tags that are currently selected?
 698     public static boolean newNoteWithSelectedTags() {
 699                 settings.beginGroup("General");
 700                 try {
 701                         String text = (String)settings.value("newNoteWithSelectedTags", "false");
 702                         settings.endGroup();
 703                         if (text.equalsIgnoreCase("true"))
 704                                 return true;
 705                         else
 706                                 return false;
 707                 } catch (java.lang.ClassCastException e) {
 708                         Boolean value = (Boolean) settings.value("newNoteWithSelectedTags", false);
 709                         settings.endGroup();
 710                         return value;
 711                 }
 712     }
 713     public static void setNewNoteWithSelectedTags(boolean val) {
 714                 settings.beginGroup("General");
 715                 if (val)
 716                         settings.setValue("newNoteWithSelectedTags", "true");
 717                 else
 718                         settings.setValue("newNoteWithSelectedTags", "false");
 719                 settings.endGroup();
 720     }
 721
 722     // Minimum weight for text OCRed from Evernote. Anything below this
 723     // Won't be shown to the user when they search
 724     public static void setRecognitionWeight(int len) {
 725                 settings.beginGroup("General");
 726                 settings.setValue("recognitionWeight", len);
 727                 settings.endGroup();
 728     }
 729     public static int getRecognitionWeight() {
 730                 settings.beginGroup("General");
 731                 Integer len;
 732                 try {
 733                         len = (Integer)settings.value("recognitionWeight", 30);\r
 734                 } catch (Exception e) {
 735                         len = 80;\r
 736                 }
 737                 settings.endGroup();
 738                 return len;
 739     }
 740
 741     // get/set current debug message level
 742     public static String getMessageLevel() {
 743                 settings.beginGroup("Debug");
 744                 String text = (String)settings.value("messageLevel", "Low");
 745                 settings.endGroup();
 746                 setMessageLevel(text);
 747                 return text;
 748     }
 749     public static void setDateFormat(String format) {
 750                 settings.beginGroup("General");
 751                 settings.setValue("dateFormat", format);
 752                 settings.endGroup();
 753     }
 754
 755     // Get/Set user date/time formats
 756     public static String getDateFormat() {
 757                 settings.beginGroup("General");
 758                 String text = (String)settings.value("dateFormat", "MM/dd/yyyy");
 759                 settings.endGroup();
 760                 return text;
 761     }
 762     public static void setTimeFormat(String format) {
 763                 settings.beginGroup("General");
 764                 settings.setValue("timeFormat", format);
 765                 settings.endGroup();
 766     }
 767     public static String getTimeFormat() {
 768                 settings.beginGroup("General");
 769                 String text = (String)settings.value("timeFormat", "HH:mm:ss");
 770                 settings.endGroup();
 771                 return text;
 772     }
 773
 774     // How often should we sync with Evernote?
 775     public static String getSyncInterval() {
 776                 settings.beginGroup("General");
 777                 String text = (String)settings.value("syncInterval", "15 minutes");
 778                 settings.endGroup();
 779                 return text;
 780     }
 781     public static void setSyncInterval(String format) {
 782                 settings.beginGroup("General");
 783                 settings.setValue("syncInterval", format);
 784                 settings.endGroup();
 785     }
 786
 787     // Get/Set the width of columns and their position for the
 788     // next start.
 789     public static void setColumnWidth(String col, int width) {
 790         if (Global.getListView() == Global.View_List_Wide)
 791                 settings.beginGroup("ColumnWidths");
 792         else
 793                 settings.beginGroup("ColumnWidths-Narrow");
 794                 settings.setValue(col, width);
 795                 settings.endGroup();
 796         }
 797     public static int getColumnWidth(String col) {
 798         int view = Global.getListView();
 799         if (view == Global.View_List_Wide)
 800                 settings.beginGroup("ColumnWidths");
 801         else
 802                 settings.beginGroup("ColumnWidths-Narrow");
 803                 Integer width;
 804                 try {
 805                         String val  = (String)settings.value(col, "0");
 806                         width = new Integer(val.trim());
 807                 } catch (Exception e) {
 808                         try {
 809                                 width = (Integer)settings.value(col, 0);
 810                         } catch (Exception e1) {
 811                                 width = 0;
 812                         }
 813                 }
 814                 settings.endGroup();
 815                 return width;
 816     }
 817     public static void setColumnPosition(String col, int width) {
 818         if (Global.getListView() == Global.View_List_Wide)
 819                 settings.beginGroup("ColumnPosition");
 820         else
 821                 settings.beginGroup("ColumnPosition-Narrow");
 822                 settings.setValue(col, width);
 823                 settings.endGroup();
 824     }
 825     public static int getColumnPosition(String col) {
 826         if (Global.getListView() == Global.View_List_Wide)
 827                 settings.beginGroup("ColumnPosition");
 828         else
 829                 settings.beginGroup("ColumnPosition-Narrow");
 830                 Integer width;
 831                 try {
 832                         String val  = (String)settings.value(col, "-1");
 833                         width = new Integer(val.trim());
 834                 } catch (Exception e) {
 835                         try {
 836                                 width = (Integer)settings.value(col, 0);
 837                         } catch (Exception e1) {
 838                                 width = 0;
 839                         }
 840                 }
 841                 settings.endGroup();
 842                 return width;
 843     }
 844
 845     // Ping the user when they try to delete or just do it.
 846     public static boolean verifyDelete() {
 847                 settings.beginGroup("General");
 848                 try {
 849                         String text = (String)settings.value("verifyDelete", "true");
 850                         settings.endGroup();
 851                         if (text.equalsIgnoreCase("true"))
 852                                 return true;
 853                         else
 854                                 return false;
 855                 } catch (java.lang.ClassCastException e) {
 856                         Boolean value = (Boolean) settings.value("verifyDelete", true);
 857                         settings.endGroup();
 858                         return value;
 859                 }
 860     }
 861     public static void setVerifyDelete(boolean val) {
 862                 settings.beginGroup("General");
 863                 if (val)
 864                         settings.setValue("verifyDelete", "true");
 865                 else
 866                         settings.setValue("verifyDelete", "false");
 867                 settings.endGroup();
 868     }
 869
 870     // Should it start minimized?
 871     public static boolean startMinimized() {
 872                 settings.beginGroup("General");
 873                 try {
 874                         String text = (String)settings.value("startMinimized", "false");
 875                         settings.endGroup();
 876                         if (text.equalsIgnoreCase("true"))
 877                                 return true;
 878                         else
 879                                 return false;
 880                 } catch (java.lang.ClassCastException e) {
 881                         Boolean value = (Boolean) settings.value("startMinimized", false);
 882                         settings.endGroup();
 883                         return value;
 884                 }
 885     }
 886     public static void setStartMinimized(boolean val) {
 887                 settings.beginGroup("General");
 888                 if (val)
 889                         settings.setValue("startMinimized", "true");
 890                 else
 891                         settings.setValue("startMinimized", "false");
 892                 settings.endGroup();
 893     }
 894
 895     // Should we upload the content of any deleted notes
 896     public static boolean synchronizeDeletedContent() {
 897                 settings.beginGroup("General");
 898                 try {
 899                         String text = (String)settings.value("syncDeletedContent", "false");
 900                         settings.endGroup();
 901                         if (text.equalsIgnoreCase("true"))
 902                                 return true;
 903                         else
 904                                 return false;
 905                 } catch (java.lang.ClassCastException e) {
 906                         Boolean value = (Boolean) settings.value("syncDeletedContent", false);
 907                         settings.endGroup();
 908                         return value;
 909                 }
 910     }
 911     public static void setSynchronizeDeletedContent(boolean val) {
 912                 settings.beginGroup("General");
 913                 if (val)
 914                         settings.setValue("syncDeletedContent", "true");
 915                 else
 916                         settings.setValue("syncDeletedContent", "false");
 917                 settings.endGroup();
 918     }
 919
 920     // Is a section of the window visible?  Used to hide things people don't
 921     // want to see.
 922     public static boolean isWindowVisible(String window) {
 923                 settings.beginGroup("WindowsVisible");
 924                 try {
 925                         String defaultValue = "true";
 926                         if (window.equalsIgnoreCase("noteInformation"))
 927                                 defaultValue = "false";
 928                         String text = (String)settings.value(window, defaultValue);
 929                         settings.endGroup();
 930                         if (text.equalsIgnoreCase("true"))
 931                                 return true;
 932                 else
 933                         return false;
 934                 } catch (java.lang.ClassCastException e) {
 935                         boolean defaultValue = true;
 936                         if (window.equalsIgnoreCase("noteInformation"))
 937                                 defaultValue = false;
 938                         Boolean value = (Boolean) settings.value("showTrayIcon", defaultValue);
 939                         settings.endGroup();
 940                         return value;
 941                 }
 942     }
 943     public static void saveWindowVisible(String window, boolean val) {
 944                 settings.beginGroup("WindowsVisible");
 945                 if (val)
 946                         settings.setValue(window, "true");
 947                 else
 948                         settings.setValue(window, "false");
 949                 settings.endGroup();
 950     }
 951
 952     // Is a list in the column in the note list visible?
 953     public static boolean isColumnVisible(String window) {
 954         String defaultValue = "true";
 955         int view = Global.getListView();
 956         if (Global.getListView() == Global.View_List_Wide)
 957                 settings.beginGroup("ColumnsVisible");
 958         else
 959                 settings.beginGroup("ColumnsVisible-Narrow");
 960                 if (window.equalsIgnoreCase("thumbnail") && view == Global.View_List_Wide)
 961                         defaultValue = "false";
 962                 if (window.equalsIgnoreCase("thumbnail"))
 963                         defaultValue = "false";
 964                 if (window.equalsIgnoreCase("Guid"))
 965                         defaultValue = "false";
 966                 try {
 967                         String text = (String)settings.value(window, defaultValue);
 968                         settings.endGroup();
 969                         if (text.equalsIgnoreCase("true"))
 970                                 return true;
 971                         else
 972                                 return false;
 973                 } catch (java.lang.ClassCastException e) {
 974                         boolean defBool = false;
 975                         if (window.equalsIgnoreCase("true"))
 976                                 defBool = true;
 977                         else
 978                                 defBool = false;
 979                         Boolean value = (Boolean) settings.value(window, defBool);
 980                         settings.endGroup();
 981                         return value;
 982                 }
 983     }
 984     public static void saveColumnVisible(String column, boolean val) {
 985         if (Global.getListView() == Global.View_List_Wide)
 986                 settings.beginGroup("ColumnsVisible");
 987         else
 988                 settings.beginGroup("ColumnsVisible-Narrow");
 989                 if (val)
 990                         settings.setValue(column, "true");
 991                 else
 992                         settings.setValue(column, "false");
 993                 settings.endGroup();
 994     }
 995
 996     // Is a particular editor button visible?
 997     public static boolean isEditorButtonVisible(String window) {
 998                 settings.beginGroup("EditorButtonsVisible");
 999                 try {
1000                         String text = (String)settings.value(window, "true");
1001                         settings.endGroup();
1002                         if (text.equalsIgnoreCase("true"))
1003                                 return true;
1004                         else
1005                                 return false;
1006                 } catch (java.lang.ClassCastException e) {
1007                         Boolean value = (Boolean) settings.value(window, true);
1008                         settings.endGroup();
1009                         return value;
1010                 }
1011     }
1012     public static void saveEditorButtonsVisible(String column, boolean val) {
1013                 settings.beginGroup("EditorButtonsVisible");
1014                 if (val)
1015                         settings.setValue(column, "true");
1016                 else
1017                         settings.setValue(column, "false");
1018                 settings.endGroup();
1019     }
1020
1021     // Should the test fixes be enabled
1022     public static boolean enableCarriageReturnFix() {
1023         try {
1024                 settings.beginGroup("Debug");
1025                 String text = (String)settings.value("enableCarriageReturnFix", "false");
1026                 settings.endGroup();
1027                 if (text.equalsIgnoreCase("true"))
1028                         return true;
1029                 else
1030                         return false;
1031                 } catch (java.lang.ClassCastException e) {
1032                         Boolean value = (Boolean) settings.value("enableCarriageReturnFix", false);
1033                         settings.endGroup();
1034                         return value;
1035                 }
1036     }
1037     public static void saveCarriageReturnFix(boolean val) {
1038                 settings.beginGroup("Debug");
1039                 if (val)
1040                         settings.setValue("enableCarriageReturnFix", "true");
1041                 else
1042                         settings.setValue("enableCarriageReturnFix", "false");
1043                 settings.endGroup();
1044     }
1045     public static boolean enableHtmlEntitiesFix() {
1046         try {
1047                 settings.beginGroup("Debug");
1048                 String text = (String)settings.value("enableHtmlEntitiesFix", "false");
1049                 settings.endGroup();
1050                 if (text.equalsIgnoreCase("true"))
1051                         return true;
1052                 else
1053                         return false;
1054                 } catch (java.lang.ClassCastException e) {
1055                         Boolean value = (Boolean) settings.value("enableHtmlEntitiesFix", false);
1056                         settings.endGroup();
1057                         return value;
1058                 }
1059     }
1060     public static void saveHtmlEntitiesFix(boolean val) {
1061                 settings.beginGroup("Debug");
1062                 if (val)
1063                         settings.setValue("enableHtmlEntitiesFix", "true");
1064                 else
1065                         settings.setValue("enableHtmlEntitiesFix", "false");
1066                 settings.endGroup();
1067     }
1068
1069 //    public static void setIndexThreads(int val) {
1070 //              settings.beginGroup("General");
1071 //              settings.setValue("indexThreads", val);
1072 //              settings.endGroup();
1073 //   }
1074 //    public static int getIndexThreads() {
1075 //              settings.beginGroup("General");
1076 //              Integer threads;
1077 //              try {
1078 //                      String val  = (String)settings.value("indexThreads", "1");
1079 //                      threads = new Integer(val.trim());
1080 //              } catch (Exception e) {
1081 //                      try {
1082 //                              threads = (Integer)settings.value("indexThreads", 1);
1083 //                      } catch (Exception e1) {
1084 //                              threads = 1;
1085 //                      }
1086 //              }
1087 //              settings.endGroup();
1088 //              threads = 1;
1089 //              return threads;
1090
1091     // Get/Set text zoom factor
1092 //   }
1093     public static void setZoomFactor(double val) {
1094                 settings.beginGroup("General");
1095                 settings.setValue("zoomFactor", val);
1096                 settings.endGroup();
1097     }
1098     public static double getZoomFactor() {
1099                 settings.beginGroup("General");
1100                 Double threads;
1101                 try {
1102                         String val  = (String)settings.value("zoomFactor", "1.0");
1103                         threads = new Double(val.trim());
1104                 } catch (Exception e) {
1105                         try {
1106                                 threads = (Double)settings.value("zoomFactor", 1.0);
1107                         } catch (Exception e1) {
1108                                 threads = new Double(1);
1109                         }
1110                 }
1111                 settings.endGroup();
1112                 return threads;
1113     }
1114     public static void setTextSizeMultiplier(double val) {
1115                 settings.beginGroup("General");
1116                 settings.setValue("textMultiplier", val);
1117                 settings.endGroup();
1118     }
1119     public static double getTextSizeMultiplier() {
1120                 settings.beginGroup("General");
1121                 Double threads;
1122                 try {
1123                         String val  = (String)settings.value("textMultiplier", "1");
1124                         threads = new Double(val.trim());
1125                 } catch (Exception e) {
1126                         try {
1127                                 threads = (Double)settings.value("textMultiplier", 1);
1128                         } catch (Exception e1) {
1129                                 threads = new Double(1);
1130                         }
1131                 }
1132                 settings.endGroup();
1133                 return threads;
1134     }
1135
1136
1137     // Should we mimic Evernote and restrict the notebooks selected?
1138     public static boolean getMimicEvernoteInterface() {
1139                 settings.beginGroup("General");
1140                 try {
1141                         String text = (String)settings.value("mimicEvernoteInterface", "true");
1142                         settings.endGroup();
1143                         if (text.equalsIgnoreCase("true"))
1144                                 return true;
1145                         else
1146                                 return false;
1147                 } catch (java.lang.ClassCastException e) {
1148                         Boolean value = (Boolean) settings.value("mimicEvernoteInterface", true);
1149                         settings.endGroup();
1150                         return value;
1151                 }
1152     }
1153     public static void setMimicEvernoteInterface(boolean value) {
1154         settings.beginGroup("General");
1155         if (value)
1156                 settings.setValue("mimicEvernoteInterface", "true");
1157         else
1158                 settings.setValue("mimicEvernoteInterface", "false");
1159         settings.endGroup();
1160     }
1161
1162
1163     // Synchronize with Evernote when closing?
1164     public static boolean synchronizeOnClose() {
1165                 settings.beginGroup("General");
1166                 try {
1167                         String text = (String)settings.value("synchronizeOnClose", "false");
1168                         settings.endGroup();
1169                         if (text.equalsIgnoreCase("true"))
1170                                 return true;
1171                         else
1172                                 return false;
1173                 } catch (java.lang.ClassCastException e) {
1174                         Boolean value = (Boolean) settings.value("synchronizeOnClose", false);
1175                         settings.endGroup();
1176                         return value;
1177                 }
1178     }
1179     public static void setSynchronizeOnClose(boolean val) {
1180                 settings.beginGroup("General");
1181                 if (val)
1182                         settings.setValue("synchronizeOnClose", "true");
1183                 else
1184                         settings.setValue("synchronizeOnClose", "false");
1185                 settings.endGroup();
1186     }
1187
1188     // Get/set the database version.  Not really used any more, but kept
1189     // for compatibility.
1190     public static void setDatabaseVersion(String version) {
1191                 settings.beginGroup("General");
1192                 settings.setValue("databaseVersion", version);
1193                 settings.endGroup();
1194     }
1195     public static String getDatabaseVersion() {
1196                 settings.beginGroup("General");
1197                 String val  = (String)settings.value("databaseVersion", "0.70");
1198                 settings.endGroup();
1199                 return val;
1200     }
1201
1202     // Get the URL (full path) of the main database
1203     public static String getDatabaseUrl() {
1204                 settings.beginGroup("General");
1205                 String val  = (String)settings.value("DatabaseURL", "");
1206                 settings.endGroup();
1207                 if (val.equals(""))
1208                         val = "jdbc:h2:"+Global.getFileManager().getDbDirPath(Global.databaseName);
1209                 return val;
1210     }
1211
1212     // get the url (full path) of the searchable word database
1213     public static String getIndexDatabaseUrl() {
1214                 settings.beginGroup("General");
1215                 String val  = (String)settings.value("IndexDatabaseURL", "");
1216                 settings.endGroup();
1217                 if (val.equals(""))
1218                         val = "jdbc:h2:"+Global.getFileManager().getDbDirPath(Global.indexDatabaseName);
1219                 return val;
1220     }
1221
1222     // Get the url (full path) of the attachment database
1223     public static String getResourceDatabaseUrl() {
1224                 settings.beginGroup("General");
1225                 String val  = (String)settings.value("ResourceDatabaseURL", "");
1226                 settings.endGroup();
1227                 if (val.equals(""))
1228                         val = "jdbc:h2:"+Global.getFileManager().getDbDirPath(Global.resourceDatabaseName);
1229                 return val;
1230     }
1231
1232         // ICHANGED
1233         // 操作履歴データベースのURL（フルパス）をゲット
1234         public static String getBehaviorDatabaseUrl() {
1235                 settings.beginGroup("General");
1236                 String val = (String) settings.value("BehaviorDatabaseURL", "");
1237                 settings.endGroup();
1238                 if (val.equals(""))
1239                         val = "jdbc:h2:"
1240                                         + Global.getFileManager().getDbDirPath(
1241                                                         Global.behaviorDatabaseName);
1242                 return val;
1243         }
1244
1245     public static void setDatabaseUrl(String value) {
1246                 settings.beginGroup("General");
1247                 settings.setValue("DatabaseURL", value);
1248                 settings.endGroup();
1249     }
1250     public static void setIndexDatabaseUrl(String value) {
1251                 settings.beginGroup("General");
1252                 settings.setValue("IndexDatabaseURL", value);
1253                 settings.endGroup();
1254     }
1255     public static void setResourceDatabaseUrl(String value) {
1256                 settings.beginGroup("General");
1257                 settings.setValue("ResourceDatabaseURL", value);
1258                 settings.endGroup();
1259     }
1260
1261         // ICHANGED
1262         public static void setBehaviorDatabaseUrl(String value) {
1263                 settings.beginGroup("General");
1264                 settings.setValue("BehaviorDatabaseURL", value);
1265                 settings.endGroup();
1266         }
1267
1268     public static String getDatabaseUserid() {
1269                 settings.beginGroup("General");
1270                 String val  = (String)settings.value("databaseUserid", "");
1271                 settings.endGroup();
1272                 return val;
1273     }
1274     public static String getDatabaseUserPassword() {
1275                 settings.beginGroup("General");
1276                 String val  = (String)settings.value("databaseUserPassword", "");
1277                 settings.endGroup();
1278                 return val;
1279     }
1280
1281     // get/Set the style sheet and the palette to control the look & feel
1282     public static void setStyle(String style) {
1283                 settings.beginGroup("General");
1284                 settings.setValue("style", style);
1285                 settings.endGroup();
1286     }
1287     public static String getStyle() {
1288                 settings.beginGroup("General");
1289                 String val  = (String)settings.value("style", "Cleanlooks");
1290                 settings.endGroup();
1291                 return val;
1292     }
1293     public static boolean useStandardPalette() {
1294                 settings.beginGroup("General");
1295                 try {
1296                         String text = (String)settings.value("standardPalette", "true");
1297                         settings.endGroup();
1298                         if (text.equalsIgnoreCase("true"))
1299                                 return true;
1300                         else
1301                                 return false;
1302                 } catch (java.lang.ClassCastException e) {
1303                         Boolean value = (Boolean) settings.value("standardPalette", true);
1304                         settings.endGroup();
1305                         return value;
1306                 }
1307     }
1308     public static void setStandardPalette(boolean val) {
1309                 settings.beginGroup("General");
1310                 if (val)
1311                         settings.setValue("standardPalette", "true");
1312                 else
1313                         settings.setValue("standardPalette", "false");
1314                 settings.endGroup();
1315     }
1316
1317     // Set the amount of time to wait between indexing
1318     // Get/Set interval when the index thread wakes up.
1319     public static void setIndexThreadSleepInterval(int sleep) {
1320                 settings.beginGroup("General");
1321                 settings.setValue("IndexThreadSleepInterval", sleep);
1322                 settings.endGroup();
1323     }
1324     public static int getIndexThreadSleepInterval() {
1325                 settings.beginGroup("General");
1326                 Integer sleep;
1327                 try {
1328                         String val  = (String)settings.value("IndexThreadSleepInterval", "300");
1329                         sleep = new Integer(val.trim());
1330                 } catch (Exception e) {
1331                         try {
1332                                 sleep = (Integer)settings.value("IndexThreadSleepInterval", 0);
1333                         } catch (Exception e1) {
1334                                 sleep = 300;
1335                         }
1336                 }
1337                 settings.endGroup();
1338                 return sleep;
1339     }
1340
1341
1342     // Get/Set a window state for later restoring
1343     public static void saveState(String name, QByteArray state) {
1344         int view = Global.getListView();
1345         if (view == Global.View_List_Narrow)
1346                 name = name +"Narrow";
1347                 settings.beginGroup("SaveState");
1348                 settings.setValue(name, state);
1349                 settings.endGroup();
1350     }
1351
1352     public static QByteArray restoreState(String name) {
1353         int view = Global.getListView();
1354         if (view == Global.View_List_Narrow)
1355                 name = name +"Narrow";
1356                 settings.beginGroup("SaveState");
1357                 QByteArray state = (QByteArray)settings.value(name);
1358                 settings.endGroup();
1359                 return state;
1360     }
1361     public static void saveGeometry(String name, QByteArray state) {
1362         int view = Global.getListView();
1363         if (view == Global.View_List_Narrow)
1364                 settings.beginGroup("SaveGeometryNarrow");
1365         else
1366                 settings.beginGroup("SaveGeometry");
1367                 settings.setValue(name, state);
1368                 settings.endGroup();
1369     }
1370
1371     public static QByteArray restoreGeometry(String name) {
1372         int view = Global.getListView();
1373         if (view == Global.View_List_Narrow)
1374                 settings.beginGroup("SaveGeometryNarrow");
1375         else
1376                 settings.beginGroup("SaveGeometry");
1377                 QByteArray state = (QByteArray)settings.value(name);
1378                 settings.endGroup();
1379                 return state;
1380     }
1381
1382
1383     // Set how often to do an automatic save
1384     public static void setAutoSaveInterval(int interval) {
1385                 settings.beginGroup("General");
1386                 settings.setValue("autoSaveInterval", interval);
1387                 settings.endGroup();
1388     }
1389     public static int getAutoSaveInterval() {
1390                 settings.beginGroup("General");
1391                 Integer value;
1392                 try {
1393                         String val  = (String)settings.value("autoSaveInterval", "5");
1394                         value = new Integer(val.trim());
1395                 } catch (Exception e) {
1396                         try {
1397                                 value = (Integer)settings.value("autoSaveInterval", 5);
1398                         } catch (Exception e1) {
1399                                 value = 5;
1400                         }
1401                 }
1402                 settings.endGroup();
1403                 return value;
1404     }
1405
1406     // Add an invalid attribute & element to the database so we don't bother parsing it in the future
1407     // These values we automatically remove from any note.
1408     // Add invalid attributes
1409     public static void addInvalidAttribute(String element, String attribute) {
1410
1411                 List<String> attributes = invalidAttributes.get(element);
1412                 if (attributes != null) {
1413                         for (int i=0; i<attributes.size(); i++)
1414                                 if (attribute.equalsIgnoreCase(attributes.get(i))) {
1415                                         return;
1416                         }
1417         }
1418
1419         ArrayList<String> attributeList;
1420         if (!invalidAttributes.containsKey(element)) {
1421                 attributeList = new ArrayList<String>();
1422                 attributeList.add(attribute);
1423                 invalidAttributes.put(element, attributeList);
1424         }
1425         else {
1426                 attributeList = invalidAttributes.get(element);
1427                 attributeList.add(attribute);
1428                 invalidAttributes.put(element,attributeList);
1429         }
1430     }
1431
1432     // Add invalid attributes
1433     public static void addInvalidElement(String element) {
1434                 for (int i=0; i<invalidElements.size(); i++) {
1435                         if (element.equalsIgnoreCase(invalidElements.get(i)))
1436                                 return;
1437                 }
1438         invalidElements.add(element);
1439     }
1440
1441     // Get/Set proxy information
1442     // Proxy settings
1443     public static String getProxyValue(String key) {
1444                 settings.beginGroup("Proxy");
1445                 String val  = (String)settings.value(key, "");
1446                 settings.endGroup();
1447                 return val;
1448     }
1449     public static void setProxyValue(String key, String value) {
1450                 settings.beginGroup("Proxy");
1451                 settings.setValue(key, value);
1452                 settings.endGroup();
1453     }
1454
1455     // Change a byte array to a hex string
1456     // Convert a byte array to a hex string
1457         public static String byteArrayToHexString(byte data[]) {
1458                 StringBuffer buf = new StringBuffer();
1459             for (byte element : data) {
1460                 int halfbyte = (element >>> 4) & 0x0F;
1461                 int two_halfs = 0;
1462                 do {
1463                         if ((0 <= halfbyte) && (halfbyte <= 9))
1464                                buf.append((char) ('0' + halfbyte));
1465                            else
1466                                 buf.append((char) ('a' + (halfbyte - 10)));
1467                         halfbyte = element & 0x0F;
1468                 } while(two_halfs++ < 1);
1469             }
1470             return buf.toString();
1471         }
1472
1473
1474         // Get/Set spelling settings
1475         public static boolean getSpellSetting(String value) {
1476                 settings.beginGroup("Spell");
1477                 String text = (String)settings.value(value, "");
1478                 settings.endGroup();
1479                 if (text.equalsIgnoreCase("true"))
1480                         return true;
1481                 if (text.equalsIgnoreCase("false"))
1482                         return false;
1483                 if (value.equalsIgnoreCase(Configuration.SPELL_IGNOREDIGITWORDS))
1484                         return true;
1485                 if (value.equalsIgnoreCase(Configuration.SPELL_IGNOREINTERNETADDRESSES))
1486                         return true;
1487                 if (value.equalsIgnoreCase(Configuration.SPELL_IGNOREUPPERCASE))
1488                         return true;
1489                 if (value.equalsIgnoreCase(Configuration.SPELL_IGNORESENTENCECAPITALIZATION))
1490                         return true;
1491                 return false;
1492     }
1493     public static void setSpellSetting(String setting, boolean val) {
1494                 settings.beginGroup("Spell");
1495                 if (val)
1496                         settings.setValue(setting, "true");
1497                 else
1498                         settings.setValue(setting, "false");
1499                 settings.endGroup();
1500     }
1501
1502         // Get/Set how we should display tags (color them, hide unused, or do nothing)
1503         // What to do with inactive tags?
1504         public static String tagBehavior() {
1505                 settings.beginGroup("General");
1506                 String text = (String)settings.value("tagBehavior", "DoNothing");
1507                 settings.endGroup();
1508                 return text;
1509         }
1510         // What to do with inactive tags?
1511         public static void setTagBehavior(String value) {
1512                 settings.beginGroup("General");
1513                 settings.setValue("tagBehavior", value);
1514                 settings.endGroup();
1515         }
1516
1517
1518         // Should the toolbar be visible?
1519         public static boolean isToolbarButtonVisible(String window) {
1520                 settings.beginGroup("ToolbarButtonsVisible");
1521                 try {
1522                         String text = (String)settings.value(window, "true");
1523                         settings.endGroup();
1524                         if (text.equalsIgnoreCase("true"))
1525                                 return true;
1526                         else
1527                                 return false;
1528                 } catch (java.lang.ClassCastException e) {
1529                         Boolean value = (Boolean) settings.value(window, true);
1530                         settings.endGroup();
1531                         return value;
1532                 }
1533     }
1534     public static void saveToolbarButtonsVisible(String column, boolean val) {
1535                 settings.beginGroup("ToolbarButtonsVisible");
1536                 if (val)
1537                         settings.setValue(column, "true");
1538                 else
1539                         settings.setValue(column, "false");
1540                 settings.endGroup();
1541     }
1542
1543     // Are thumbnails enabled?
1544
1545     public static boolean enableThumbnails() {
1546                 settings.beginGroup("Debug");
1547                 try {
1548                         String text = (String)settings.value("thumbnails", "true");
1549                         settings.endGroup();
1550                         if (text.equalsIgnoreCase("true"))
1551                                 return true;
1552                         else
1553                                 return false;
1554                 } catch (java.lang.ClassCastException e) {
1555                         Boolean value = (Boolean) settings.value("thumbnails", true);
1556                         settings.endGroup();
1557                         return value;
1558                 }
1559     }
1560     public static void setEnableThumbnails(boolean val) {
1561                 settings.beginGroup("Debug");
1562                 if (val)
1563                         settings.setValue("thumbnails", "true");
1564                 else
1565                         settings.setValue("thumbnails", "false");
1566                 settings.endGroup();
1567     }
1568
1569     // Trace used for performance tuning.  Not normally used in production.
1570         // Print date/time.  Used mainly for performance tracing
1571         public static void trace(boolean resetInterval) {
1572                 String fmt = "MM/dd/yy HH:mm:ss.SSSSSS";
1573                 String dateTimeFormat = new String(fmt);
1574                 SimpleDateFormat simple = new SimpleDateFormat(dateTimeFormat);
1575                 Calendar cal = Calendar.getInstance();
1576                 if (intervalTraceTime == null)
1577                         intervalTraceTime = Calendar.getInstance();
1578                 if (startTraceTime == null)
1579                         startTraceTime = Calendar.getInstance();
1580
1581                 float interval = (cal.getTimeInMillis() - intervalTraceTime.getTimeInMillis());
1582                 float total = (cal.getTimeInMillis() - startTraceTime.getTimeInMillis());
1583
1584 //              if (interval > 00.0) {
1585                         StackTraceElement[] exceptions = Thread.currentThread().getStackTrace();
1586                         System.out.println("------------------------------------------");
1587
1588                         System.out.println("Date/Time " +simple.format(cal.getTime()));
1589                         System.out.format("Interval Time: %-10.6f%n", interval);
1590                         System.out.format("Total Time: %-10.6f%n", total);
1591                         for (int i=2; i<5 && i<exceptions.length; i++) {
1592                                 System.out.println(exceptions[i]);
1593                         }
1594 //              }
1595                 if (resetInterval)
1596                         intervalTraceTime = cal;
1597         }
1598         public static void traceReset() {
1599                 intervalTraceTime = null;
1600                 startTraceTime = null;
1601         }
1602
1603
1604         // Get the FileManager class to manage local files & directories
1605         public static FileManager getFileManager() {
1606         return fileManager;
1607     }
1608
1609         // Should the note editor be disabled?
1610     public static boolean getDisableViewing() {
1611         return disableViewing;
1612     }
1613
1614     //**********************
1615     //* Thumbnail zoom level
1616     //**********************
1617     public static int calculateThumbnailZoom(String content) {
1618         int zoom = 1;
1619                 if (content.indexOf("application/pdf") == -1) {
1620                         if (content.indexOf("image/") == -1) {
1621                                 String text =  StringEscapeUtils.unescapeHtml4(content.replaceAll("\\<.*?\\>", ""));
1622                                 zoom = 2;
1623                                 if (text.length() < 500)
1624                                         zoom = 2;
1625                                 if (text.length() < 250)
1626                                         zoom = 3;
1627                                 if (text.length() < 100)
1628                                         zoom = 4;
1629                                 if (text.length() < 50)
1630                                         zoom = 5;
1631                                 if (text.length() < 10)
1632                                         zoom = 6;
1633                         }
1634                 }
1635                 return zoom;
1636     }
1637
1638     //**********************
1639     //* List View settings
1640     //**********************
1641     public static void setListView(int view) {
1642                 settings.beginGroup("General");
1643                 settings.setValue("listView", view);
1644                 settings.endGroup();
1645     }
1646     public static int getListView() {
1647                 settings.beginGroup("General");
1648                 Integer value;
1649                 try {
1650                         String val  = (String)settings.value("listView", View_List_Wide);
1651                         value = new Integer(val.trim());
1652                 } catch (Exception e) {
1653                         try {
1654                                 value = (Integer)settings.value("listView", View_List_Wide);
1655                         } catch (Exception e1) {
1656                                 value = View_List_Wide;
1657                         }
1658                 }
1659                 settings.endGroup();
1660                 return value;
1661     }
1662
1663
1664
1665     //*******************
1666     // Font Settings
1667     //*******************
1668     public static boolean overrideDefaultFont() {
1669                 settings.beginGroup("Font");
1670                 try {
1671                         String text = (String)settings.value("overrideFont", "false");
1672                         settings.endGroup();
1673                         if (text.equalsIgnoreCase("true"))
1674                                 return true;
1675                         else
1676                                 return false;
1677                 } catch (java.lang.ClassCastException e) {
1678                         Boolean value = (Boolean) settings.value("overrideFont", false);
1679                         settings.endGroup();
1680                         return value;
1681                 }
1682
1683     }
1684
1685     //****************************************************
1686     // Get/Set the default font settings for a new note
1687     //****************************************************
1688     public static void setOverrideDefaultFont(boolean value) {
1689                 settings.beginGroup("Font");
1690                 settings.setValue("overrideFont", value);
1691                 settings.endGroup();
1692     }
1693     public static String getDefaultFont() {
1694                 settings.beginGroup("Font");
1695                 String val  = (String)settings.value("font", "");
1696                 settings.endGroup();
1697                 return val;
1698     }
1699     public static void setDefaultFont(String value) {
1700                 settings.beginGroup("Font");
1701                 settings.setValue("font", value);
1702                 settings.endGroup();
1703     }
1704     public static String getDefaultFontSize() {
1705                 settings.beginGroup("Font");
1706                 String val  = (String)settings.value("fontSize", "");
1707                 settings.endGroup();
1708                 return val;
1709     }
1710     public static void setDefaultFontSize(String value) {
1711                 settings.beginGroup("Font");
1712                 settings.setValue("fontSize", value);
1713                 settings.endGroup();
1714     }
1715
1716
1717     //*******************************************
1718     // Override the close & minimize instead.
1719     //*******************************************
1720     public static boolean minimizeOnClose() {
1721                 settings.beginGroup("General");
1722                 try {
1723                         String text = (String)settings.value("minimizeOnClose", "false");
1724                         settings.endGroup();
1725                         if (text.equalsIgnoreCase("true") && QSystemTrayIcon.isSystemTrayAvailable())
1726                                 return true;
1727                         else
1728                                 return false;
1729                 } catch (java.lang.ClassCastException e) {
1730                         Boolean value = (Boolean) settings.value("minimizeOnClose", false);
1731                         settings.endGroup();
1732                         return value;
1733                 }
1734     }
1735     public static void setMinimizeOnClose(boolean value) {
1736                 settings.beginGroup("General");
1737                 settings.setValue("minimizeOnClose", value);
1738                 settings.endGroup();
1739     }
1740
1741     //*********************************
1742     // Check version information
1743     //*********************************
1744     public static boolean checkVersionUpgrade() {
1745                 settings.beginGroup("Upgrade");
1746                 try {
1747                         String text = (String)settings.value("checkForUpdates", "true");
1748                         settings.endGroup();
1749                         if (text.equalsIgnoreCase("true"))
1750                                 return true;
1751                         else
1752                                 return false;
1753                 } catch (java.lang.ClassCastException e) {
1754                         Boolean value = (Boolean) settings.value("checkForUpdates", true);
1755                         settings.endGroup();
1756                         return value;
1757                 }
1758     }
1759     public static void setCheckVersionUpgrade(boolean value) {
1760                 settings.beginGroup("Upgrade");
1761                 settings.setValue("checkForUpdates", value);
1762                 settings.endGroup();
1763     }
1764     public static String getUpdatesAvailableUrl() {
1765                 settings.beginGroup("Upgrade");
1766                 String text = (String)settings.value("avialableUrl", "http://nevernote.sourceforge.net/versions.txt");
1767                 settings.endGroup();
1768                 return text;
1769     }
1770     public static String getUpdateAnnounceUrl() {
1771                 settings.beginGroup("Upgrade");
1772                 String text = (String)settings.value("announceUrl", "http://nevernote.sourceforge.net/upgrade.html");
1773                 settings.endGroup();
1774                 return text;
1775     }
1776
1777     //*******************
1778     // Index settings
1779     //*******************
1780     // Set/Get if we should index the text of a note
1781     public static boolean indexNoteBody() {
1782                 settings.beginGroup("Index");
1783                 try {
1784                         String value = (String)settings.value("indexNoteBody", "true");
1785                         settings.endGroup();
1786                         if (value.equals("true"))
1787                                 return true;
1788                         else
1789                                 return false;
1790                 } catch (java.lang.ClassCastException e) {
1791                         Boolean value = (Boolean) settings.value("indexNoteBody", true);
1792                         settings.endGroup();
1793                         return value;
1794                 }
1795     }
1796     public static void setIndexNoteTitle(boolean value) {
1797                 settings.beginGroup("Index");
1798                 settings.setValue("indexNoteTitle", value);
1799                 settings.endGroup();
1800     }
1801     // Set/Get if we should index the title of a note
1802     public static boolean indexNoteTitle() {
1803                 settings.beginGroup("Index");
1804                 try {
1805                         String value = (String)settings.value("indexNoteTitle", "true");
1806                         settings.endGroup();
1807                         if (value.equals("true"))
1808                                 return true;
1809                         else
1810                                 return false;
1811                 } catch (java.lang.ClassCastException e) {
1812                         Boolean value = (Boolean) settings.value("indexNoteTitle", true);
1813                         settings.endGroup();
1814                         return value;
1815                 }
1816     }
1817     public static void setIndexNoteBody(boolean value) {
1818                 settings.beginGroup("Index");
1819                 settings.setValue("indexNoteBody", value);
1820                 settings.endGroup();
1821     }
1822     // Set/Get if we should index any attachments
1823     public static boolean indexAttachmentsLocally() {
1824                 settings.beginGroup("Index");
1825                 try {
1826                         String value = (String)settings.value("indexAttachmentsLocally", "true");
1827                         settings.endGroup();
1828                         if (value.equals("true"))
1829                                 return true;
1830                         else
1831                                 return false;
1832                 } catch (java.lang.ClassCastException e) {
1833                         Boolean value = (Boolean) settings.value("indexAttachmentsLocally", true);
1834                         settings.endGroup();
1835                         return value;
1836                 }
1837     }
1838     public static void setIndexImageRecognition(boolean value) {
1839                 settings.beginGroup("Index");
1840                 settings.setValue("indexImageRecognition", value);
1841                 settings.endGroup();
1842     }
1843     public static boolean indexImageRecognition() {
1844                 settings.beginGroup("Index");
1845                 try {
1846                         String value = (String)settings.value("indexImageRecognition", "true");
1847                         settings.endGroup();
1848                         if (value.equals("true"))
1849                                 return true;
1850                         else
1851                                 return false;
1852                 } catch (java.lang.ClassCastException e) {
1853                         Boolean value = (Boolean) settings.value("indexImageRecognition", true);
1854                         settings.endGroup();
1855                         return value;
1856                 }
1857     }
1858     public static void setIndexAttachmentsLocally(boolean value) {
1859                 settings.beginGroup("Index");
1860                 settings.setValue("indexAttachmentsLocally", value);
1861                 settings.endGroup();
1862     }
1863     // Get/Set characters that shouldn't be removed from a word
1864     public static String getSpecialIndexCharacters() {
1865                 settings.beginGroup("Index");
1866                 String text = (String)settings.value("specialCharacters", "");
1867                 settings.endGroup();
1868                 return text;
1869     }
1870     public static void setSpecialIndexCharacters(String value) {
1871                 settings.beginGroup("Index");
1872                 settings.setValue("specialCharacters", value);
1873                 settings.endGroup();
1874                 databaseCache = value;
1875     }
1876
1877     //*****************************************************************************
1878     // Control how tag selection behaves (should they be "and" or "or" selections
1879     //*****************************************************************************
1880     public static boolean anyTagSelectionMatch() {
1881                 settings.beginGroup("General");
1882                 try {
1883                         String value = (String)settings.value("anyTagSelectionMatch", "false");
1884                         settings.endGroup();
1885                         if (value.equals("true"))
1886                                 return true;
1887                         else
1888                                 return false;
1889                 } catch (java.lang.ClassCastException e) {
1890                         Boolean value = (Boolean) settings.value("anyTagSelectionMatch", false);
1891                         settings.endGroup();
1892                         return value;
1893                 }
1894     }
1895     public static void setAnyTagSelectionMatch(boolean value) {
1896                 settings.beginGroup("General");
1897                 settings.setValue("anyTagSelectionMatch", value);
1898                 settings.endGroup();
1899     }
1900
1901     //*****************************************************************************
1902     // Control if a user receives a warning when trying to create a note-to-note link
1903     // when the DB is not synchronized.
1904     //*****************************************************************************
1905     public static boolean bypassSynchronizationWarning() {
1906                 settings.beginGroup("User");
1907                 try {
1908                         String value = (String)settings.value("bypassSynchronizationWarning", "false");
1909                         settings.endGroup();
1910                         if (value.equals("true"))
1911                                 return true;
1912                         else
1913                                 return false;
1914                 } catch (java.lang.ClassCastException e) {
1915                         Boolean value = (Boolean) settings.value("bypassSynchronizationWarning", false);
1916                         settings.endGroup();
1917                         return value;
1918                 }
1919     }
1920     public static void setBypassSynchronizationWarning(boolean value) {
1921                 settings.beginGroup("User");
1922                 settings.setValue("bypassSynchronizationWarning", value);
1923                 settings.endGroup();
1924     }
1925
1926
1927     //***********************
1928     //* Database cache size
1929     //***********************
1930     public static String getDatabaseCacheSize() {
1931                 settings.beginGroup("Debug");
1932                 String text = (String)settings.value("databaseCache", "16384");
1933                 settings.endGroup();
1934                 return text;
1935     }
1936     public static void setDatabaseCache(String value) {
1937                 settings.beginGroup("Debug");
1938                 settings.setValue("databaseCache", value);
1939                 settings.endGroup();
1940                 databaseCache = value;
1941     }
1942
1943
1944     // This is used to copy a class since Java's normal deep copy is wacked
1945     public static Object deepCopy(Object oldObj)
1946     {
1947        ObjectOutputStream oos = null;
1948        ObjectInputStream ois = null;
1949        try
1950        {
1951           ByteArrayOutputStream bos =
1952                 new ByteArrayOutputStream(); // A
1953           oos = new ObjectOutputStream(bos); // B
1954           // serialize and pass the object
1955           oos.writeObject(oldObj);   // C
1956           oos.flush();               // D
1957           ByteArrayInputStream bin =
1958                 new ByteArrayInputStream(bos.toByteArray()); // E
1959           ois = new ObjectInputStream(bin);                  // F
1960           // return the new object
1961           return ois.readObject(); // G
1962        }
1963        catch(Exception e)
1964        {
1965           Global.logger.log(logger.LOW, "Exception in ObjectCloner = " + e);
1966        }
1967           try {
1968                         oos.close();
1969                 ois.close();
1970                 } catch (IOException e) {
1971                         Global.logger.log(logger.LOW, "Exception in ObjectCloner = " + e);
1972                         e.printStackTrace();
1973                 }
1974
1975                 return null;
1976     }
1977
1978     // If we should automatically select the children of any tag
1979     public static boolean includeTagChildren() {
1980                 settings.beginGroup("General");
1981                 try {
1982                         String value = (String)settings.value("includeTagChildren", "false");
1983                         settings.endGroup();
1984                         if (value.equals("true"))
1985                                 return true;
1986                         else
1987                                 return false;
1988                 } catch (java.lang.ClassCastException e) {
1989                         Boolean value = (Boolean) settings.value("includeTagChildren", false);
1990                         settings.endGroup();
1991                         return value;
1992                 }
1993
1994     }
1995     public static void setIncludeTagChildren(boolean value) {
1996                 settings.beginGroup("General");
1997                 settings.setValue("includeTagChildren", value);
1998                 settings.endGroup();
1999     }
2000
2001     // If we should automatically wildcard searches
2002     public static boolean automaticWildcardSearches() {
2003                 settings.beginGroup("General");
2004                 try {
2005                         String value = (String)settings.value("automaticWildcard", "false");
2006                         settings.endGroup();
2007                         if (value.equals("true"))
2008                                 return true;
2009                         else
2010                                 return false;
2011                 } catch (java.lang.ClassCastException e) {
2012                         Boolean value = (Boolean) settings.value("automaticWildcard", false);
2013                         settings.endGroup();
2014                         return value;
2015                 }
2016
2017     }
2018     public static void setAutomaticWildcardSearches(boolean value) {
2019                 settings.beginGroup("General");
2020                 settings.setValue("automaticWildcard", value);
2021                 settings.endGroup();
2022     }
2023
2024     // If we should automatically select the children of any tag
2025     public static boolean displayRightToLeft() {
2026                 settings.beginGroup("General");
2027                 try {
2028                         String value = (String)settings.value("displayRightToLeft", "false");
2029                         settings.endGroup();
2030                         if (value.equals("true"))
2031                                 return true;
2032                         else
2033                                 return false;
2034                 } catch (java.lang.ClassCastException e) {
2035                         Boolean value = (Boolean) settings.value("displayRightToLeft", false);
2036                         settings.endGroup();
2037                         return value;
2038                 }
2039
2040     }
2041     public static void setDisplayRightToLeft(boolean value) {
2042                 settings.beginGroup("General");
2043                 settings.setValue("displayRightToLeft", value);
2044                 settings.endGroup();
2045     }
2046
2047
2048     //***********************
2049     //* Startup Notebook
2050     //***********************
2051     public static String getStartupNotebook() {
2052                 settings.beginGroup("General");
2053                 String text = (String)settings.value("startupNotebook", "");
2054                 settings.endGroup();
2055                 return text;
2056     }
2057     public static void setStartupNotebook(String value) {
2058                 settings.beginGroup("General");
2059                 settings.setValue("startupNotebook", value);
2060                 settings.endGroup();
2061                 databaseCache = value;
2062     }
2063
2064     // ICHANGED
2065     // 複数ノート同時閲覧操作に対する重み付け
2066     public static void setBrowseWeight(int weight) {
2067                 settings.beginGroup("RensoNoteList");
2068                 settings.setValue("browseWeight", weight);
2069                 settings.endGroup();
2070     }
2071     public static int getBrowseWeight() {
2072                 settings.beginGroup("RensoNoteList");
2073                 Integer value;
2074                 try {
2075                         String val  = (String)settings.value("browseWeight", 1);
2076                         value = new Integer(val.trim());
2077                 } catch (Exception e) {
2078                         try {
2079                                 value = (Integer)settings.value("browseWeight", 1);
2080                         } catch (Exception e1) {
2081                                 value = 1;
2082                         }
2083                 }
2084                 settings.endGroup();
2085                 return value;
2086     }
2087
2088     // ICHANGED
2089     // ノート内容のコピー＆ペースト操作に対する重み付け
2090     public static void setCopyPasteWeight(int weight) {
2091                 settings.beginGroup("RensoNoteList");
2092                 settings.setValue("copyPasteWeight", weight);
2093                 settings.endGroup();
2094     }
2095     public static int getCopyPasteWeight() {
2096                 settings.beginGroup("RensoNoteList");
2097                 Integer value;
2098                 try {
2099                         String val  = (String)settings.value("copyPasteWeight", 3);
2100                         value = new Integer(val.trim());
2101                 } catch (Exception e) {
2102                         try {
2103                                 value = (Integer)settings.value("copyPasteWeight", 3);
2104                         } catch (Exception e1) {
2105                                 value = 3;
2106                         }
2107                 }
2108                 settings.endGroup();
2109                 return value;
2110     }
2111
2112     // ICHANGED
2113     // 新規ノート追加操作に対する重み付け
2114     public static void setAddNewNoteWeight(int weight) {
2115                 settings.beginGroup("RensoNoteList");
2116                 settings.setValue("addNewNoteWeight", weight);
2117                 settings.endGroup();
2118     }
2119         public static int getAddNewNoteWeight() {
2120                 settings.beginGroup("RensoNoteList");
2121                 Integer value;
2122                 try {
2123                         String val  = (String)settings.value("addNewNoteWeight", 1);
2124                         value = new Integer(val.trim());
2125                 } catch (Exception e) {
2126                         try {
2127                                 value = (Integer)settings.value("addNewNoteWeight", 1);
2128                         } catch (Exception e1) {
2129                                 value = 1;
2130                         }
2131                 }
2132                 settings.endGroup();
2133                 return value;
2134         }
2135
2136         // ICHANGED
2137         // 連想ノートクリック操作に対する重み付け
2138     public static void setRensoItemClickWeight(int weight) {
2139                 settings.beginGroup("RensoNoteList");
2140                 settings.setValue("rensoItemClickWeight", weight);
2141                 settings.endGroup();
2142     }
2143         public static int getRensoItemClickWeight() {
2144                 settings.beginGroup("RensoNoteList");
2145                 Integer value;
2146                 try {
2147                         String val  = (String)settings.value("rensoItemClickWeight", 10);
2148                         value = new Integer(val.trim());
2149                 } catch (Exception e) {
2150                         try {
2151                                 value = (Integer)settings.value("rensoItemClickWeight", 10);
2152                         } catch (Exception e1) {
2153                                 value = 10;
2154                         }
2155                 }
2156                 settings.endGroup();
2157                 return value;
2158         }
2159
2160         // ICHANGED
2161         // タグ付け操作に対する重み付け
2162     public static void setSameTagWeight(int weight) {
2163                 settings.beginGroup("RensoNoteList");
2164                 settings.setValue("sameTagWeight", weight);
2165                 settings.endGroup();
2166     }
2167         public static int getSameTagWeight() {
2168                 settings.beginGroup("RensoNoteList");
2169                 Integer value;
2170                 try {
2171                         String val  = (String)settings.value("sameTagWeight", 2);
2172                         value = new Integer(val.trim());
2173                 } catch (Exception e) {
2174                         try {
2175                                 value = (Integer)settings.value("sameTagWeight", 2);
2176                         } catch (Exception e1) {
2177                                 value = 2;
2178                         }
2179                 }
2180                 settings.endGroup();
2181                 return value;
2182         }
2183
2184         // ICHANGED
2185         // ノートブック変更操作に対する重み付け
2186     public static void setSameNotebookWeight(int weight) {
2187                 settings.beginGroup("RensoNoteList");
2188                 settings.setValue("sameNotebookWeight", weight);
2189                 settings.endGroup();
2190     }
2191         public static int getSameNotebookWeight() {
2192                 settings.beginGroup("RensoNoteList");
2193                 Integer value;
2194                 try {
2195                         String val  = (String)settings.value("sameNotebookWeight", 2);
2196                         value = new Integer(val.trim());
2197                 } catch (Exception e) {
2198                         try {
2199                                 value = (Integer)settings.value("sameNotebookWeight", 2);
2200                         } catch (Exception e1) {
2201                                 value = 2;
2202                         }
2203                 }
2204                 settings.endGroup();
2205                 return value;
2206         }
2207
2208     //*******************
2209     // ノートのマージ・複製の関連ノートリストへの適用
2210     //*******************
2211     // ICHANGED
2212     public static void setMergeRensoNote(boolean value) {
2213                 settings.beginGroup("RensoNoteList");
2214                 settings.setValue("mergeRensoNoteList", value);
2215                 settings.endGroup();
2216     }
2217     // ICHANGED
2218     public static boolean getMergeRensoNote() {
2219                 settings.beginGroup("RensoNoteList");
2220                 try {
2221                         String value = (String)settings.value("mergeRensoNoteList", "true");
2222                         settings.endGroup();
2223                         if (value.equals("true"))
2224                                 return true;
2225                         else
2226                                 return false;
2227                 } catch (java.lang.ClassCastException e) {
2228                         Boolean value = (Boolean) settings.value("mergeRensoNoteList", true);
2229                         settings.endGroup();
2230                         return value;
2231                 }
2232     }
2233     // ICHANGED
2234     public static void setDuplicateRensoNote(boolean value) {
2235                 settings.beginGroup("RensoNoteList");
2236                 settings.setValue("duplicateRensoNoteList", value);
2237                 settings.endGroup();
2238     }
2239     // ICHANGED
2240     public static boolean getDuplicateRensoNote() {
2241                 settings.beginGroup("RensoNoteList");
2242                 try {
2243                         String value = (String)settings.value("duplicateRensoNoteList", "true");
2244                         settings.endGroup();
2245                         if (value.equals("true"))
2246                                 return true;
2247                         else
2248                                 return false;
2249                 } catch (java.lang.ClassCastException e) {
2250                         Boolean value = (Boolean) settings.value("duplicateRensoNoteList", true);
2251                         settings.endGroup();
2252                         return value;
2253                 }
2254     }
2255
2256     // ICHANGED
2257     // 連想ノートリストからノートを除外するときに確認メッセージを表示するかどうか
2258     public static boolean verifyExclude() {
2259                 settings.beginGroup("RensoNoteList");
2260                 try {
2261                         String text = (String)settings.value("verifyExclude", "true");
2262                         settings.endGroup();
2263                         if (text.equalsIgnoreCase("true"))
2264                                 return true;
2265                         else
2266                                 return false;
2267                 } catch (java.lang.ClassCastException e) {
2268                         Boolean value = (Boolean) settings.value("verifyExclude", true);
2269                         settings.endGroup();
2270                         return value;
2271                 }
2272     }
2273     // ICHANGED
2274     public static void setVerifyExclude(boolean val) {
2275                 settings.beginGroup("RensoNoteList");
2276                 if (val)
2277                         settings.setValue("verifyExclude", "true");
2278                 else
2279                         settings.setValue("verifyExclude", "false");
2280                 settings.endGroup();
2281     }
2282
2283         // ICHANGED
2284         // 連想ノートリスト最大表示アイテム数
2285     public static void setRensoListItemMaximum(int maximum) {
2286                 settings.beginGroup("RensoNoteList");
2287                 settings.setValue("rensoListMaximum", maximum);
2288                 settings.endGroup();
2289     }
2290         public static int getRensoListItemMaximum() {
2291                 settings.beginGroup("RensoNoteList");
2292                 Integer value;
2293                 try {
2294                         String val  = (String)settings.value("rensoListMaximum", 20);
2295                         value = new Integer(val.trim());
2296                 } catch (Exception e) {
2297                         try {
2298                                 value = (Integer)settings.value("rensoListMaximum", 20);
2299                         } catch (Exception e1) {
2300                                 value = 20;
2301                         }
2302                 }
2303                 settings.endGroup();
2304                 return value;
2305         }
2306 }
2307