src/cx/fbn/nevernote/NeverNote.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 package cx.fbn.nevernote;
  21 import java.awt.Desktop;
  22 import java.io.File;
  23 import java.io.FileInputStream;
  24 import java.io.FileNotFoundException;
  25 import java.io.FileOutputStream;
  26 import java.net.Authenticator;
  27 import java.net.PasswordAuthentication;
  28 import java.security.MessageDigest;
  29 import java.security.NoSuchAlgorithmException;
  30 import java.sql.Connection;
  31 import java.sql.DriverManager;
  32 import java.sql.SQLException;
  33 import java.sql.Statement;
  34 import java.text.SimpleDateFormat;
  35 import java.util.ArrayList;
  36 import java.util.Calendar;
  37 import java.util.Collection;
  38 import java.util.Collections;
  39 import java.util.Comparator;
  40 import java.util.Date;
  41 import java.util.GregorianCalendar;
  42 import java.util.HashMap;
  43 import java.util.Iterator;
  44 import java.util.List;
  45 import java.util.SortedMap;
  46 import java.util.Vector;
  47
  48 import org.apache.log4j.Level;
  49 import org.apache.log4j.Logger;
  50 import org.h2.tools.ChangeFileEncryption;
  51
  52 import com.evernote.edam.error.EDAMNotFoundException;
  53 import com.evernote.edam.error.EDAMSystemException;
  54 import com.evernote.edam.error.EDAMUserException;
  55 import com.evernote.edam.notestore.NoteFilter;
  56 import com.evernote.edam.notestore.NoteVersionId;
  57 import com.evernote.edam.type.Data;
  58 import com.evernote.edam.type.LinkedNotebook;
  59 import com.evernote.edam.type.Note;
  60 import com.evernote.edam.type.NoteAttributes;
  61 import com.evernote.edam.type.Notebook;
  62 import com.evernote.edam.type.Publishing;
  63 import com.evernote.edam.type.QueryFormat;
  64 import com.evernote.edam.type.Resource;
  65 import com.evernote.edam.type.SavedSearch;
  66 import com.evernote.edam.type.Tag;
  67 import com.evernote.edam.type.User;
  68 import com.evernote.thrift.TException;
  69 import com.trolltech.qt.QThread;
  70 import com.trolltech.qt.core.QByteArray;
  71 import com.trolltech.qt.core.QDateTime;
  72 import com.trolltech.qt.core.QDir;
  73 import com.trolltech.qt.core.QEvent;
  74 import com.trolltech.qt.core.QFile;
  75 import com.trolltech.qt.core.QFileInfo;
  76 import com.trolltech.qt.core.QFileSystemWatcher;
  77 import com.trolltech.qt.core.QIODevice;
  78 import com.trolltech.qt.core.QIODevice.OpenModeFlag;
  79 import com.trolltech.qt.core.QLocale;
  80 import com.trolltech.qt.core.QMimeData;
  81 import com.trolltech.qt.core.QModelIndex;
  82 import com.trolltech.qt.core.QSize;
  83 import com.trolltech.qt.core.QTemporaryFile;
  84 import com.trolltech.qt.core.QTextCodec;
  85 import com.trolltech.qt.core.QTextStream;
  86 import com.trolltech.qt.core.QThreadPool;
  87 import com.trolltech.qt.core.QTimer;
  88 import com.trolltech.qt.core.QTranslator;
  89 import com.trolltech.qt.core.QUrl;
  90 import com.trolltech.qt.core.Qt;
  91 import com.trolltech.qt.core.Qt.BGMode;
  92 import com.trolltech.qt.core.Qt.DockWidgetArea;
  93 import com.trolltech.qt.core.Qt.ItemDataRole;
  94 import com.trolltech.qt.core.Qt.KeyboardModifier;
  95 import com.trolltech.qt.core.Qt.MouseButton;
  96 import com.trolltech.qt.core.Qt.SortOrder;
  97 import com.trolltech.qt.core.Qt.WidgetAttribute;
  98 import com.trolltech.qt.gui.QAbstractItemView;
  99 import com.trolltech.qt.gui.QAbstractItemView.ScrollHint;
 100 import com.trolltech.qt.gui.QAction;
 101 import com.trolltech.qt.gui.QApplication;
 102 import com.trolltech.qt.gui.QClipboard;
 103 import com.trolltech.qt.gui.QCloseEvent;
 104 import com.trolltech.qt.gui.QColor;
 105 import com.trolltech.qt.gui.QComboBox;
 106 import com.trolltech.qt.gui.QCursor;
 107 import com.trolltech.qt.gui.QDesktopServices;
 108 import com.trolltech.qt.gui.QDialog;
 109 import com.trolltech.qt.gui.QDockWidget;
 110 import com.trolltech.qt.gui.QFileDialog;
 111 import com.trolltech.qt.gui.QFileDialog.AcceptMode;
 112 import com.trolltech.qt.gui.QFileDialog.FileMode;
 113 import com.trolltech.qt.gui.QGridLayout;
 114 import com.trolltech.qt.gui.QHBoxLayout;
 115 import com.trolltech.qt.gui.QIcon;
 116 import com.trolltech.qt.gui.QImage;
 117 import com.trolltech.qt.gui.QKeySequence;
 118 import com.trolltech.qt.gui.QLabel;
 119 import com.trolltech.qt.gui.QListWidgetItem;
 120 import com.trolltech.qt.gui.QMainWindow;
 121 import com.trolltech.qt.gui.QMenu;
 122 import com.trolltech.qt.gui.QMessageBox;
 123 import com.trolltech.qt.gui.QMessageBox.StandardButton;
 124 import com.trolltech.qt.gui.QPainter;
 125 import com.trolltech.qt.gui.QPalette.ColorRole;
 126 import com.trolltech.qt.gui.QPixmap;
 127 import com.trolltech.qt.gui.QPrintDialog;
 128 import com.trolltech.qt.gui.QPrinter;
 129 import com.trolltech.qt.gui.QShortcut;
 130 import com.trolltech.qt.gui.QSizePolicy;
 131 import com.trolltech.qt.gui.QSizePolicy.Policy;
 132 import com.trolltech.qt.gui.QSpinBox;
 133 import com.trolltech.qt.gui.QSplashScreen;
 134 import com.trolltech.qt.gui.QSplitter;
 135 import com.trolltech.qt.gui.QStatusBar;
 136 import com.trolltech.qt.gui.QSystemTrayIcon;
 137 import com.trolltech.qt.gui.QTableWidgetItem;
 138 import com.trolltech.qt.gui.QTextEdit;
 139 import com.trolltech.qt.gui.QToolBar;
 140 import com.trolltech.qt.gui.QTreeWidgetItem;
 141 import com.trolltech.qt.network.QNetworkAccessManager;
 142 import com.trolltech.qt.network.QNetworkProxy;
 143 import com.trolltech.qt.network.QNetworkProxy.ProxyType;
 144 import com.trolltech.qt.network.QNetworkReply;
 145 import com.trolltech.qt.network.QNetworkRequest;
 146 import com.trolltech.qt.webkit.QWebPage.WebAction;
 147 import com.trolltech.qt.webkit.QWebSettings;
 148
 149 import cx.fbn.nevernote.config.InitializationException;
 150 import cx.fbn.nevernote.config.StartupConfig;
 151 import cx.fbn.nevernote.dialog.AccountDialog;
 152 import cx.fbn.nevernote.dialog.ConfigDialog;
 153 import cx.fbn.nevernote.dialog.DBEncryptDialog;
 154 import cx.fbn.nevernote.dialog.DatabaseLoginDialog;
 155 import cx.fbn.nevernote.dialog.DatabaseStatus;
 156 import cx.fbn.nevernote.dialog.FindDialog;
 157 import cx.fbn.nevernote.dialog.IgnoreSync;
 158 import cx.fbn.nevernote.dialog.LogFileDialog;
 159 import cx.fbn.nevernote.dialog.NotebookArchive;
 160 import cx.fbn.nevernote.dialog.NotebookEdit;
 161 import cx.fbn.nevernote.dialog.OnlineNoteHistory;
 162 import cx.fbn.nevernote.dialog.PublishNotebook;
 163 import cx.fbn.nevernote.dialog.SavedSearchEdit;
 164 import cx.fbn.nevernote.dialog.SetIcon;
 165 import cx.fbn.nevernote.dialog.ShareNotebook;
 166 import cx.fbn.nevernote.dialog.SharedNotebookSyncError;
 167 import cx.fbn.nevernote.dialog.StackNotebook;
 168 import cx.fbn.nevernote.dialog.SynchronizationRequiredWarning;
 169 import cx.fbn.nevernote.dialog.TagEdit;
 170 import cx.fbn.nevernote.dialog.TagMerge;
 171 import cx.fbn.nevernote.dialog.ThumbnailViewer;
 172 import cx.fbn.nevernote.dialog.UpgradeAvailableDialog;
 173 import cx.fbn.nevernote.dialog.WatchFolder;
 174 import cx.fbn.nevernote.evernote.NoteMetadata;
 175 import cx.fbn.nevernote.filters.FilterEditorNotebooks;
 176 import cx.fbn.nevernote.filters.FilterEditorTags;
 177 import cx.fbn.nevernote.gui.AttributeTreeWidget;
 178 import cx.fbn.nevernote.gui.BrowserWindow;
 179 import cx.fbn.nevernote.gui.DateAttributeFilterTable;
 180 import cx.fbn.nevernote.gui.ExternalBrowse;
 181 import cx.fbn.nevernote.gui.MainMenuBar;
 182 import cx.fbn.nevernote.gui.NotebookTreeWidget;
 183 import cx.fbn.nevernote.gui.RensoNoteList;
 184 import cx.fbn.nevernote.gui.SavedSearchTreeWidget;
 185 import cx.fbn.nevernote.gui.SearchPanel;
 186 import cx.fbn.nevernote.gui.TabBrowse;
 187 import cx.fbn.nevernote.gui.TabBrowserWidget;
 188 import cx.fbn.nevernote.gui.TableView;
 189 import cx.fbn.nevernote.gui.TagTreeWidget;
 190 import cx.fbn.nevernote.gui.Thumbnailer;
 191 import cx.fbn.nevernote.gui.TrashTreeWidget;
 192 import cx.fbn.nevernote.gui.controls.QuotaProgressBar;
 193 import cx.fbn.nevernote.neighbornote.ClipBoardObserver;
 194 import cx.fbn.nevernote.oauth.OAuthTokenizer;
 195 import cx.fbn.nevernote.oauth.OAuthWindow;
 196 import cx.fbn.nevernote.sql.DatabaseConnection;
 197 import cx.fbn.nevernote.sql.WatchFolderRecord;
 198 import cx.fbn.nevernote.threads.IndexRunner;
 199 import cx.fbn.nevernote.threads.SyncRunner;
 200 import cx.fbn.nevernote.threads.ThumbnailRunner;
 201 import cx.fbn.nevernote.utilities.AESEncrypter;
 202 import cx.fbn.nevernote.utilities.ApplicationLogger;
 203 import cx.fbn.nevernote.utilities.FileImporter;
 204 import cx.fbn.nevernote.utilities.FileUtils;
 205 import cx.fbn.nevernote.utilities.ListManager;
 206 import cx.fbn.nevernote.utilities.SyncTimes;
 207 import cx.fbn.nevernote.xml.ExportData;
 208 import cx.fbn.nevernote.xml.ImportData;
 209 import cx.fbn.nevernote.xml.ImportEnex;
 210 import cx.fbn.nevernote.xml.NoteFormatter;
 211 //import org.apache.thrift.TException;
 212
 213
 214 public class NeverNote extends QMainWindow{
 215
 216         QStatusBar                              statusBar;                                      // Application status bar
 217
 218         DatabaseConnection              conn;
 219
 220         MainMenuBar                             menuBar;                                        // Main menu bar
 221         FindDialog                              find;                                           // Text search in note dialog
 222         List<String>                    emitLog;                                        // Messages displayed in the status bar;
 223         QSystemTrayIcon                 trayIcon;                                       // little tray icon
 224         QMenu                                   trayMenu;                                       // System tray menu
 225         QAction                                 trayExitAction;                         // Exit the application
 226         QAction                                 trayShowAction;                         // toggle the show/hide action
 227         QAction                                 trayAddNoteAction;                      // Add a note from the system tray
 228         QNetworkAccessManager   versionChecker;                         // Used when checking for new versions
 229
 230     NotebookTreeWidget          notebookTree;                           // List of notebooks
 231     AttributeTreeWidget         attributeTree;                          // List of note attributes
 232     TagTreeWidget                       tagTree;                                        // list of user created tags
 233     SavedSearchTreeWidget       savedSearchTree;                        // list of saved searches
 234     TrashTreeWidget                     trashTree;                                      // Trashcan
 235     TableView                           noteTableView;                          //      List of notes (the widget).
 236
 237     public BrowserWindow        browserWindow;                          // Window containing browser & labels
 238     public QToolBar             toolBar;                                        // The tool bar under the menu
 239     QComboBox                           searchField;                            // search filter bar on the toolbar;
 240     QShortcut                           searchShortcut;                         // Shortcut to search bar
 241     boolean                                     searchPerformed = false;        // Search was done?
 242     QuotaProgressBar            quotaBar;                                       // The current quota usage
 243
 244     ApplicationLogger           logger;
 245     List<String>                        selectedNotebookGUIDs;          // List of notebook GUIDs
 246     List<String>                        selectedTagGUIDs;                       // List of selected tag GUIDs
 247     List<String>                        selectedNoteGUIDs;                      // List of selected notes
 248     String                                      selectedSavedSearchGUID;        // Currently selected saved searches
 249     private final HashMap<String, ExternalBrowse>       externalWindows;        // Notes being edited by an external window;
 250
 251     NoteFilter                          filter;                                         // Note filter
 252     String                                      currentNoteGuid;                        // GUID of the current note
 253     Note                                        currentNote;                            // The currently viewed note
 254     // ICHANGED
 255     HashMap<Integer, Boolean>   noteDirty;                              // Has the note been changed?
 256     HashMap<Integer, Boolean>   inkNote;                // if this is an ink note, it is read only
 257     HashMap<Integer, Boolean>   readOnly;                               // Is this note read-only?
 258
 259
 260     ListManager                         listManager;                                    // DB runnable task
 261
 262     List<QTemporaryFile>        tempFiles;                                      // Array of temporary files;
 263
 264     QTimer                                      indexTimer;                                     // timer to start the index thread
 265     IndexRunner                         indexRunner;                            // thread to index notes
 266     QThread                                     indexThread;
 267
 268     QTimer                                      syncTimer;                                      // Sync on an interval
 269     QTimer                                      syncDelayTimer;                         // Sync delay to free up database
 270     SyncRunner                          syncRunner;                                     // thread to do a sync.
 271     QThread                                     syncThread;                                     // Thread which talks to evernote
 272     ThumbnailRunner                     thumbnailRunner;                        // Runner for thumbnail thread
 273     QThread                                     thumbnailThread;                        // Thread that generates pretty pictures
 274     QTimer                                      saveTimer;                                      // Timer to save note contents
 275
 276     QTimer                                      authTimer;                                      // Refresh authentication
 277     QTimer                                      externalFileSaveTimer;          // Save files altered externally
 278     QTimer                                      thumbnailTimer;                         // Wakeup & scan for thumbnails
 279     QTimer                                      debugTimer;
 280     List<String>                        externalFiles;                          // External files to save later
 281     List<String>                        importFilesKeep;                        // Auto-import files to save later
 282     List<String>                        importFilesDelete;                      // Auto-import files to save later
 283
 284     int                                         indexTime;                                      // how often to try and index
 285     boolean                                     indexRunning;                           // Is indexing running?
 286     boolean                                     indexDisabled;                          // Is indexing disabled?
 287
 288     int                                         syncThreadsReady;                       // number of sync threads that are free
 289     int                                         syncTime;                                       // Sync interval
 290     boolean                                     syncRunning;                            // Is sync running?
 291     boolean                                     automaticSync;                          // do sync automatically?
 292     QTreeWidgetItem                     attributeTreeSelected;
 293
 294     QAction                             prevButton;                                     // Go to the previous item viewed
 295     QAction                             nextButton;                                     // Go to the next item in the history
 296     QAction                             downButton;                                     // Go to the next item in the list
 297     QAction                             upButton;                                       // Go to the prev. item in the list;
 298     QAction                             synchronizeButton;                      // Synchronize with Evernote
 299     QAction                             allNotesButton;                         // Reset & view all notes
 300     QTimer                              synchronizeAnimationTimer;      // Timer to change animation button
 301     int                                 synchronizeIconAngle;           // Used to rotate sync icon
 302     QAction                     printButton;                            // Print Button
 303     QAction                             tagButton;                                      // Tag edit button
 304     QAction                             attributeButton;                        // Attribute information button
 305     QAction                     emailButton;                            // Email button
 306     QAction                     deleteButton;                           // Delete button
 307     QAction                             newButton;                                      // new Note Button;
 308     QSpinBox                    zoomSpinner;                            // Zoom zoom
 309     QAction                             searchClearButton;                      // Clear the search field
 310
 311     SearchPanel                 searchLayout;                           // Widget to hold search field, zoom, & quota
 312
 313     QSplitter                   mainLeftRightSplitter;          // main splitter for left/right side
 314     QSplitter                   leftSplitter1;                          // first left hand splitter
 315     QSplitter                   browserIndexSplitter;           // splitter between note index & note text
 316
 317     QFileSystemWatcher  importKeepWatcher;                      // Watch & keep auto-import
 318     QFileSystemWatcher  importDeleteWatcher;            // Watch & Delete auto-import
 319     List<String>                importedFiles;                          // History of imported files (so we don't import twice)
 320
 321     OnlineNoteHistory   historyWindow;                          // online history window
 322     List<NoteVersionId> versions;                                       // history versions
 323
 324     QTimer                              threadMonitorTimer;                     // Timer to watch threads.
 325     int                                 dbThreadDeadCount=0;            // number of consecutive dead times for the db thread
 326     int                                 syncThreadDeadCount=0;          // number of consecutive dead times for the sync thread
 327     int                                 indexThreadDeadCount=0;         // number of consecutive dead times for the index thread
 328     int                                 notebookThreadDeadCount=0;      // number of consecutive dead times for the notebook thread
 329     int                                 tagDeadCount=0;                         // number of consecutive dead times for the tag thread
 330     int                                 trashDeadCount=0;                       // number of consecutive dead times for the trash thread
 331     int                                 saveThreadDeadCount=0;          // number of consecutive dead times for the save thread
 332     int                                 enRelatedNotesThreadDeadCount=0;        // number of consecutive dead times for the EvernoteRelatedNotes Thread
 333     boolean                             disableTagThreadCheck=false;
 334     boolean                             disableNotebookThreadCheck=false;
 335     boolean                             disableTrashThreadCheck=false;
 336     boolean                             disableSaveThreadCheck=false;
 337     boolean                             disableSyncThreadCheck=false;
 338     boolean                             disableIndexThreadCheck=false;
 339     boolean                             disableENRelatedNotesThreadCheck=false;
 340
 341     HashMap<String, String>             noteCache;                      // Cash of note content
 342     HashMap<String, Boolean>    readOnlyCache;          // List of cashe notes that are read-only
 343     HashMap<String, Boolean>    inkNoteCache;           // List of cache notes that are ink notes
 344         // ICHANGED
 345         HashMap<Integer, ArrayList<String>> historyGuids;  // タブごとの以前見たノートのGUID
 346         HashMap<Integer, Integer> historyPosition; // Position within the viewed items
 347         HashMap<Integer, Boolean> fromHistory; // Is this from the history queue?
 348
 349     String                              trashNoteGuid;                          // Guid to restore / set into or out of trash to save position
 350     List<Thumbnailer>   thumbGenerators;                                // generate preview image
 351     ThumbnailViewer             thumbnailViewer;                        // View preview thumbnail;
 352     boolean                             encryptOnShutdown;                      // should I encrypt when I close?
 353     boolean                             decryptOnShutdown;                      // should I decrypt on shutdown;
 354     String                              encryptCipher;                          // What cipher should I use?
 355     //Signal0                   minimizeToTray;
 356     boolean                             windowMaximized = false;        // Keep track of the window state for restores
 357     List<String>                pdfReadyQueue;                          // Queue of PDFs that are ready to be rendered.
 358     List<QPixmap>               syncIcons;                                      // Array of icons used in sync animation
 359     private boolean             closeAction = false;            // Used to say when to close or when to minimize
 360     private static Logger log = Logger.getLogger(NeverNote.class);
 361     private String              saveLastPath;                           // last path we used
 362     private final QTimer                messageTimer;                           // Timer to clear the status message.
 363     private QTimer              blockTimer;
 364     BrowserWindow               blockingWindow;
 365
 366         // ICHANGED
 367         private final TabBrowserWidget tabBrowser; // ブラウザウィンドウをタブ化
 368         private final HashMap<Integer, TabBrowse> tabWindows; // タブウィンドウ
 369         private final RensoNoteList rensoNoteList; // 連想ノートリスト
 370         private final QDockWidget rensoNoteListDock; // 連想ノートリストドックウィジェット
 371         ClipBoardObserver cbObserver;
 372         String rensoNotePressedItemGuid;
 373
 374     String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
 375
 376
 377     //***************************************************************
 378     //***************************************************************
 379     //** Constructor & main entry point
 380     //***************************************************************
 381     //***************************************************************
 382     // Application Constructor
 383         @SuppressWarnings("static-access")
 384         public NeverNote(DatabaseConnection dbConn)  {
 385                 // ICHANGED
 386                 cbObserver = new ClipBoardObserver();
 387
 388                 conn = dbConn;
 389                 if (conn.getConnection() == null) {
 390                         String msg = new String(tr("Unable to connect to the database.\n\nThe most probable reason is that some other process\n" +
 391                                 "is accessing the database or NeighborNote is already running.\n\n" +
 392                                 "Please end any other process or shutdown the other NeighborNote before starting.\n\nExiting program."));
 393
 394             QMessageBox.critical(null, tr("Database Connection Error") ,msg);
 395                         System.exit(16);
 396                 }
 397                 setObjectName("mainWindow");
 398 //              thread().setPriority(Thread.MAX_PRIORITY);
 399
 400                 logger = new ApplicationLogger("nevernote.log");
 401                 logger.log(logger.HIGH, "Starting Application");
 402
 403                 decryptOnShutdown = false;
 404                 encryptOnShutdown = false;
 405                 conn.checkDatabaseVersion();
 406
 407
 408
 409                 // Start building the invalid XML tables
 410                 Global.invalidElements = conn.getInvalidXMLTable().getInvalidElements();
 411                 List<String> elements = conn.getInvalidXMLTable().getInvalidAttributeElements();
 412
 413                 for (int i=0; i<elements.size(); i++) {
 414                         Global.invalidAttributes.put(elements.get(i), conn.getInvalidXMLTable().getInvalidAttributes(elements.get(i)));
 415                 }
 416
 417                 logger.log(logger.EXTREME, "Starting GUI build");
 418
 419                 QTranslator nevernoteTranslator = new QTranslator();
 420                 nevernoteTranslator.load(Global.getFileManager().getTranslateFilePath("neighbornote_" + QLocale.system().name() + ".qm"));
 421                 QApplication.instance().installTranslator(nevernoteTranslator);
 422
 423                 Global.originalPalette = QApplication.palette();
 424                 QApplication.setStyle(Global.getStyle());
 425                 if (Global.useStandardPalette())
 426                         QApplication.setPalette(QApplication.style().standardPalette());
 427         setWindowTitle(tr("NeighborNote"));
 428
 429         mainLeftRightSplitter = new QSplitter();
 430                 // ICHANGED
 431                 mainLeftRightSplitter.setOrientation(Qt.Orientation.Horizontal);
 432
 433         setCentralWidget(mainLeftRightSplitter);
 434         leftSplitter1 = new QSplitter();
 435         leftSplitter1.setOrientation(Qt.Orientation.Vertical);
 436
 437         browserIndexSplitter = new QSplitter();
 438         browserIndexSplitter.setOrientation(Qt.Orientation.Vertical);
 439
 440         //* Setup threads & thread timers
 441 //        int indexRunnerCount = Global.getIndexThreads();
 442 //       indexRunnerCount = 1;
 443         QThreadPool.globalInstance().setMaxThreadCount(Global.threadCount);     // increase max thread count
 444
 445                 logger.log(logger.EXTREME, "Building list manager");
 446         listManager = new ListManager(conn, logger);
 447
 448                 logger.log(logger.EXTREME, "Building index runners & timers");
 449                 // ICHANGED Global.getBehaviorDatabaseUrl()を追加
 450                 indexRunner = new IndexRunner("indexRunner.log",
 451                                 Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(),
 452                                 Global.getResourceDatabaseUrl(),
 453                                 Global.getBehaviorDatabaseUrl(), Global.getDatabaseUserid(),
 454                                 Global.getDatabaseUserPassword(), Global.cipherPassword);
 455
 456                 indexThread = new QThread(indexRunner, "Index Thread");
 457         indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
 458         indexRunner.indexImageRecognition = Global.indexImageRecognition();
 459         indexRunner.indexNoteBody = Global.indexNoteBody();
 460         indexRunner.indexNoteTitle = Global.indexNoteTitle();
 461         indexRunner.specialIndexCharacters = Global.getSpecialIndexCharacters();
 462                 indexThread.start();
 463
 464         synchronizeAnimationTimer = new QTimer();
 465         synchronizeAnimationTimer.timeout.connect(this, "updateSyncButton()");
 466
 467                 indexTimer = new QTimer();
 468                 indexTime = 1000*Global.getIndexThreadSleepInterval();
 469                 indexTimer.start(indexTime);  // Start indexing timer
 470                 indexTimer.timeout.connect(this, "indexTimer()");
 471                 indexDisabled = false;
 472                 indexRunning = false;
 473
 474                 logger.log(logger.EXTREME, "Setting sync thread & timers");
 475                 syncThreadsReady=1;
 476                 // ICHANGED Global.getBehaviorDatabaseUrl()を追加
 477                 syncRunner = new SyncRunner("syncRunner.log", Global.getDatabaseUrl(),
 478                                 Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
 479                                 Global.getBehaviorDatabaseUrl(), Global.getDatabaseUserid(),
 480                                 Global.getDatabaseUserPassword(), Global.cipherPassword);
 481
 482                 syncTime = new SyncTimes().timeValue(Global.getSyncInterval());
 483                 syncTimer = new QTimer();
 484                 syncTimer.timeout.connect(this, "syncTimer()");
 485         syncRunner.status.message.connect(this, "setMessage(String)");
 486         syncRunner.syncSignal.finished.connect(this, "syncThreadComplete(Boolean)");
 487         syncRunner.syncSignal.errorDisconnect.connect(this, "remoteErrorDisconnect()");
 488         syncRunning = false;
 489                 if (syncTime > 0) {
 490                         automaticSync = true;
 491                         syncTimer.start(syncTime*60*1000);
 492                 } else {
 493                         automaticSync = false;
 494                         syncTimer.stop();
 495                 }
 496                 syncRunner.setEvernoteUpdateCount(Global.getEvernoteUpdateCount());
 497                 syncThread = new QThread(syncRunner, "Synchronization Thread");
 498                 syncThread.start();
 499
 500
 501                 logger.log(logger.EXTREME, "Starting thumnail thread");
 502                 pdfReadyQueue = new ArrayList<String>();
 503                 // ICHANGED Global.getBehaviorDatabaseUrl()を追加
 504                 thumbnailRunner = new ThumbnailRunner("thumbnailRunner.log",
 505                                 Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(),
 506                                 Global.getResourceDatabaseUrl(),
 507                                 Global.getBehaviorDatabaseUrl(), Global.getDatabaseUserid(),
 508                                 Global.getDatabaseUserPassword(), Global.cipherPassword);
 509
 510                 thumbnailThread = new QThread(thumbnailRunner, "Thumbnail Thread");
 511                 thumbnailRunner.noteSignal.thumbnailPageReady.connect(this, "thumbnailHTMLReady(String,QByteArray,Integer)");
 512                 thumbnailThread.start();
 513                 thumbGenerators = new ArrayList<Thumbnailer>();
 514                 thumbnailTimer = new QTimer();
 515                 thumbnailTimer.timeout.connect(this, "thumbnailTimer()");
 516                 thumbnailTimer();
 517                 thumbnailTimer.setInterval(500*1000);  // Thumbnail every minute
 518                 thumbnailTimer.start();
 519
 520 //              debugTimer = new QTimer();
 521 //              debugTimer.timeout.connect(this, "debugDirty()");
 522 //              debugTimer.start(1000*60);
 523
 524                 logger.log(logger.EXTREME, "Starting authentication timer");
 525                 authTimer = new QTimer();
 526                 authTimer.timeout.connect(this, "authTimer()");
 527                 authTimer.start(1000*60*15);
 528                 syncRunner.syncSignal.authRefreshComplete.connect(this, "authRefreshComplete(boolean)");
 529
 530                 logger.log(logger.EXTREME, "Setting save note timer");
 531                 saveTimer = new QTimer();
 532                 saveTimer.timeout.connect(this, "saveNote()");
 533                 if (Global.getAutoSaveInterval() > 0) {
 534                         saveTimer.setInterval(1000*60*Global.getAutoSaveInterval());
 535                         saveTimer.start();
 536                 }
 537                 listManager.saveRunner.noteSignals.noteSaveRunnerError.connect(this, "saveRunnerError(String, String)");
 538
 539                 logger.log(logger.EXTREME, "Starting external file monitor timer");
 540                 externalFileSaveTimer = new QTimer();
 541                 externalFileSaveTimer.timeout.connect(this, "externalFileEditedSaver()");
 542                 externalFileSaveTimer.setInterval(1000*5);   // save every 5 seconds;
 543                 externalFiles = new ArrayList<String>();
 544                 importFilesDelete = new ArrayList<String>();
 545                 importFilesKeep = new ArrayList<String>();
 546                 externalFileSaveTimer.start();
 547
 548         notebookTree = new NotebookTreeWidget(conn);
 549         attributeTree = new AttributeTreeWidget();
 550         tagTree = new TagTreeWidget(conn);
 551         savedSearchTree = new SavedSearchTreeWidget();
 552         trashTree = new TrashTreeWidget();
 553                 // ICHANGED
 554                 noteTableView = new TableView(logger, listManager, this);
 555
 556         searchField = new QComboBox();
 557         searchField.setObjectName("searchField");
 558         //setStyleSheet("QComboBox#searchField { background-color: yellow }");
 559         searchField.setEditable(true);
 560         searchField.activatedIndex.connect(this, "searchFieldChanged()");
 561         searchField.setDuplicatesEnabled(false);
 562         searchField.editTextChanged.connect(this,"searchFieldTextChanged(String)");
 563         searchShortcut = new QShortcut(this);
 564         setupShortcut(searchShortcut, "Focus_Search");
 565         searchShortcut.activated.connect(this, "focusSearch()");
 566
 567         quotaBar = new QuotaProgressBar();
 568         // Setup the zoom
 569         zoomSpinner = new QSpinBox();
 570         zoomSpinner.setMinimum(10);
 571         zoomSpinner.setMaximum(1000);
 572         zoomSpinner.setAccelerated(true);
 573         zoomSpinner.setSingleStep(10);
 574         zoomSpinner.setValue(100);
 575         zoomSpinner.valueChanged.connect(this, "zoomChanged()");
 576
 577         searchLayout = new SearchPanel(searchField, quotaBar, notebookTree, zoomSpinner);
 578
 579
 580         QGridLayout leftGrid = new QGridLayout();
 581         leftSplitter1.setContentsMargins(5, 0, 0, 7);
 582         leftSplitter1.setLayout(leftGrid);
 583         leftGrid.addWidget(searchLayout,1,1);
 584         leftGrid.addWidget(tagTree,2,1);
 585         leftGrid.addWidget(attributeTree,3,1);
 586         leftGrid.addWidget(savedSearchTree,4,1);
 587         leftGrid.addWidget(trashTree,5, 1);
 588
 589         // Setup the browser window
 590         noteCache = new HashMap<String,String>();
 591         readOnlyCache = new HashMap<String, Boolean>();
 592         inkNoteCache = new HashMap<String, Boolean>();
 593         // ICHANGED
 594         browserWindow = new BrowserWindow(conn, cbObserver);
 595
 596                 // ICHANGED 下から移動してきた。
 597                 historyGuids = new HashMap<Integer, ArrayList<String>>();
 598                 historyPosition = new HashMap<Integer, Integer>();
 599                 fromHistory = new HashMap<Integer, Boolean>();
 600
 601                 // ICHANGED タブブラウザ作成
 602                 tabWindows = new HashMap<Integer, TabBrowse>();
 603                 tabBrowser = new TabBrowserWidget(this);
 604                 tabBrowser.setStyleSheet("QTabBar::tab{width:150px;}");
 605                 tabBrowser.setMovable(true);
 606                 TabBrowse tab = new TabBrowse(conn, tabBrowser, cbObserver);
 607                 browserWindow = tab.getBrowserWindow();
 608                 int index = tabBrowser.addNewTab(tab, "");
 609                 tabWindows.put(index, tab);
 610                 tabBrowser.setTabsClosable(true);
 611                 tabBrowser.currentChanged.connect(this, "tabWindowChanged(int)");
 612                 tabBrowser.tabCloseRequested.connect(this, "tabWindowClosing(int)");
 613
 614                 noteDirty = new HashMap<Integer, Boolean>();
 615                 noteDirty.put(index, false);
 616
 617                 inkNote = new HashMap<Integer, Boolean>();
 618                 readOnly = new HashMap<Integer, Boolean>();
 619
 620                 // ICHANGED
 621                 // 履歴記録のハッシュマップを初期化
 622                 historyGuids.put(index, new ArrayList<String>());
 623                 historyPosition.put(index, 0);
 624                 fromHistory.put(index, false);
 625
 626         mainLeftRightSplitter.addWidget(leftSplitter1);
 627         mainLeftRightSplitter.addWidget(browserIndexSplitter);
 628
 629                 // ICHANGED
 630                 // 連想ノートリストをセットアップ
 631                 rensoNoteList = new RensoNoteList(conn, this, syncRunner);
 632                 rensoNoteList.itemPressed.connect(this,
 633                                 "rensoNoteItemPressed(QListWidgetItem)");
 634                 rensoNoteListDock = new QDockWidget(tr("Renso Note List"), this);
 635                 rensoNoteListDock.setWidget(rensoNoteList);
 636                 addDockWidget(DockWidgetArea.RightDockWidgetArea, rensoNoteListDock);
 637
 638                 if (Global.getListView() == Global.View_List_Wide) {
 639                         browserIndexSplitter.addWidget(noteTableView);
 640                         // ICHANGED
 641                         browserIndexSplitter.addWidget(tabBrowser);
 642                         // browserIndexSplitter.addWidget(browserWindow);
 643                 } else {
 644                         mainLeftRightSplitter.addWidget(noteTableView);
 645                         // ICHANGED
 646                         mainLeftRightSplitter.addWidget(tabBrowser);
 647                         // mainLeftRightSplitter.addWidget(browserWindow);
 648                 }
 649
 650         // Setup the thumbnail viewer
 651         thumbnailViewer = new ThumbnailViewer();
 652         thumbnailViewer.upArrow.connect(this, "upAction()");
 653         thumbnailViewer.downArrow.connect(this, "downAction()");
 654         thumbnailViewer.leftArrow.connect(this, "nextViewedAction()");
 655         thumbnailViewer.rightArrow.connect(this, "previousViewedAction()");
 656
 657         //Setup external browser manager
 658         externalWindows = new HashMap<String, ExternalBrowse>();
 659
 660         listManager.loadNotesIndex();
 661         initializeNotebookTree();
 662         initializeTagTree();
 663         initializeSavedSearchTree();
 664         attributeTree.itemClicked.connect(this, "attributeTreeClicked(QTreeWidgetItem, Integer)");
 665         attributeTreeSelected = null;
 666         initializeNoteTable();
 667
 668                 selectedNoteGUIDs = new ArrayList<String>();
 669                 statusBar = new QStatusBar();
 670                 setStatusBar(statusBar);
 671                 menuBar = new MainMenuBar(this);
 672                 emitLog = new ArrayList<String>();
 673
 674                 tagTree.setDeleteAction(menuBar.tagDeleteAction);
 675                 tagTree.setMergeAction(menuBar.tagMergeAction);
 676                 tagTree.setEditAction(menuBar.tagEditAction);
 677                 tagTree.setAddAction(menuBar.tagAddAction);
 678                 tagTree.setIconAction(menuBar.tagIconAction);
 679                 tagTree.setVisible(Global.isWindowVisible("tagTree"));
 680                 leftSplitter1.setVisible(Global.isWindowVisible("leftPanel"));
 681                 tagTree.noteSignal.tagsAdded.connect(this, "tagsAdded(String, String)");
 682                 menuBar.hideTags.setChecked(Global.isWindowVisible("tagTree"));
 683                 listManager.tagSignal.listChanged.connect(this, "reloadTagTree()");
 684
 685                 if (!Global.isWindowVisible("zoom")) {
 686                         searchLayout.hideZoom();
 687                         menuBar.hideZoom.setChecked(false);
 688                 }
 689
 690                 notebookTree.setDeleteAction(menuBar.notebookDeleteAction);
 691                 notebookTree.setEditAction(menuBar.notebookEditAction);
 692                 notebookTree.setAddAction(menuBar.notebookAddAction);
 693                 notebookTree.setIconAction(menuBar.notebookIconAction);
 694                 notebookTree.setStackAction(menuBar.notebookStackAction);
 695                 notebookTree.setPublishAction(menuBar.notebookPublishAction);
 696                 notebookTree.setShareAction(menuBar.notebookShareAction);
 697                 notebookTree.setVisible(Global.isWindowVisible("notebookTree"));
 698                 notebookTree.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
 699                 notebookTree.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
 700             notebookTree.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
 701                 menuBar.hideNotebooks.setChecked(Global.isWindowVisible("notebookTree"));
 702
 703                 savedSearchTree.setAddAction(menuBar.savedSearchAddAction);
 704                 savedSearchTree.setEditAction(menuBar.savedSearchEditAction);
 705                 savedSearchTree.setDeleteAction(menuBar.savedSearchDeleteAction);
 706                 savedSearchTree.setIconAction(menuBar.savedSearchIconAction);
 707                 savedSearchTree.itemSelectionChanged.connect(this, "updateSavedSearchSelection()");
 708                 savedSearchTree.setVisible(Global.isWindowVisible("savedSearchTree"));
 709                 menuBar.hideSavedSearches.setChecked(Global.isWindowVisible("savedSearchTree"));
 710
 711                 // ICHANGED noteTableViewに新しいタブで開くを追加
 712                 noteTableView.setOpenNewTabAction(menuBar.noteOpenNewTab);
 713
 714                 noteTableView.setAddAction(menuBar.noteAdd);
 715
 716                 // ICHANGED noteTableViewに新しいタブでノート追加を追加
 717                 noteTableView.setAddNoteNewTabAction(menuBar.noteAddNewTab);
 718
 719                 noteTableView.setDeleteAction(menuBar.noteDelete);
 720                 noteTableView.setRestoreAction(menuBar.noteRestoreAction);
 721                 noteTableView.setNoteDuplicateAction(menuBar.noteDuplicateAction);
 722                 noteTableView.setNoteHistoryAction(menuBar.noteOnlineHistoryAction);
 723                 noteTableView.noteSignal.titleColorChanged.connect(this, "titleColorChanged(Integer)");
 724                 noteTableView.noteSignal.notePinned.connect(this, "notePinned()");
 725                 noteTableView.setMergeNotesAction(menuBar.noteMergeAction);
 726                 noteTableView.setCopyAsUrlAction(menuBar.noteCopyAsUrlAction);
 727                 noteTableView.doubleClicked.connect(this, "listDoubleClick()");
 728                 listManager.trashSignal.countChanged.connect(trashTree, "updateCounts(Integer)");
 729
 730                 quotaBar.setMouseClickAction(menuBar.accountAction);
 731
 732                 trashTree.load();
 733         trashTree.itemSelectionChanged.connect(this, "trashTreeSelection()");
 734                 trashTree.setEmptyAction(menuBar.emptyTrashAction);
 735                 trashTree.setVisible(Global.isWindowVisible("trashTree"));
 736                 menuBar.hideTrash.setChecked(Global.isWindowVisible("trashTree"));
 737                 trashTree.updateCounts(listManager.getTrashCount());
 738                 attributeTree.setVisible(Global.isWindowVisible("attributeTree"));
 739                 menuBar.hideAttributes.setChecked(Global.isWindowVisible("attributeTree"));
 740
 741                 noteTableView.setVisible(Global.isWindowVisible("noteList"));
 742                 menuBar.hideNoteList.setChecked(Global.isWindowVisible("noteList"));
 743
 744                 // ICHANGED
 745                 if (!Global.isWindowVisible("editorButtonBar")) {
 746                         menuBar.showEditorBar.setChecked(false);
 747                         toggleEditorButtonBar();
 748                 }
 749
 750                 if (!Global.isWindowVisible("leftPanel"))
 751                         menuBar.hideLeftSide.setChecked(true);
 752
 753                 // ICHANGED
 754                 if (Global.isWindowVisible("noteInformation")) {
 755                         menuBar.noteAttributes.setChecked(true);
 756                         toggleNoteInformation();
 757                 }
 758
 759                 quotaBar.setVisible(Global.isWindowVisible("quota"));
 760                 // IFIXED quotaBar.isVisible() → Global.isWindowVisible("quota")
 761                 // なぜかquotaBar.isVisible()が常にfalseを返すようなので修正
 762                 if (!Global.isWindowVisible("quota"))
 763                         menuBar.hideQuota.setChecked(false);
 764
 765                 searchField.setVisible(Global.isWindowVisible("searchField"));
 766                 // IFIXED !searchField.isVisible() → !Global.isWindowVisible("searchField")
 767                 // なぜかsearchField.isVisible()が常にfalseを返すようなので修正
 768                 if (!Global.isWindowVisible("searchField"))
 769                         menuBar.hideSearch.setChecked(false);
 770
 771                 if (searchField.isHidden() && quotaBar.isHidden() && zoomSpinner.isHidden() && notebookTree.isHidden())
 772                         searchLayout.hide();
 773
 774                 setMenuBar(menuBar);
 775                 setupToolBar();
 776                 find = new FindDialog();
 777                 find.getOkButton().clicked.connect(this, "doFindText()");
 778
 779                 // Setup the tray icon menu bar
 780                 trayShowAction = new QAction(tr("Show/Hide"), this);
 781                 trayExitAction = new QAction(tr("Exit"), this);
 782                 trayAddNoteAction = new QAction(tr("Add Note"), this);
 783
 784                 trayExitAction.triggered.connect(this, "closeNeverNote()");
 785                 trayAddNoteAction.triggered.connect(this, "addNote()");
 786                 trayShowAction.triggered.connect(this, "trayToggleVisible()");
 787
 788                 trayMenu = new QMenu(this);
 789                 trayMenu.addAction(trayAddNoteAction);
 790                 trayMenu.addAction(trayShowAction);
 791                 trayMenu.addAction(trayExitAction);
 792
 793
 794                 trayIcon = new QSystemTrayIcon(this);
 795                 trayIcon.setToolTip(tr("NeighborNote"));
 796                 trayIcon.setContextMenu(trayMenu);
 797                 trayIcon.activated.connect(this, "trayActivated(com.trolltech.qt.gui.QSystemTrayIcon$ActivationReason)");
 798
 799                 currentNoteGuid="";
 800                 currentNoteGuid = Global.getLastViewedNoteGuid();
 801                 if (currentNoteGuid.equals(""))
 802                         currentNote = new Note();
 803
 804                 // ICHANGED
 805                 /* 上に移動したので要らない
 806                 historyGuids = new ArrayList<String>();
 807                 historyPosition = 0;
 808                 fromHistory = false;
 809                 */
 810
 811                 if (!currentNoteGuid.trim().equals("")) {
 812                         currentNote = conn.getNoteTable().getNote(currentNoteGuid, true,true,false,false,true);
 813                 }
 814
 815                 noteIndexUpdated(true);
 816                 showColumns();
 817                 menuBar.showEditorBar.setChecked(Global.isWindowVisible("editorButtonBar"));
 818                 if (menuBar.showEditorBar.isChecked())
 819                 showEditorButtons(browserWindow);
 820                 tagIndexUpdated(true);
 821                 savedSearchIndexUpdated();
 822                 notebookIndexUpdated();
 823                 updateQuotaBar();
 824         setupSyncSignalListeners();
 825         setupBrowserSignalListeners();
 826         setupIndexListeners();
 827
 828
 829         tagTree.tagSignal.listChanged.connect(this, "tagIndexUpdated()");
 830         tagTree.showAllTags(true);
 831
 832                 QIcon appIcon = new QIcon(iconPath+"nevernote.png");
 833                 if (QSystemTrayIcon.isSystemTrayAvailable()) {
 834                         setWindowIcon(appIcon);
 835                         trayIcon.setIcon(appIcon);
 836                         if (Global.showTrayIcon() || Global.minimizeOnClose())
 837                                 trayIcon.show();
 838                         else
 839                                 trayIcon.hide();
 840                 }
 841
 842         scrollToGuid(currentNoteGuid);
 843         if (Global.automaticLogin()) {
 844                 remoteConnect();
 845                 if (Global.isConnected)
 846                         syncTimer();
 847         }
 848         setupFolderImports();
 849
 850         loadStyleSheet();
 851         restoreWindowState(true);
 852
 853         if (Global.mimicEvernoteInterface) {
 854                 notebookTree.selectGuid("");
 855         }
 856
 857         threadMonitorTimer = new QTimer();
 858         threadMonitorTimer.timeout.connect(this, "threadMonitorCheck()");
 859         threadMonitorTimer.start(1000*10);  // Check for threads every 10 seconds;
 860
 861                 // ICHANGED たぶんこれはいらない
 862                 // IFIXED ?
 863                 /*
 864                 historyGuids.add(currentNoteGuid);
 865                 historyPosition = 1;
 866                 */
 867
 868         menuBar.blockSignals(true);
 869         menuBar.narrowListView.blockSignals(true);
 870         menuBar.wideListView.blockSignals(true);
 871         if (Global.getListView() == Global.View_List_Narrow) {
 872                 menuBar.narrowListView.setChecked(true);
 873         }
 874         else{
 875                 menuBar.wideListView.setChecked(true);
 876         }
 877         menuBar.blockSignals(false);
 878         menuBar.narrowListView.blockSignals(false);
 879         menuBar.wideListView.blockSignals(false);
 880
 881                 // IFIXED
 882                 // 上に同じコードがあるよね？　とりあえずコメントアウト
 883                 /*
 884                  * if (Global.getListView() == Global.View_List_Wide) {
 885                  * browserIndexSplitter.addWidget(noteTableView); // ICHANGED //
 886                  * browserIndexSplitter.addWidget(tabBrowser);
 887                  * browserIndexSplitter.addWidget(browserWindow); } else {
 888                  * mainLeftRightSplitter.addWidget(noteTableView); // ICHANGED //
 889                  * mainLeftRightSplitter.addWidget(tabBrowser);
 890                  * mainLeftRightSplitter.addWidget(browserWindow); }
 891                  */
 892
 893                 messageTimer = new QTimer();
 894                 messageTimer.timeout.connect(this, "clearMessage()");
 895                 messageTimer.setInterval(1000*15);
 896                 clearMessage();
 897
 898         int sortCol = Global.getSortColumn();
 899                 int sortOrder = Global.getSortOrder();
 900                 noteTableView.proxyModel.blocked = true;
 901                 // We sort the table twice to fix a bug.  For some reaosn the table won't sort properly if it is in narrow
 902                 // list view and sorted descending on the date  created.  By sorting it twice it forces the proper sort.  Ugly.
 903                 if (sortCol == 0 && sortOrder == 1 && Global.getListView() == Global.View_List_Narrow)
 904                         noteTableView.sortByColumn(sortCol, SortOrder.resolve(0));
 905                 noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
 906                 noteTableView.proxyModel.blocked = false;
 907                 noteTableView.proxyModel.sortChanged.connect(this, "tableSortOrderChanged(Integer,Integer)");
 908
 909                 // Set the startup notebook
 910         String defaultNotebook = Global.getStartupNotebook();
 911         if (!defaultNotebook.equals("AllNotebooks") && !defaultNotebook.equals("")) {
 912                 for (int k=0; k<listManager.getNotebookIndex().size(); k++) {
 913                         if (listManager.getNotebookIndex().get(k).isDefaultNotebook()) {
 914                                 notebookTree.clearSelection();
 915                                 notebookTree.selectGuid(listManager.getNotebookIndex().get(k).getGuid());
 916                                 notebookTree.selectionSignal.emit();
 917                         }
 918                 }
 919         }
 920
 921                 if (Global.checkVersionUpgrade()) {
 922                         checkForUpdates();
 923                 }
 924
 925                 // ICHANGED
 926                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
 927                         menuBar.noteAddNewTab.setEnabled(false);
 928                 }
 929         }
 930
 931
 932         public void debugDirty() {
 933                 List<Note> dirty = conn.getNoteTable().getDirty();
 934                 logger.log(logger.LOW, "------ Dirty Notes List Begin ------");
 935                 for (int i=0; i<dirty.size(); i++) {
 936                         logger.log(logger.LOW, "GUID: " +dirty.get(i).getGuid() + " Title:" + dirty.get(i).getTitle());
 937                 }
 938                 logger.log(logger.LOW, "------ Dirty Notes List End ------");
 939         }
 940
 941         // Main entry point
 942         public static void main(String[] args) {
 943                 log.setLevel(Level.FATAL);
 944                 QApplication.initialize(args);
 945                 QPixmap pixmap = new QPixmap("classpath:cx/fbn/nevernote/icons/splash_logo.png");
 946                 QSplashScreen splash = new QSplashScreen(pixmap);
 947                 boolean showSplash;
 948
 949                 DatabaseConnection dbConn;
 950
 951         try {
 952             initializeGlobalSettings(args);
 953
 954             showSplash = Global.isWindowVisible("SplashScreen");
 955             if (showSplash)
 956                 splash.show();
 957
 958             dbConn = setupDatabaseConnection();
 959
 960             // Must be last stage of setup - only safe once DB is open hence we know we are the only instance running
 961             Global.getFileManager().purgeResDirectory(true);
 962
 963         } catch (InitializationException e) {
 964             // Fatal
 965             e.printStackTrace();
 966             QMessageBox.critical(null, "Startup error", "Aborting: " + e.getMessage());
 967             return;
 968         }
 969
 970                 // Setup proxy crap
 971                 String proxyUrl = Global.getProxyValue("url");
 972                 String proxyPort = Global.getProxyValue("port");
 973                 String proxyUserid = Global.getProxyValue("userid");
 974                 String proxyPassword = Global.getProxyValue("password");
 975                 boolean proxySet = false;
 976                 QNetworkProxy proxy = new QNetworkProxy();
 977                 proxy.setType(ProxyType.HttpProxy);
 978                 if (!proxyUrl.trim().equals("")) {
 979                         System.out.println("Proxy URL found: " +proxyUrl);
 980                         proxySet = true;
 981                         proxy.setHostName(proxyUrl);
 982                 }
 983                 if (!proxyPort.trim().equals("")) {
 984                         System.out.println("Proxy Port found: " +proxyPort);
 985                         proxySet = true;
 986                         proxy.setPort(Integer.parseInt(proxyPort));
 987                 }
 988                 if (!proxyUserid.trim().equals("")) {
 989                         System.out.println("Proxy Userid found: " +proxyUserid);
 990                         proxySet = true;
 991                         proxy.setUser(proxyUserid);
 992                 }
 993                 if (!proxyPassword.trim().equals("")) {
 994                         System.out.println("Proxy URL found: " +proxyPassword);
 995                         proxySet = true;
 996                         proxy.setPassword(proxyPassword);
 997                 }
 998                 if (proxySet) {
 999                         QNetworkProxy.setApplicationProxy(proxy);
1000                 }
1001
1002
1003         NeverNote application = new NeverNote(dbConn);
1004                 if (Global.syncOnly) {
1005                         System.out.println("Performing synchronization only.");
1006                         application.remoteConnect();
1007                         if (Global.isConnected) {
1008                                 application.syncRunner.syncNeeded = true;
1009                                 application.syncRunner.addWork("SYNC");
1010                                 application.syncRunner.addWork("STOP");
1011                                 while(!application.syncRunner.isIdle());
1012                                 application.closeNeverNote();
1013                         }
1014                         return;
1015                 }
1016
1017                 application.setAttribute(WidgetAttribute.WA_DeleteOnClose, true);
1018                 if (Global.startMinimized())
1019                         application.showMinimized();
1020                 else {
1021                         if (Global.wasWindowMaximized())
1022                                 application.showMaximized();
1023                         else
1024                                 application.show();
1025                 }
1026
1027                 if (showSplash)
1028                         splash.finish(application);
1029                 QApplication.exec();
1030                 System.out.println("Goodbye.");
1031                 QApplication.exit();
1032         }
1033
1034     /**
1035      * Open the internal database, or create if not present
1036      *
1037      * @throws InitializationException when opening the database fails, e.g. because another process has it locked
1038      */
1039     private static DatabaseConnection setupDatabaseConnection() throws InitializationException {
1040         ApplicationLogger logger = new ApplicationLogger("nevernote-database.log");
1041
1042         File f = Global.getFileManager().getDbDirFile(Global.databaseName + ".h2.db");
1043         File fr = Global.getFileManager().getDbDirFile(Global.resourceDatabaseName + ".h2.db");
1044                 // IFIXED resourceDatabaseNameになっていたので修正
1045                 File fi = Global.getFileManager().getDbDirFile(Global.indexDatabaseName + ".h2.db");
1046                 // ICHANGED
1047                 File fb = Global.getFileManager().getDbDirFile(Global.behaviorDatabaseName + ".h2.db");
1048
1049                 if (!f.exists())
1050                         Global.setDatabaseUrl("");
1051                 if (!fr.exists())
1052                         Global.setResourceDatabaseUrl("");
1053                 if (!fi.exists())
1054                         Global.setIndexDatabaseUrl("");
1055                 // ICHANGED
1056                 if (!fb.exists())
1057                         Global.setBehaviorDatabaseUrl("");
1058
1059         if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") > -1) {
1060             boolean goodCheck = false;
1061             while (!goodCheck) {
1062                 DatabaseLoginDialog dialog = new DatabaseLoginDialog();
1063                 dialog.exec();
1064                 if (!dialog.okPressed())
1065                     System.exit(0);
1066                 Global.cipherPassword = dialog.getPassword();
1067                 goodCheck = databaseCheck(Global.getDatabaseUrl(), Global.getDatabaseUserid(),
1068                         Global.getDatabaseUserPassword(), Global.cipherPassword);
1069             }
1070         }
1071         // ICHANGED Global.getBehaviorDatabaserUrl()を追加
1072         DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(),
1073                         Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(), Global.getBehaviorDatabaseUrl(),
1074                         Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword, 0);
1075        return dbConn;
1076     }
1077
1078     // Encrypt the database upon shutdown
1079     private void encryptOnShutdown() {
1080         String dbPath= Global.getFileManager().getDbDirPath("");
1081         try {
1082
1083                 Statement st = conn.getConnection().createStatement();
1084                 st.execute("shutdown");
1085                 st = conn.getResourceConnection().createStatement();
1086                 st.execute("shutdown");
1087                 st = conn.getIndexConnection().createStatement();
1088                 st.execute("shutdown");
1089                 // ICHANGED
1090                 st = conn.getBehaviorConnection().createStatement();
1091                 st.execute("shutdown");
1092
1093                 if (QMessageBox.question(this, tr("Are you sure"),
1094                                 tr("Are you sure you wish to encrypt the database?"),
1095                                 QMessageBox.StandardButton.Yes,
1096                                 QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
1097                         ChangeFileEncryption.execute(dbPath, "NeverNote", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
1098                         ChangeFileEncryption.execute(dbPath, "Resources", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
1099                         ChangeFileEncryption.execute(dbPath, "Index", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
1100                         // ICHANGED
1101                         ChangeFileEncryption.execute(dbPath, "Behavior", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
1102
1103                         Global.setDatabaseUrl(Global.getDatabaseUrl() + ";CIPHER="+encryptCipher);
1104                         Global.setResourceDatabaseUrl(Global.getResourceDatabaseUrl() + ";CIPHER="+encryptCipher);
1105                         Global.setIndexDatabaseUrl(Global.getIndexDatabaseUrl() + ";CIPHER="+encryptCipher);
1106                         // ICHANGED
1107                                 Global.setBehaviorDatabaseUrl(Global.getBehaviorDatabaseUrl() + ";CIPHER=" + encryptCipher);
1108
1109                         QMessageBox.information(this, tr("Encryption Complete"), tr("Encryption is complete"));
1110                 }
1111         } catch (SQLException e) {
1112                         e.printStackTrace();
1113                 }
1114     }
1115
1116     // Decrypt the database upon shutdown
1117     private void decryptOnShutdown() {
1118         String dbPath= Global.getFileManager().getDbDirPath("");
1119         String dbName = "NeverNote";
1120         try {
1121                 Statement st = conn.getConnection().createStatement();
1122                 st.execute("shutdown");
1123                 if (Global.getDatabaseUrl().toUpperCase().indexOf(";CIPHER=AES") > -1)
1124                         encryptCipher = "AES";
1125                 else
1126                         encryptCipher = "XTEA";
1127                 if (QMessageBox.question(this, tr("Confirmation"), tr("Are you sure",
1128                                 "Are you sure you wish to decrypt the database?"),
1129                                 QMessageBox.StandardButton.Yes,
1130                                 QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
1131
1132                         ChangeFileEncryption.execute(dbPath, dbName, encryptCipher, Global.cipherPassword.toCharArray(), null, true);
1133                         Global.setDatabaseUrl("");
1134                         Global.setResourceDatabaseUrl("");
1135                         Global.setIndexDatabaseUrl("");
1136                         QMessageBox.information(this, tr("Decryption Complete"), tr("Decryption is complete"));
1137                 }
1138                 } catch (SQLException e) {
1139                         e.printStackTrace();
1140                 }
1141     }
1142     /**
1143      * Encrypt/Decrypt the local database
1144      **/
1145     public void doDatabaseEncrypt() {
1146         // The database is not currently encrypted
1147         if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") == -1) {
1148                 if (QMessageBox.question(this, tr("Confirmation"), tr("Encrypting the database is used" +
1149                                 "to enhance security and is performed\nupon shutdown, but please be aware that if"+
1150                                 " you lose the password your\nis lost forever.\n\nIt is highly recommended you " +
1151                                 "perform a backup and/or fully synchronize\n prior to executing this funtction.\n\n" +
1152                                 "Do you wish to proceed?"),
1153                                 QMessageBox.StandardButton.Yes,
1154                                 QMessageBox.StandardButton.No)==StandardButton.No.value()) {
1155                                 return;
1156                 }
1157                 DBEncryptDialog dialog = new DBEncryptDialog();
1158                 dialog.exec();
1159                 if (dialog.okPressed()) {
1160                         Global.cipherPassword = dialog.getPassword();
1161                         encryptOnShutdown  = true;
1162                         encryptCipher = dialog.getEncryptionMethod();
1163                 }
1164         } else {
1165             DBEncryptDialog dialog = new DBEncryptDialog();
1166             dialog.setWindowTitle(tr("Database Decryption"));
1167             dialog.hideEncryption();
1168             dialog.exec();
1169             if (dialog.okPressed()) {
1170                 if (!dialog.getPassword().equals(Global.cipherPassword)) {
1171                         QMessageBox.critical(null, tr("Incorrect Password"), tr("Incorrect Password"));
1172                         return;
1173                 }
1174                 decryptOnShutdown  = true;
1175                 encryptCipher = "";
1176             }
1177         }
1178         return;
1179     }
1180
1181         private static void initializeGlobalSettings(String[] args) throws InitializationException {
1182                 StartupConfig   startupConfig = new StartupConfig();
1183
1184         for (String arg : args) {
1185             String lower = arg.toLowerCase();
1186             if (lower.startsWith("--name="))
1187                startupConfig.setName(arg.substring(arg.indexOf('=') + 1));
1188             if (lower.startsWith("--home="))
1189                startupConfig.setHomeDirPath(arg.substring(arg.indexOf('=') + 1));
1190             if (lower.startsWith("--disable-viewing"))
1191                startupConfig.setDisableViewing(true);
1192             if (lower.startsWith("--sync-only=true"))
1193                 startupConfig.setSyncOnly(true);
1194         }
1195         Global.setup(startupConfig);
1196
1197     }
1198
1199     // Exit point
1200         @Override
1201         public void closeEvent(QCloseEvent event) {
1202                 if (Global.minimizeOnClose() && !closeAction) {
1203                         event.ignore();
1204                         hide();
1205                         return;
1206                 }
1207                 logger.log(logger.HIGH, "Entering NeverNote.closeEvent");
1208                 waitCursor(true);
1209
1210                 if (currentNote != null & browserWindow != null) {
1211                         if (currentNote.getTitle() != null && browserWindow != null
1212                                         && !currentNote.getTitle().equals(browserWindow.getTitle()))
1213                                 conn.getNoteTable().updateNoteTitle(currentNote.getGuid(),
1214                                                 browserWindow.getTitle());
1215                 }
1216
1217                 saveNote();
1218                 setMessage(tr("Beginning shutdown."));
1219
1220                 // Close down external windows
1221                 Collection<ExternalBrowse> windows = externalWindows.values();
1222                 Iterator<ExternalBrowse> iterator = windows.iterator();
1223                 while (iterator.hasNext()) {
1224                         ExternalBrowse browser = iterator.next();
1225                         browser.windowClosing.disconnect();
1226                         browser.close();
1227                 }
1228
1229                 // ICHANGED タブブラウザに対してクローズ処理を行う
1230                 Collection<TabBrowse> win = tabWindows.values();
1231                 Iterator<TabBrowse> it = win.iterator();
1232                 tabBrowser.currentChanged.disconnect();
1233                 tabBrowser.tabCloseRequested.disconnect();
1234                 while (it.hasNext()) {
1235                         TabBrowse browser = it.next();
1236                         browser.close();
1237                 }
1238
1239                 externalFileEditedSaver();
1240                 if (Global.isConnected && Global.synchronizeOnClose()) {
1241                         setMessage(tr("Performing synchronization before closing."));
1242                         syncRunner.syncNeeded = true;
1243                         syncRunner.addWork("SYNC");
1244                 } else {
1245                         syncRunner.keepRunning = false;
1246                 }
1247                 syncRunner.addWork("STOP");
1248                 setMessage("Closing Program.");
1249                 threadMonitorTimer.stop();
1250
1251                 thumbnailRunner.addWork("STOP");
1252                 indexRunner.addWork("STOP");
1253                 saveNote();
1254                 listManager.stop();
1255                 saveWindowState();
1256
1257                 // 連想ノートリストのEvernote関連ノート取得スレッドを終了
1258                 rensoNoteList.stopThread();
1259
1260                 if (tempFiles != null)
1261                         tempFiles.clear();
1262
1263                 browserWindow.noteSignal.tagsChanged.disconnect();
1264                 browserWindow.noteSignal.titleChanged.disconnect();
1265                 browserWindow.noteSignal.noteChanged.disconnect();
1266                 browserWindow.noteSignal.notebookChanged.disconnect();
1267                 browserWindow.noteSignal.createdDateChanged.disconnect();
1268                 browserWindow.noteSignal.alteredDateChanged.disconnect();
1269                 syncRunner.searchSignal.listChanged.disconnect();
1270                 syncRunner.tagSignal.listChanged.disconnect();
1271         syncRunner.notebookSignal.listChanged.disconnect();
1272         syncRunner.noteIndexSignal.listChanged.disconnect();
1273
1274                 if (isVisible())
1275                         Global.saveWindowVisible("toolBar", toolBar.isVisible());
1276                 saveNoteColumnPositions();
1277                 saveNoteIndexWidth();
1278
1279                 int width = notebookTree.columnWidth(0);
1280                 Global.setColumnWidth("notebookTreeName", width);
1281                 width = tagTree.columnWidth(0);
1282                 Global.setColumnWidth("tagTreeName", width);
1283
1284                 Global.saveWindowMaximized(isMaximized());
1285                 Global.saveCurrentNoteGuid(currentNoteGuid);
1286
1287                 int sortCol = noteTableView.proxyModel.sortColumn();
1288                 int sortOrder = noteTableView.proxyModel.sortOrder().value();
1289                 Global.setSortColumn(sortCol);
1290                 Global.setSortOrder(sortOrder);
1291
1292                 hide();
1293                 trayIcon.hide();
1294                 Global.keepRunning = false;
1295                 try {
1296                         logger.log(logger.MEDIUM, "Waiting for indexThread to stop");
1297                         if (indexRunner.thread().isAlive())
1298                                 indexRunner.thread().join(50);
1299                         if (!indexRunner.thread().isAlive())
1300                                 logger.log(logger.MEDIUM, "Index thread has stopped");
1301                         else {
1302                                 logger.log(logger.MEDIUM, "Index thread still running - interrupting");
1303                                 indexRunner.thread().interrupt();
1304                         }
1305                 } catch (InterruptedException e1) {
1306                         e1.printStackTrace();
1307                 }
1308
1309                 if (!syncRunner.thread().isAlive()) {
1310                         logger.log(logger.MEDIUM, "Waiting for syncThread to stop");
1311                         if (syncRunner.thread().isAlive()) {
1312                                 System.out.println(tr("Synchronizing.  Please be patient."));
1313                                 for(;syncRunner.thread().isAlive();) {
1314                                         try {
1315                                                 wait(10);
1316                                         } catch (InterruptedException e) {
1317                                                 e.printStackTrace();
1318                                         }
1319                                 }
1320                         }
1321                         logger.log(logger.MEDIUM, "Sync thread has stopped");
1322                 }
1323
1324                 if (encryptOnShutdown) {
1325                         encryptOnShutdown();
1326                 }
1327                 if (decryptOnShutdown) {
1328                         decryptOnShutdown();
1329                 }
1330                 try {
1331                         Global.getFileManager().purgeResDirectory(false);
1332                 } catch (InitializationException e) {
1333                         System.out.println(tr("Empty res directory purge failed"));
1334                         e.printStackTrace();
1335                 }
1336                 logger.log(logger.HIGH, "Leaving NeverNote.closeEvent");
1337         }
1338
1339
1340         private void closeNeverNote() {
1341                 closeAction = true;
1342                 close();
1343         }
1344         public void setMessage(String s) {
1345                 if (logger != null)
1346                         logger.log(logger.HIGH, "Entering NeverNote.setMessage");
1347                 else
1348                         System.out.println("*** ERROR *** " +s);
1349
1350                 if (statusBar != null) {
1351                         statusBar.show();
1352                         if (logger != null)
1353                                 logger.log(logger.HIGH, "Message: " +s);
1354                         statusBar.showMessage(s);
1355                         if (emitLog != null)
1356                                 emitLog.add(s);
1357
1358                         if (messageTimer != null) {
1359                                 messageTimer.stop();
1360                                 messageTimer.setSingleShot(true);
1361                                 messageTimer.start();
1362                         }
1363                 }
1364
1365                 if (logger != null)
1366                         logger.log(logger.HIGH, "Leaving NeverNote.setMessage");
1367         }
1368
1369         private void clearMessage() {
1370                 statusBar.clearMessage();
1371                 statusBar.hide();
1372         }
1373
1374         private void waitCursor(boolean wait) {
1375                 if (wait) {
1376                         if (QApplication.overrideCursor() == null)
1377                                 QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.WaitCursor));
1378                 }
1379                 else {
1380                         if (QApplication.overrideCursor() != null)
1381                                 QApplication.restoreOverrideCursor();
1382                         else
1383                                 QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.ArrowCursor));
1384                 }
1385                 listManager.refreshCounters();
1386         }
1387
1388         private void setupIndexListeners() {
1389 //              indexRunner.noteSignal.noteIndexed.connect(this, "indexThreadComplete(String)");
1390 //              indexRunner.resourceSignal.resourceIndexed.connect(this, "indexThreadComplete(String)");
1391                 indexRunner.signal.indexStarted.connect(this, "indexStarted()");
1392                 indexRunner.signal.indexFinished.connect(this, "indexComplete()");
1393         }
1394         private void setupSyncSignalListeners() {
1395                 syncRunner.tagSignal.listChanged.connect(this, "tagIndexUpdated()");
1396         syncRunner.searchSignal.listChanged.connect(this, "savedSearchIndexUpdated()");
1397         syncRunner.notebookSignal.listChanged.connect(this, "notebookIndexUpdated()");
1398         syncRunner.noteIndexSignal.listChanged.connect(this, "noteIndexUpdated(boolean)");
1399         syncRunner.noteSignal.quotaChanged.connect(this, "updateQuotaBar()");
1400
1401                 syncRunner.syncSignal.saveUploadAmount.connect(this,"saveUploadAmount(long)");
1402                 syncRunner.syncSignal.saveUserInformation.connect(this,"saveUserInformation(User)");
1403                 syncRunner.syncSignal.saveEvernoteUpdateCount.connect(this,"saveEvernoteUpdateCount(int)");
1404
1405                 syncRunner.noteSignal.guidChanged.connect(this, "noteGuidChanged(String, String)");
1406                 syncRunner.noteSignal.noteChanged.connect(this, "invalidateNoteCache(String, String)");
1407                 syncRunner.resourceSignal.resourceGuidChanged.connect(this, "noteResourceGuidChanged(String,String,String)");
1408                 syncRunner.noteSignal.noteDownloaded.connect(listManager, "noteDownloaded(Note)");
1409                 syncRunner.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
1410
1411                 syncRunner.syncSignal.refreshLists.connect(this, "refreshLists()");
1412         }
1413
1414         private void setupBrowserSignalListeners() {
1415                 setupBrowserWindowListeners(browserWindow, true);
1416         }
1417
1418         private void setupBrowserWindowListeners(BrowserWindow browser, boolean master) {
1419                 browser.fileWatcher.fileChanged.connect(this, "externalFileEdited(String)");
1420                 browser.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
1421             browser.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
1422             if (master) browser.noteSignal.noteChanged.connect(this, "setNoteDirty()");
1423             browser.noteSignal.titleChanged.connect(listManager, "updateNoteTitle(String, String)");
1424             browser.noteSignal.titleChanged.connect(this, "updateNoteTitle(String, String)");
1425             browser.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
1426             browser.noteSignal.createdDateChanged.connect(listManager, "updateNoteCreatedDate(String, QDateTime)");
1427             browser.noteSignal.alteredDateChanged.connect(listManager, "updateNoteAlteredDate(String, QDateTime)");
1428             browser.noteSignal.subjectDateChanged.connect(listManager, "updateNoteSubjectDate(String, QDateTime)");
1429             browser.noteSignal.authorChanged.connect(listManager, "updateNoteAuthor(String, String)");
1430             browser.noteSignal.geoChanged.connect(listManager, "updateNoteGeoTag(String, Double,Double,Double)");
1431             browser.noteSignal.geoChanged.connect(this, "setNoteDirty()");
1432             browser.noteSignal.sourceUrlChanged.connect(listManager, "updateNoteSourceUrl(String, String)");
1433         browser.blockApplication.connect(this, "blockApplication(BrowserWindow)");
1434         browser.unblockApplication.connect(this, "unblockApplication()");
1435             if (master) browser.focusLost.connect(this, "saveNote()");
1436             browser.resourceSignal.contentChanged.connect(this, "externalFileEdited(String)");
1437             browser.evernoteLinkClicked.connect(this, "evernoteLinkClick(String, String)");
1438         }
1439
1440         //**************************************************
1441         //* Setup shortcuts
1442         //**************************************************
1443         private void setupShortcut(QShortcut action, String text) {
1444                 if (!Global.shortcutKeys.containsAction(text))
1445                         return;
1446                 action.setKey(new QKeySequence(Global.shortcutKeys.getShortcut(text)));
1447         }
1448
1449         //***************************************************************
1450         //***************************************************************
1451         //* Settings and look & feel
1452         //***************************************************************
1453         //***************************************************************
1454         @SuppressWarnings("unused")
1455         private void settings() {
1456                 logger.log(logger.HIGH, "Entering NeverNote.settings");
1457
1458                 saveNoteColumnPositions();
1459                 saveNoteIndexWidth();
1460                 showColumns();
1461         ConfigDialog settings = new ConfigDialog(this);
1462         String dateFormat = Global.getDateFormat();
1463         String timeFormat = Global.getTimeFormat();
1464
1465                 indexTime = 1000*Global.getIndexThreadSleepInterval();
1466                 indexTimer.start(indexTime);  // reset indexing timer
1467
1468         settings.exec();
1469         indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
1470         indexRunner.indexNoteBody = Global.indexNoteBody();
1471         indexRunner.indexNoteTitle = Global.indexNoteTitle();
1472         indexRunner.specialIndexCharacters = Global.getSpecialIndexCharacters();
1473         indexRunner.indexImageRecognition = Global.indexImageRecognition();
1474         if (Global.showTrayIcon() || Global.minimizeOnClose())
1475                 trayIcon.show();
1476         else
1477                 trayIcon.hide();
1478         showColumns();
1479         if (menuBar.showEditorBar.isChecked()){
1480                 // ICHANGED
1481                 for(int i = 0; i < tabBrowser.count(); i++){
1482                         BrowserWindow browser = ((TabBrowse) tabBrowser.widget(i)).getBrowserWindow();
1483                         showEditorButtons(browser);
1484                 }
1485
1486         }
1487
1488         // Reset the save timer
1489         if (Global.getAutoSaveInterval() > 0)
1490                         saveTimer.setInterval(1000*60*Global.getAutoSaveInterval());
1491         else
1492                 saveTimer.stop();
1493
1494
1495         // Set special reloads
1496         if (settings.getDebugPage().reloadSharedNotebooksClicked()) {
1497                 conn.executeSql("Delete from LinkedNotebook");
1498                 conn.executeSql("delete from SharedNotebook");
1499                 conn.executeSql("Delete from Notebook where linked=true");
1500                 conn.executeSql("Insert into Sync (key, value) values ('FullLinkedNotebookSync', 'true')");
1501                 conn.executeSql("Insert into Sync (key, value) values ('FullSharedNotebookSync', 'true')");
1502         }
1503
1504         // Reload user data
1505         noteCache.clear();
1506         readOnlyCache.clear();
1507         inkNoteCache.clear();
1508         noteIndexUpdated(true);
1509
1510         logger.log(logger.HIGH, "Leaving NeverNote.settings");
1511         }
1512         // Restore things to the way they were
1513         private void restoreWindowState(boolean mainWindow) {
1514                 // We need to name things or this doesn't work.
1515                 setObjectName("NeverNote");
1516         restoreState(Global.restoreState(objectName()));
1517                 mainLeftRightSplitter.setObjectName("mainLeftRightSplitter");
1518                 browserIndexSplitter.setObjectName("browserIndexSplitter");
1519                 leftSplitter1.setObjectName("leftSplitter1");
1520                 // ICHANGED
1521                 rensoNoteListDock.setObjectName("rensoNoteListDock");
1522
1523                 // Restore the actual positions.
1524                 if (mainWindow)
1525                         restoreGeometry(Global.restoreGeometry(objectName()));
1526         mainLeftRightSplitter.restoreState(Global.restoreState(mainLeftRightSplitter.objectName()));
1527         browserIndexSplitter.restoreState(Global.restoreState(browserIndexSplitter.objectName()));
1528         leftSplitter1.restoreState(Global.restoreState(leftSplitter1.objectName()));
1529         // ICHANGED
1530         rensoNoteListDock.restoreGeometry(Global.restoreGeometry(rensoNoteListDock.objectName()));
1531
1532         }
1533         // Save window positions for the next start
1534         private void saveWindowState() {
1535                 Global.saveGeometry(objectName(), saveGeometry());
1536                 Global.saveState(mainLeftRightSplitter.objectName(), mainLeftRightSplitter.saveState());
1537                 Global.saveState(browserIndexSplitter.objectName(), browserIndexSplitter.saveState());
1538                 Global.saveState(leftSplitter1.objectName(), leftSplitter1.saveState());
1539                 Global.saveState(objectName(), saveState());
1540                 // ICHANGED
1541                 Global.saveGeometry(rensoNoteListDock.objectName(), rensoNoteListDock.saveGeometry());
1542         }
1543         // Load the style sheet
1544         private void loadStyleSheet() {
1545                 String styleSheetName = "default.qss";
1546                 if (Global.getStyle().equalsIgnoreCase("cleanlooks"))
1547                                 styleSheetName = "default-cleanlooks.qss";
1548                 String fileName = Global.getFileManager().getQssDirPathUser("default.qss");
1549                 QFile file = new QFile(fileName);
1550
1551                 // If a user default.qss doesn't exist, we use the one shipped with NeverNote
1552                 if (!file.exists()) {
1553                         fileName = Global.getFileManager().getQssDirPath(styleSheetName);
1554                         file = new QFile(fileName);
1555                 }
1556                 file.open(OpenModeFlag.ReadOnly);
1557                 String styleSheet = file.readAll().toString();
1558                 file.close();
1559                 setStyleSheet(styleSheet);
1560         }
1561         // Save column positions for the next time
1562         private void saveNoteColumnPositions() {
1563                 int position = noteTableView.header.visualIndex(Global.noteTableCreationPosition);
1564                 Global.setColumnPosition("noteTableCreationPosition", position);
1565                 position = noteTableView.header.visualIndex(Global.noteTableTagPosition);
1566                 Global.setColumnPosition("noteTableTagPosition", position);
1567                 position = noteTableView.header.visualIndex(Global.noteTableNotebookPosition);
1568                 Global.setColumnPosition("noteTableNotebookPosition", position);
1569                 position = noteTableView.header.visualIndex(Global.noteTableChangedPosition);
1570                 Global.setColumnPosition("noteTableChangedPosition", position);
1571                 position = noteTableView.header.visualIndex(Global.noteTableAuthorPosition);
1572                 Global.setColumnPosition("noteTableAuthorPosition", position);
1573                 position = noteTableView.header.visualIndex(Global.noteTableSourceUrlPosition);
1574                 Global.setColumnPosition("noteTableSourceUrlPosition", position);
1575                 position = noteTableView.header.visualIndex(Global.noteTableSubjectDatePosition);
1576                 Global.setColumnPosition("noteTableSubjectDatePosition", position);
1577                 position = noteTableView.header.visualIndex(Global.noteTableTitlePosition);
1578                 Global.setColumnPosition("noteTableTitlePosition", position);
1579                 position = noteTableView.header.visualIndex(Global.noteTableSynchronizedPosition);
1580                 Global.setColumnPosition("noteTableSynchronizedPosition", position);
1581                 position = noteTableView.header.visualIndex(Global.noteTableGuidPosition);
1582                 Global.setColumnPosition("noteTableGuidPosition", position);
1583                 position = noteTableView.header.visualIndex(Global.noteTableThumbnailPosition);
1584                 Global.setColumnPosition("noteTableThumbnailPosition", position);
1585                 position = noteTableView.header.visualIndex(Global.noteTablePinnedPosition);
1586                 Global.setColumnPosition("noteTablePinnedPosition", position);
1587
1588         }
1589         // Save column widths for the next time
1590         private void saveNoteIndexWidth() {
1591                 int width;
1592         width = noteTableView.getColumnWidth(Global.noteTableCreationPosition);
1593         Global.setColumnWidth("noteTableCreationPosition", width);
1594                 width = noteTableView.getColumnWidth(Global.noteTableChangedPosition);
1595                 Global.setColumnWidth("noteTableChangedPosition", width);
1596                 width = noteTableView.getColumnWidth(Global.noteTableGuidPosition);
1597                 Global.setColumnWidth("noteTableGuidPosition", width);
1598                 width = noteTableView.getColumnWidth(Global.noteTableNotebookPosition);
1599                 Global.setColumnWidth("noteTableNotebookPosition", width);
1600                 width = noteTableView.getColumnWidth(Global.noteTableTagPosition);
1601                 Global.setColumnWidth("noteTableTagPosition", width);
1602                 width = noteTableView.getColumnWidth(Global.noteTableTitlePosition);
1603                 Global.setColumnWidth("noteTableTitlePosition", width);
1604                 width = noteTableView.getColumnWidth(Global.noteTableSourceUrlPosition);
1605                 Global.setColumnWidth("noteTableSourceUrlPosition", width);
1606                 width = noteTableView.getColumnWidth(Global.noteTableAuthorPosition);
1607                 Global.setColumnWidth("noteTableAuthorPosition", width);
1608                 width = noteTableView.getColumnWidth(Global.noteTableSubjectDatePosition);
1609                 Global.setColumnWidth("noteTableSubjectDatePosition", width);
1610                 width = noteTableView.getColumnWidth(Global.noteTableSynchronizedPosition);
1611                 Global.setColumnWidth("noteTableSynchronizedPosition", width);
1612                 width = noteTableView.getColumnWidth(Global.noteTableThumbnailPosition);
1613                 Global.setColumnWidth("noteTableThumbnailPosition", width);
1614                 width = noteTableView.getColumnWidth(Global.noteTableGuidPosition);
1615                 Global.setColumnWidth("noteTableGuidPosition", width);
1616                 width = noteTableView.getColumnWidth(Global.noteTablePinnedPosition);
1617                 Global.setColumnWidth("noteTablePinnedPosition", width);
1618         }
1619
1620         @SuppressWarnings("unused")
1621         private void toggleSearchWindow() {
1622                 logger.log(logger.HIGH, "Entering NeverNote.toggleSearchWindow");
1623         searchLayout.toggleSearchField();
1624         menuBar.hideSearch.setChecked(searchField.isVisible());
1625         Global.saveWindowVisible("searchField", searchField.isVisible());
1626         logger.log(logger.HIGH, "Leaving NeverNote.toggleSearchWindow");
1627     }
1628         @SuppressWarnings("unused")
1629         private void toggleQuotaWindow() {
1630                 logger.log(logger.HIGH, "Entering NeverNote.toggleQuotaWindow");
1631         searchLayout.toggleQuotaBar();
1632         menuBar.hideQuota.setChecked(quotaBar.isVisible());
1633         Global.saveWindowVisible("quota", quotaBar.isVisible());
1634         logger.log(logger.HIGH, "Leaving NeverNote.toggleQuotaWindow");
1635     }
1636         @SuppressWarnings("unused")
1637         private void toggleZoomWindow() {
1638                 logger.log(logger.HIGH, "Entering NeverNote.toggleZoomWindow");
1639         searchLayout.toggleZoom();
1640         menuBar.hideZoom.setChecked(zoomSpinner.isVisible());
1641         Global.saveWindowVisible("zoom", zoomSpinner.isVisible());
1642         logger.log(logger.HIGH, "Leaving NeverNote.toggleZoomWindow");
1643     }
1644
1645
1646
1647     //***************************************************************
1648     //***************************************************************
1649     //** These functions deal with Notebook menu items
1650     //***************************************************************
1651     //***************************************************************
1652     // Setup the tree containing the user's notebooks.
1653     private void initializeNotebookTree() {
1654         logger.log(logger.HIGH, "Entering NeverNote.initializeNotebookTree");
1655 //      notebookTree.itemClicked.connect(this, "notebookTreeSelection()");
1656         notebookTree.selectionSignal.connect(this, "notebookTreeSelection()");
1657         listManager.notebookSignal.refreshNotebookTreeCounts.connect(notebookTree, "updateCounts(List, List)");
1658         logger.log(logger.HIGH, "Leaving NeverNote.initializeNotebookTree");
1659     }
1660     // Listener when a notebook is selected
1661         private void notebookTreeSelection() {
1662                 logger.log(logger.HIGH, "Entering NeverNote.notebookTreeSelection");
1663                 noteTableView.proxyModel.blocked = true;
1664
1665                 clearTrashFilter();
1666                 clearAttributeFilter();
1667                 clearSavedSearchFilter();
1668                 if (Global.mimicEvernoteInterface) {
1669                         clearTagFilter();
1670                         //searchField.clear();
1671                         searchField.clearEditText();
1672                 }
1673                 menuBar.noteRestoreAction.setVisible(false);
1674         menuBar.notebookEditAction.setEnabled(true);
1675         menuBar.notebookDeleteAction.setEnabled(true);
1676         menuBar.notebookPublishAction.setEnabled(true);
1677         menuBar.notebookShareAction.setEnabled(true);
1678         menuBar.notebookIconAction.setEnabled(true);
1679         menuBar.notebookStackAction.setEnabled(true);
1680
1681                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
1682                 if (!rensoNoteListDock.isEnabled()) {
1683                         rensoNoteListDock.setEnabled(true);
1684                 }
1685
1686         List<QTreeWidgetItem> selections = notebookTree.selectedItems();
1687         selectedNotebookGUIDs.clear();
1688                 String guid = "";
1689                 String stackName = "";
1690                 if (selections.size() > 0) {
1691                 guid = (selections.get(0).text(2));
1692                 stackName = selections.get(0).text(0);
1693         }
1694                 if (!Global.mimicEvernoteInterface) {
1695                         // If no notebooks are selected, we make it look like the "all notebooks" one was selected
1696                         if (selections.size()==0) {
1697                                 selectedNotebookGUIDs.clear();
1698                                 for (int i=0; i < listManager.getNotebookIndex().size(); i++) {
1699                                         selectedNotebookGUIDs.add(listManager.getNotebookIndex().get(i).getGuid());
1700                                 }
1701                                 menuBar.notebookEditAction.setEnabled(false);
1702                                 menuBar.notebookDeleteAction.setEnabled(false);
1703                                 menuBar.notebookStackAction.setEnabled(false);
1704                                 menuBar.notebookIconAction.setEnabled(false);
1705                         }
1706                 }
1707         if (!guid.equals("") && !guid.equals("STACK")) {
1708                 selectedNotebookGUIDs.add(guid);
1709                 menuBar.notebookIconAction.setEnabled(true);
1710         } else {
1711                 menuBar.notebookIconAction.setEnabled(true);
1712                         for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
1713                                 Notebook book = listManager.getNotebookIndex().get(j);
1714                                 if (book.getStack() != null && book.getStack().equalsIgnoreCase(stackName))
1715                                         selectedNotebookGUIDs.add(book.getGuid());
1716                         }
1717         }
1718         listManager.setSelectedNotebooks(selectedNotebookGUIDs);
1719         listManager.loadNotesIndex();
1720         noteIndexUpdated(false);
1721         refreshEvernoteNote(true);
1722         listManager.refreshCounters = true;
1723         listManager.refreshCounters();
1724         if (selectedNotebookGUIDs.size() == 1) {
1725                 int col = conn.getNotebookTable().getSortColumn(selectedNotebookGUIDs.get(0));
1726                 int order = conn.getNotebookTable().getSortOrder(selectedNotebookGUIDs.get(0));
1727                 if (col != -1) {
1728                         noteTableView.proxyModel.blocked = true;
1729                         if (order == 1)
1730                                 noteTableView.sortByColumn(col, Qt.SortOrder.DescendingOrder);
1731                         else
1732                                 noteTableView.sortByColumn(col, Qt.SortOrder.AscendingOrder);
1733                 }
1734         }
1735         noteTableView.proxyModel.blocked = false;
1736                 logger.log(logger.HIGH, "Leaving NeverNote.notebookTreeSelection");
1737
1738     }
1739     private void clearNotebookFilter() {
1740         notebookTree.blockSignals(true);
1741         notebookTree.clearSelection();
1742                 menuBar.noteRestoreAction.setVisible(false);
1743         menuBar.notebookEditAction.setEnabled(false);
1744         menuBar.notebookDeleteAction.setEnabled(false);
1745         selectedNotebookGUIDs.clear();
1746         listManager.setSelectedNotebooks(selectedNotebookGUIDs);
1747         notebookTree.blockSignals(false);
1748     }
1749         // Triggered when the notebook DB has been updated
1750         private void notebookIndexUpdated() {
1751                 logger.log(logger.HIGH, "Entering NeverNote.notebookIndexUpdated");
1752
1753                 // Get the possible icons
1754                 HashMap<String, QIcon> icons = conn.getNotebookTable().getAllIcons();
1755         notebookTree.setIcons(icons);
1756
1757         if (selectedNotebookGUIDs == null)
1758                         selectedNotebookGUIDs = new ArrayList<String>();
1759                 List<Notebook> books = conn.getNotebookTable().getAll();
1760                 for (int i=books.size()-1; i>=0; i--) {
1761                         for (int j=0; j<listManager.getArchiveNotebookIndex().size(); j++) {
1762                                 if (listManager.getArchiveNotebookIndex().get(j).getGuid().equals(books.get(i).getGuid())) {
1763                                         books.remove(i);
1764                                         j=listManager.getArchiveNotebookIndex().size();
1765                                 }
1766                         }
1767                 }
1768
1769
1770                 listManager.countNotebookResults(listManager.getNoteIndex());
1771                 notebookTree.blockSignals(true);
1772         notebookTree.load(books, listManager.getLocalNotebooks());
1773         for (int i=selectedNotebookGUIDs.size()-1; i>=0; i--) {
1774                 boolean found = notebookTree.selectGuid(selectedNotebookGUIDs.get(i));
1775                 if (!found)
1776                         selectedNotebookGUIDs.remove(i);
1777         }
1778         listManager.refreshCounters = true;
1779         listManager.refreshCounters();
1780         notebookTree.blockSignals(false);
1781
1782                 logger.log(logger.HIGH, "Leaving NeverNote.notebookIndexUpdated");
1783     }
1784     // Show/Hide note information
1785         @SuppressWarnings("unused")
1786         private void toggleNotebookWindow() {
1787                 logger.log(logger.HIGH, "Entering NeverNote.toggleNotebookWindow");
1788                 searchLayout.toggleNotebook();
1789         menuBar.hideNotebooks.setChecked(notebookTree.isVisible());
1790         Global.saveWindowVisible("notebookTree", notebookTree.isVisible());
1791         logger.log(logger.HIGH, "Leaving NeverNote.toggleNotebookWindow");
1792     }
1793         // Add a new notebook
1794         @SuppressWarnings("unused")
1795         private void addNotebook() {
1796                 logger.log(logger.HIGH, "Inside NeverNote.addNotebook");
1797                 NotebookEdit edit = new NotebookEdit();
1798                 edit.setNotebooks(listManager.getNotebookIndex());
1799                 edit.exec();
1800
1801                 if (!edit.okPressed())
1802                         return;
1803
1804                 Calendar currentTime = new GregorianCalendar();
1805                 Long l = new Long(currentTime.getTimeInMillis());
1806                 String randint = new String(Long.toString(l));
1807
1808                 Notebook newBook = new Notebook();
1809                 newBook.setUpdateSequenceNum(0);
1810                 newBook.setGuid(randint);
1811                 newBook.setName(edit.getNotebook());
1812                 newBook.setServiceCreated(new Date().getTime());
1813                 newBook.setServiceUpdated(new Date().getTime());
1814                 newBook.setDefaultNotebook(false);
1815                 newBook.setPublished(false);
1816
1817                 listManager.getNotebookIndex().add(newBook);
1818                 if (edit.isLocal())
1819                         listManager.getLocalNotebooks().add(newBook.getGuid());
1820                 conn.getNotebookTable().addNotebook(newBook, true, edit.isLocal());
1821                 notebookIndexUpdated();
1822                 listManager.countNotebookResults(listManager.getNoteIndex());
1823 //              notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
1824                 logger.log(logger.HIGH, "Leaving NeverNote.addNotebook");
1825         }
1826         // Edit an existing notebook
1827         @SuppressWarnings("unused")
1828         private void stackNotebook() {
1829                 logger.log(logger.HIGH, "Entering NeverNote.stackNotebook");
1830                 StackNotebook edit = new StackNotebook();
1831
1832                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
1833                 QTreeWidgetItem currentSelection;
1834                 for (int i=0; i<selections.size(); i++) {
1835                         currentSelection = selections.get(0);
1836                         String guid = currentSelection.text(2);
1837                         if (guid.equalsIgnoreCase("")) {
1838                                  QMessageBox.critical(this, tr("Unable To Stack") ,tr("You can't stack the \"All Notebooks\" item."));
1839                                  return;
1840                         }
1841                         if (guid.equalsIgnoreCase("STACK")) {
1842                                  QMessageBox.critical(this, tr("Unable To Stack") ,tr("You can't stack a stack."));
1843                                  return;
1844                         }
1845                 }
1846
1847                 edit.setStackNames(conn.getNotebookTable().getAllStackNames());
1848
1849
1850                 edit.exec();
1851
1852                 if (!edit.okPressed())
1853                         return;
1854
1855                 String stack = edit.getStackName();
1856
1857                 for (int i=0; i<selections.size(); i++) {
1858                         currentSelection = selections.get(i);
1859                         String guid = currentSelection.text(2);
1860                         listManager.updateNotebookStack(guid, stack);
1861                 }
1862                 notebookIndexUpdated();
1863                 logger.log(logger.HIGH, "Leaving NeverNote.stackNotebook");
1864         }
1865         // Edit an existing notebook
1866         @SuppressWarnings("unused")
1867         private void editNotebook() {
1868                 logger.log(logger.HIGH, "Entering NeverNote.editNotebook");
1869                 NotebookEdit edit = new NotebookEdit();
1870
1871                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
1872                 QTreeWidgetItem currentSelection;
1873                 currentSelection = selections.get(0);
1874                 edit.setNotebook(currentSelection.text(0));
1875
1876                 String guid = currentSelection.text(2);
1877                 if (!guid.equalsIgnoreCase("STACK")) {
1878                         edit.setTitle(tr("Edit Notebook"));
1879                         edit.setNotebooks(listManager.getNotebookIndex());
1880                         edit.setLocalCheckboxEnabled(false);
1881                         for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
1882                                 if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
1883                                         edit.setDefaultNotebook(listManager.getNotebookIndex().get(i).isDefaultNotebook());
1884                                         i=listManager.getNotebookIndex().size();
1885                                 }
1886                         }
1887                 } else {
1888                         edit.setTitle(tr("Edit Stack"));
1889                         edit.setStacks(conn.getNotebookTable().getAllStackNames());
1890                         edit.hideLocalCheckbox();
1891                         edit.hideDefaultCheckbox();
1892                 }
1893
1894                 edit.exec();
1895
1896                 if (!edit.okPressed())
1897                         return;
1898
1899
1900                 if (guid.equalsIgnoreCase("STACK")) {
1901                         conn.getNotebookTable().renameStacks(currentSelection.text(0), edit.getNotebook());
1902                         for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
1903                                 if (listManager.getNotebookIndex().get(j).getStack() != null &&
1904                                         listManager.getNotebookIndex().get(j).getStack().equalsIgnoreCase(currentSelection.text(0)))
1905                                                 listManager.getNotebookIndex().get(j).setStack(edit.getNotebook());
1906                         }
1907                         conn.getNotebookTable().renameStacks(currentSelection.text(0), edit.getNotebook());
1908                         currentSelection.setText(0, edit.getNotebook());
1909                         return;
1910                 }
1911
1912                 updateListNotebookName(currentSelection.text(0), edit.getNotebook());
1913                 currentSelection.setText(0, edit.getNotebook());
1914
1915                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
1916                         if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
1917                                 listManager.getNotebookIndex().get(i).setName(edit.getNotebook());
1918                                 if (!listManager.getNotebookIndex().get(i).isDefaultNotebook() && edit.isDefaultNotebook()) {
1919                                         for (int j=0; j<listManager.getNotebookIndex().size(); j++)
1920                                                 listManager.getNotebookIndex().get(j).setDefaultNotebook(false);
1921                                         listManager.getNotebookIndex().get(i).setDefaultNotebook(true);
1922                                         conn.getNotebookTable().setDefaultNotebook(listManager.getNotebookIndex().get(i).getGuid());
1923                                 }
1924                                 conn.getNotebookTable().updateNotebook(listManager.getNotebookIndex().get(i), true);
1925                                 if (conn.getNotebookTable().isLinked(listManager.getNotebookIndex().get(i).getGuid())) {
1926                                         LinkedNotebook linkedNotebook = conn.getLinkedNotebookTable().getByNotebookGuid(listManager.getNotebookIndex().get(i).getGuid());
1927                                         linkedNotebook.setShareName(edit.getNotebook());
1928                                         conn.getLinkedNotebookTable().updateNotebook(linkedNotebook, true);
1929                                 }
1930                                 i=listManager.getNotebookIndex().size();
1931                         }
1932                 }
1933
1934                 // Build a list of non-closed notebooks
1935                 List<Notebook> nbooks = new ArrayList<Notebook>();
1936                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
1937                         boolean found=false;
1938                         for (int j=0; j<listManager.getArchiveNotebookIndex().size(); j++) {
1939                                 if (listManager.getArchiveNotebookIndex().get(j).getGuid().equals(listManager.getNotebookIndex().get(i).getGuid()))
1940                                         found = true;
1941                         }
1942                         if (!found)
1943                                 nbooks.add(listManager.getNotebookIndex().get(i));
1944                 }
1945
1946
1947                 FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
1948                 List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
1949                 browserWindow.setNotebookList(filteredBooks);
1950                 Iterator<String> set = externalWindows.keySet().iterator();
1951                 while(set.hasNext())
1952                         externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
1953
1954                 // ICHANGED
1955                 Iterator<Integer>it = tabWindows.keySet().iterator();
1956                 while (it.hasNext()) {
1957                         tabWindows.get(it.next()).getBrowserWindow()
1958                                         .setNotebookList(filteredBooks);
1959                 }
1960
1961                 logger.log(logger.HIGH, "Leaving NeverNote.editNotebook");
1962         }
1963         // Publish a notebook
1964         @SuppressWarnings("unused")
1965         private void publishNotebook() {
1966                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
1967                 QTreeWidgetItem currentSelection;
1968                 currentSelection = selections.get(0);
1969                 String guid = currentSelection.text(2);
1970
1971                 if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
1972                         return;
1973
1974                 Notebook n = null;
1975                 int position = 0;
1976                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
1977                         if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
1978                                 n = listManager.getNotebookIndex().get(i);
1979                                 position = i;
1980                                 i = listManager.getNotebookIndex().size();
1981                         }
1982                 }
1983                 if (n == null)
1984                         return;
1985
1986                 PublishNotebook publish = new PublishNotebook(Global.username, Global.getServer(), n);
1987                 publish.exec();
1988
1989                 if (!publish.okClicked())
1990                         return;
1991
1992                 Publishing p = publish.getPublishing();
1993                 boolean isPublished = !publish.isStopPressed();
1994                 conn.getNotebookTable().setPublishing(n.getGuid(), isPublished, p);
1995                 n.setPublished(isPublished);
1996                 n.setPublishing(p);
1997                 listManager.getNotebookIndex().set(position, n);
1998                 notebookIndexUpdated();
1999         }
2000         // Publish a notebook
2001         @SuppressWarnings("unused")
2002         private void shareNotebook() {
2003                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
2004                 QTreeWidgetItem currentSelection;
2005                 currentSelection = selections.get(0);
2006                 String guid = currentSelection.text(2);
2007
2008                 if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
2009                         return;
2010
2011                 Notebook n = null;;
2012                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
2013                         if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
2014                                 n = listManager.getNotebookIndex().get(i);
2015                                 i = listManager.getNotebookIndex().size();
2016                         }
2017                 }
2018
2019                 String authToken = null;
2020                 if (syncRunner.isConnected)
2021                         authToken = syncRunner.authToken;
2022                 ShareNotebook share = new ShareNotebook(n.getName(), conn, n, syncRunner);
2023                 share.exec();
2024
2025         }
2026
2027         // Delete an existing notebook
2028         @SuppressWarnings("unused")
2029         private void deleteNotebook() {
2030                 logger.log(logger.HIGH, "Entering NeverNote.deleteNotebook");
2031                 boolean stacksFound = false;
2032                 boolean notebooksFound = false;
2033                 boolean assigned = false;
2034                 // Check if any notes have this notebook
2035                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
2036         for (int i=0; i<selections.size(); i++) {
2037                 QTreeWidgetItem currentSelection;
2038                 currentSelection = selections.get(i);
2039                 String guid = currentSelection.text(2);
2040                 if (!guid.equalsIgnoreCase("STACK")) {
2041                         notebooksFound = true;
2042                         for (int j=0; j<listManager.getNoteIndex().size(); j++) {
2043                                 String noteGuid = listManager.getNoteIndex().get(j).getNotebookGuid();
2044                                 if (noteGuid.equals(guid)) {
2045                                         assigned = true;
2046                                         j=listManager.getNoteIndex().size();
2047                                         i=selections.size();
2048                                 }
2049                         }
2050                 } else {
2051                         stacksFound = true;
2052                 }
2053         }
2054                 if (assigned) {
2055                         QMessageBox.information(this, tr("Unable to Delete"), tr("Some of the selected notebook(s) contain notes.\n"+
2056                                         "Please delete the notes or move them to another notebook before deleting any notebooks."));
2057                         return;
2058                 }
2059
2060                 if (conn.getNotebookTable().getAll().size() == 1) {
2061                         QMessageBox.information(this, tr("Unable to Delete"), tr("You must have at least one notebook."));
2062                         return;
2063                 }
2064
2065         // If all notebooks are clear, verify the delete
2066                 String msg1 = new String(tr("Delete selected notebooks?"));
2067                 String msg2 = new String(tr("Remove selected stacks (notebooks will not be deleted)?"));
2068                 String msg3 = new String(tr("Delete selected notebooks & remove stacks? Notebooks under the stacks are" +
2069                                 " not deleted unless selected?"));
2070                 String msg = "";
2071                 if (stacksFound && notebooksFound)
2072                         msg = msg3;
2073                 if (!stacksFound && notebooksFound)
2074                         msg = msg1;
2075                 if (stacksFound && !notebooksFound)
2076                         msg = msg2;
2077                 if (QMessageBox.question(this, tr("Confirmation"), msg,
2078                         QMessageBox.StandardButton.Yes,
2079                         QMessageBox.StandardButton.No)==StandardButton.No.value()) {
2080                         return;
2081                 }
2082
2083                 // If confirmed, delete the notebook
2084         for (int i=selections.size()-1; i>=0; i--) {
2085                 QTreeWidgetItem currentSelection;
2086                 currentSelection = selections.get(i);
2087                 String guid = currentSelection.text(2);
2088                 if (currentSelection.text(2).equalsIgnoreCase("STACK")) {
2089                         conn.getNotebookTable().renameStacks(currentSelection.text(0), "");
2090                         listManager.renameStack(currentSelection.text(0), "");
2091                 } else {
2092                         conn.getNotebookTable().expungeNotebook(guid, true);
2093                         listManager.deleteNotebook(guid);
2094                 }
2095         }
2096
2097                 notebookIndexUpdated();
2098 //        notebookTreeSelection();
2099 //        notebookTree.load(listManager.getNotebookIndex(), listManager.getLocalNotebooks());
2100 //        listManager.countNotebookResults(listManager.getNoteIndex());
2101         logger.log(logger.HIGH, "Entering NeverNote.deleteNotebook");
2102         }
2103         // A note's notebook has been updated
2104         @SuppressWarnings("unused")
2105         private void updateNoteNotebook(String guid, String notebookGuid) {
2106                 // ICHANGED 同じノートブックに入れられたノート間の履歴を登録
2107                 conn.getHistoryTable().addSameNotebookHistory(guid, notebookGuid);
2108
2109                 // Update the list manager
2110                 listManager.updateNoteNotebook(guid, notebookGuid);
2111                 listManager.countNotebookResults(listManager.getNoteIndex());
2112 //              notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
2113
2114                 // Find the name of the notebook
2115                 String notebookName = null;
2116                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
2117                         if (listManager.getNotebookIndex().get(i).getGuid().equals(notebookGuid)) {
2118                                 notebookName = listManager.getNotebookIndex().get(i).getName();
2119                                 break;
2120                         }
2121                 }
2122
2123                 // If we found the name, update the browser window
2124                 if (notebookName != null) {
2125                         updateListNoteNotebook(guid, notebookName);
2126                         if (guid.equals(currentNoteGuid)) {
2127                                 int pos =  browserWindow.notebookBox.findText(notebookName);
2128                                 if (pos >=0)
2129                                         browserWindow.notebookBox.setCurrentIndex(pos);
2130                         }
2131                 }
2132
2133                 // If we're dealing with the current note, then we need to be sure and update the notebook there
2134                 if (guid.equals(currentNoteGuid)) {
2135                         if (currentNote != null) {
2136                                 currentNote.setNotebookGuid(notebookGuid);
2137                         }
2138                 }
2139         }
2140         // Open/close notebooks
2141         @SuppressWarnings("unused")
2142         private void closeNotebooks() {
2143                 NotebookArchive na = new NotebookArchive(listManager.getNotebookIndex(), listManager.getArchiveNotebookIndex());
2144                 na.exec();
2145                 if (!na.okClicked())
2146                         return;
2147
2148                 waitCursor(true);
2149                 listManager.getArchiveNotebookIndex().clear();
2150
2151                 for (int i=na.getClosedBookList().count()-1; i>=0; i--) {
2152                         String text = na.getClosedBookList().takeItem(i).text();
2153                         for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
2154                                 if (listManager.getNotebookIndex().get(j).getName().equalsIgnoreCase(text)) {
2155                                         Notebook n = listManager.getNotebookIndex().get(j);
2156                                         conn.getNotebookTable().setArchived(n.getGuid(),true);
2157                                         listManager.getArchiveNotebookIndex().add(n);
2158                                         j=listManager.getNotebookIndex().size();
2159                                 }
2160                         }
2161                 }
2162
2163                 for (int i=na.getOpenBookList().count()-1; i>=0; i--) {
2164                         String text = na.getOpenBookList().takeItem(i).text();
2165                         for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
2166                                 if (listManager.getNotebookIndex().get(j).getName().equalsIgnoreCase(text)) {
2167                                         Notebook n = listManager.getNotebookIndex().get(j);
2168                                         conn.getNotebookTable().setArchived(n.getGuid(),false);
2169                                         j=listManager.getNotebookIndex().size();
2170                                 }
2171                         }
2172                 }
2173                 notebookTreeSelection();
2174                 listManager.loadNotesIndex();
2175                 notebookIndexUpdated();
2176                 noteIndexUpdated(false);
2177                 reloadTagTree(true);
2178 //              noteIndexUpdated(false);
2179
2180                 // Build a list of non-closed notebooks
2181                 List<Notebook> nbooks = new ArrayList<Notebook>();
2182                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
2183                         boolean found=false;
2184                         for (int j=0; j<listManager.getArchiveNotebookIndex().size(); j++) {
2185                                 if (listManager.getArchiveNotebookIndex().get(j).getGuid().equals(listManager.getNotebookIndex().get(i).getGuid()))
2186                                         found = true;
2187                         }
2188                         if (!found)
2189                                 nbooks.add(listManager.getNotebookIndex().get(i));
2190                 }
2191
2192                 FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
2193                 List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
2194                 browserWindow.setNotebookList(filteredBooks);
2195
2196                 // Update any external windows
2197                 Iterator<String> set = externalWindows.keySet().iterator();
2198                 while(set.hasNext())
2199                         externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
2200
2201                 // ICHANGED
2202                 // 全てのタブウィンドウを更新
2203                 Iterator<Integer> it = tabWindows.keySet().iterator();
2204                 while (it.hasNext()) {
2205                         tabWindows.get(it.next()).getBrowserWindow()
2206                                         .setNotebookList(filteredBooks);
2207                 }
2208
2209                 waitCursor(false);
2210         }
2211         // Change the notebook's icon
2212         @SuppressWarnings("unused")
2213         private void setNotebookIcon() {
2214                 boolean stackSelected = false;
2215                 boolean allNotebookSelected = false;
2216
2217                 QTreeWidgetItem currentSelection;
2218                 List<QTreeWidgetItem> selections = notebookTree.selectedItems();
2219                 if (selections.size() == 0)
2220                         return;
2221
2222                 currentSelection = selections.get(0);
2223                 String guid = currentSelection.text(2);
2224                 if (guid.equalsIgnoreCase(""))
2225                         allNotebookSelected = true;
2226                 if (guid.equalsIgnoreCase("STACK"))
2227                         stackSelected = true;
2228
2229                 QIcon currentIcon = currentSelection.icon(0);
2230                 QIcon icon;
2231                 SetIcon dialog;
2232
2233                 if (!stackSelected && !allNotebookSelected) {
2234                         icon = conn.getNotebookTable().getIcon(guid);
2235                         if (icon == null) {
2236                                 dialog = new SetIcon(currentIcon, saveLastPath);
2237                                 dialog.setUseDefaultIcon(true);
2238                         } else {
2239                                 dialog = new SetIcon(icon, saveLastPath);
2240                                 dialog.setUseDefaultIcon(false);
2241                         }
2242                 } else {
2243                         if (stackSelected) {
2244                                 icon = conn.getSystemIconTable().getIcon(currentSelection.text(0), "STACK");
2245                         } else {
2246                                 icon = conn.getSystemIconTable().getIcon(currentSelection.text(0), "ALLNOTEBOOK");
2247                         }
2248                         if (icon == null) {
2249                                 dialog = new SetIcon(currentIcon, saveLastPath);
2250                                 dialog.setUseDefaultIcon(true);
2251                         } else {
2252                                 dialog = new SetIcon(icon, saveLastPath);
2253                                 dialog.setUseDefaultIcon(false);
2254                         }
2255                 }
2256                 dialog.exec();
2257                 if (dialog.okPressed()) {
2258                 saveLastPath = dialog.getPath();
2259
2260                         QIcon newIcon = dialog.getIcon();
2261                         if (stackSelected) {
2262                                 conn.getSystemIconTable().setIcon(currentSelection.text(0), "STACK", newIcon, dialog.getFileType());
2263                                 if (newIcon == null) {
2264                                         newIcon = new QIcon(iconPath+"books2.png");
2265                                 }
2266                                 currentSelection.setIcon(0,newIcon);
2267                                 return;
2268                         }
2269                         if (allNotebookSelected) {
2270                                 conn.getSystemIconTable().setIcon(currentSelection.text(0), "ALLNOTEBOOK", newIcon, dialog.getFileType());
2271                                 if (newIcon == null) {
2272                                         newIcon = new QIcon(iconPath+"notebook-green.png");
2273                                 }
2274                                 currentSelection.setIcon(0,newIcon);
2275                                 return;
2276                         }
2277                         conn.getNotebookTable().setIcon(guid, newIcon, dialog.getFileType());
2278                         if (newIcon == null) {
2279                                 boolean isPublished = false;;
2280                                 boolean found = false;
2281                                 for (int i=0; i<listManager.getNotebookIndex().size() && !found; i++) {
2282                                         if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
2283                                                 isPublished = listManager.getNotebookIndex().get(i).isPublished();
2284                                                 found = true;
2285                                         }
2286                                 }
2287                                 newIcon = notebookTree.findDefaultIcon(guid, currentSelection.text(1), listManager.getLocalNotebooks(), isPublished);
2288                         }
2289                         currentSelection.setIcon(0, newIcon);
2290                 }
2291
2292         }
2293
2294
2295     //***************************************************************
2296     //***************************************************************
2297     //** These functions deal with Tag menu items
2298     //***************************************************************
2299     //***************************************************************
2300         // Add a new notebook
2301         @SuppressWarnings("unused")
2302         private void addTag() {
2303                 logger.log(logger.HIGH, "Inside NeverNote.addTag");
2304                 TagEdit edit = new TagEdit();
2305                 edit.setTagList(listManager.getTagIndex());
2306
2307                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
2308                 QTreeWidgetItem currentSelection = null;
2309                 if (selections.size() > 0) {
2310                         currentSelection = selections.get(0);
2311                         edit.setParentTag(currentSelection.text(0));
2312                 }
2313
2314                 edit.exec();
2315
2316                 if (!edit.okPressed())
2317                         return;
2318
2319                 Calendar currentTime = new GregorianCalendar();
2320                 Long l = new Long(currentTime.getTimeInMillis());
2321                 String randint = new String(Long.toString(l));
2322
2323                 Tag newTag = new Tag();
2324                 newTag.setUpdateSequenceNum(0);
2325                 newTag.setGuid(randint);
2326                 newTag.setName(edit.getTag());
2327                 if (edit.getParentTag().isChecked()) {
2328                         newTag.setParentGuid(currentSelection.text(2));
2329                         newTag.setParentGuidIsSet(true);
2330                         currentSelection.setExpanded(true);
2331                 }
2332                 conn.getTagTable().addTag(newTag, true);
2333                 listManager.getTagIndex().add(newTag);
2334                 reloadTagTree(true);
2335
2336                 logger.log(logger.HIGH, "Leaving NeverNote.addTag");
2337         }
2338         @SuppressWarnings("unused")
2339         private void reloadTagTree() {
2340                 reloadTagTree(false);
2341         }
2342         private void reloadTagTree(boolean reload) {
2343                 logger.log(logger.HIGH, "Entering NeverNote.reloadTagTree");
2344                 tagIndexUpdated(reload);
2345                 boolean filter = false;
2346                 if (reload)
2347                         listManager.countTagResults(listManager.getNoteIndex());
2348                 if (notebookTree.selectedItems().size() > 0
2349                                                   && !notebookTree.selectedItems().get(0).text(0).equalsIgnoreCase("All Notebooks"))
2350                                                   filter = true;
2351                 if (tagTree.selectedItems().size() > 0)
2352                         filter = true;
2353                 tagTree.showAllTags(!filter);
2354                 tagIndexUpdated(false);
2355                 logger.log(logger.HIGH, "Leaving NeverNote.reloadTagTree");
2356         }
2357         // Edit an existing tag
2358         @SuppressWarnings("unused")
2359         private void editTag() {
2360                 logger.log(logger.HIGH, "Entering NeverNote.editTag");
2361                 TagEdit edit = new TagEdit();
2362                 edit.setTitle("Edit Tag");
2363                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
2364                 QTreeWidgetItem currentSelection;
2365                 currentSelection = selections.get(0);
2366                 edit.setTag(currentSelection.text(0));
2367                 edit.setTagList(listManager.getTagIndex());
2368                 edit.exec();
2369
2370                 if (!edit.okPressed())
2371                         return;
2372
2373                 String guid = currentSelection.text(2);
2374                 currentSelection.setText(0,edit.getTag());
2375
2376                 for (int i=0; i<listManager.getTagIndex().size(); i++) {
2377                         if (listManager.getTagIndex().get(i).getGuid().equals(guid)) {
2378                                 listManager.getTagIndex().get(i).setName(edit.getTag());
2379                                 conn.getTagTable().updateTag(listManager.getTagIndex().get(i), true);
2380                                 updateListTagName(guid);
2381                                 if (currentNote != null && currentNote.getTagGuids().contains(guid))
2382                                         browserWindow.setTag(getTagNamesForNote(currentNote));
2383                                 logger.log(logger.HIGH, "Leaving NeverNote.editTag");
2384                                 //return;
2385                         }
2386                 }
2387                 listManager.reloadNoteTagNames(guid, edit.getTag());
2388                 noteIndexUpdated(true);
2389                 refreshEvernoteNote(true);
2390                 browserWindow.setTag(getTagNamesForNote(currentNote));
2391                 logger.log(logger.HIGH, "Leaving NeverNote.editTag...");
2392         }
2393         // Delete an existing tag
2394         @SuppressWarnings("unused")
2395         private void deleteTag() {
2396                 logger.log(logger.HIGH, "Entering NeverNote.deleteTag");
2397
2398                 if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected tags?"),
2399                         QMessageBox.StandardButton.Yes,
2400                         QMessageBox.StandardButton.No)==StandardButton.No.value()) {
2401                                                         return;
2402                 }
2403
2404                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
2405         for (int i=selections.size()-1; i>=0; i--) {
2406                 QTreeWidgetItem currentSelection;
2407                 currentSelection = selections.get(i);
2408                 removeTagItem(currentSelection.text(2));
2409         }
2410         tagIndexUpdated(true);
2411         tagTreeSelection();
2412         listManager.countTagResults(listManager.getNoteIndex());
2413 //              tagTree.updateCounts(listManager.getTagCounter());
2414         logger.log(logger.HIGH, "Leaving NeverNote.deleteTag");
2415         }
2416         // Remove a tag tree item.  Go recursively down & remove the children too
2417         private void removeTagItem(String guid) {
2418         for (int j=listManager.getTagIndex().size()-1; j>=0; j--) {
2419                 String parent = listManager.getTagIndex().get(j).getParentGuid();
2420                 if (parent != null && parent.equals(guid)) {
2421                         //Remove this tag's children
2422                         removeTagItem(listManager.getTagIndex().get(j).getGuid());
2423                 }
2424         }
2425         //Now, remove this tag
2426         removeListTagName(guid);
2427         conn.getTagTable().expungeTag(guid, true);
2428         for (int a=0; a<listManager.getTagIndex().size(); a++) {
2429                 if (listManager.getTagIndex().get(a).getGuid().equals(guid)) {
2430                         listManager.getTagIndex().remove(a);
2431                         return;
2432                 }
2433         }
2434         }
2435         // Setup the tree containing the user's tags
2436     private void initializeTagTree() {
2437         logger.log(logger.HIGH, "Entering NeverNote.initializeTagTree");
2438 //      tagTree.itemSelectionChanged.connect(this, "tagTreeSelection()");
2439 //      tagTree.itemClicked.connect(this, "tagTreeSelection()");
2440         tagTree.selectionSignal.connect(this, "tagTreeSelection()");
2441         listManager.tagSignal.refreshTagTreeCounts.connect(tagTree, "updateCounts(List)");
2442         logger.log(logger.HIGH, "Leaving NeverNote.initializeTagTree");
2443     }
2444     // Listener when a tag is selected
2445         private void tagTreeSelection() {
2446         logger.log(logger.HIGH, "Entering NeverNote.tagTreeSelection");
2447
2448         clearTrashFilter();
2449         clearAttributeFilter();
2450         clearSavedSearchFilter();
2451
2452                 menuBar.noteRestoreAction.setVisible(false);
2453
2454                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
2455                 if (!rensoNoteListDock.isEnabled()) {
2456                         rensoNoteListDock.setEnabled(true);
2457                 }
2458
2459         List<QTreeWidgetItem> selections = tagTree.selectedItems();
2460         QTreeWidgetItem currentSelection;
2461         selectedTagGUIDs.clear();
2462         for (int i=0; i<selections.size(); i++) {
2463                 currentSelection = selections.get(i);
2464                 selectedTagGUIDs.add(currentSelection.text(2));
2465         }
2466         if (selections.size() > 0) {
2467                 menuBar.tagEditAction.setEnabled(true);
2468                 menuBar.tagDeleteAction.setEnabled(true);
2469                 menuBar.tagIconAction.setEnabled(true);
2470         }
2471         else {
2472                 menuBar.tagEditAction.setEnabled(false);
2473                 menuBar.tagDeleteAction.setEnabled(false);
2474                 menuBar.tagIconAction.setEnabled(true);
2475         }
2476         if (selections.size() > 1)
2477                 menuBar.tagMergeAction.setEnabled(true);
2478         else
2479                 menuBar.tagMergeAction.setEnabled(false);
2480         listManager.setSelectedTags(selectedTagGUIDs);
2481         listManager.loadNotesIndex();
2482         noteIndexUpdated(false);
2483         refreshEvernoteNote(true);
2484         listManager.refreshCounters = true;
2485         listManager.refreshCounters();
2486         logger.log(logger.HIGH, "Leaving NeverNote.tagTreeSelection");
2487     }
2488     // trigger the tag index to be refreshed
2489     @SuppressWarnings("unused")
2490         private void tagIndexUpdated() {
2491         tagIndexUpdated(true);
2492     }
2493     private void tagIndexUpdated(boolean reload) {
2494         logger.log(logger.HIGH, "Entering NeverNote.tagIndexUpdated");
2495                 if (selectedTagGUIDs == null)
2496                         selectedTagGUIDs = new ArrayList<String>();
2497                 if (reload)
2498                         listManager.reloadTagIndex();
2499
2500                 tagTree.blockSignals(true);
2501                 if (reload) {
2502                         tagTree.setIcons(conn.getTagTable().getAllIcons());
2503                         tagTree.load(listManager.getTagIndex());
2504                 }
2505
2506         for (int i=selectedTagGUIDs.size()-1; i>=0; i--) {
2507                 boolean found = tagTree.selectGuid(selectedTagGUIDs.get(i));
2508                 if (!found)
2509                         selectedTagGUIDs.remove(i);
2510         }
2511         tagTree.blockSignals(false);
2512
2513                 browserWindow.setTag(getTagNamesForNote(currentNote));
2514         logger.log(logger.HIGH, "Leaving NeverNote.tagIndexUpdated");
2515     }
2516     // Show/Hide note information
2517         @SuppressWarnings("unused")
2518         private void toggleTagWindow() {
2519                 logger.log(logger.HIGH, "Entering NeverNote.toggleTagWindow");
2520         if (tagTree.isVisible())
2521                 tagTree.hide();
2522         else
2523                 tagTree.show();
2524         menuBar.hideTags.setChecked(tagTree.isVisible());
2525         Global.saveWindowVisible("tagTree", tagTree.isVisible());
2526         logger.log(logger.HIGH, "Leaving NeverNote.toggleTagWindow");
2527     }
2528         // A note's tags have been updated
2529         @SuppressWarnings("unused")
2530         private void updateNoteTags(String guid, List<String> tags) {
2531                 // Save any new tags.  We'll need them later.
2532                 List<String> newTags = new ArrayList<String>();
2533                 for (int i=0; i<tags.size(); i++) {
2534                         if (conn.getTagTable().findTagByName(tags.get(i))==null)
2535                                 newTags.add(tags.get(i));
2536                 }
2537
2538                 listManager.saveNoteTags(guid, tags, true);
2539                 listManager.countTagResults(listManager.getNoteIndex());
2540                 StringBuffer names = new StringBuffer("");
2541                 for (int i=0; i<tags.size(); i++) {
2542                         names = names.append(tags.get(i));
2543                         if (i<tags.size()-1) {
2544                                 names.append(Global.tagDelimeter + " ");
2545                         }
2546                 }
2547                 browserWindow.setTag(names.toString());
2548
2549                 // ICHANGED
2550                 for (TabBrowse tab: tabWindows.values()) {
2551                         if (tab.getBrowserWindow().getNote().getGuid().equals(guid)) {
2552                                 int index = tabBrowser.indexOf(tab);
2553                                 noteDirty.put(index, true);
2554                                 break;
2555                         }
2556                 }
2557
2558                 // Now, we need to add any new tags to the tag tree
2559                 for (int i=0; i<newTags.size(); i++)
2560                         tagTree.insertTag(newTags.get(i), conn.getTagTable().findTagByName(newTags.get(i)));
2561         }
2562         // Get a string containing all tag names for a note
2563         private String getTagNamesForNote(Note n) {
2564                 logger.log(logger.HIGH, "Entering NeverNote.getTagNamesForNote");
2565                 if (n==null || n.getGuid() == null || n.getGuid().equals(""))
2566                         return "";
2567                 StringBuffer buffer = new StringBuffer(100);
2568                 Vector<String> v = new Vector<String>();
2569                 List<String> guids = n.getTagGuids();
2570
2571                 if (guids == null)
2572                         return "";
2573
2574                 for (int i=0; i<guids.size(); i++) {
2575                         v.add(listManager.getTagNameByGuid(guids.get(i)));
2576                 }
2577                 Comparator<String> comparator = Collections.reverseOrder();
2578                 Collections.sort(v,comparator);
2579                 Collections.reverse(v);
2580
2581                 for (int i = 0; i<v.size(); i++) {
2582                         if (i>0)
2583                                 buffer.append(", ");
2584                         buffer.append(v.get(i));
2585                 }
2586
2587                 logger.log(logger.HIGH, "Leaving NeverNote.getTagNamesForNote");
2588                 return buffer.toString();
2589         }
2590         // Tags were added via dropping notes from the note list
2591         @SuppressWarnings("unused")
2592         private void tagsAdded(String noteGuid, String tagGuid) {
2593                 String tagName = null;
2594                 for (int i=0; i<listManager.getTagIndex().size(); i++) {
2595                         if (listManager.getTagIndex().get(i).getGuid().equals(tagGuid)) {
2596                                 tagName = listManager.getTagIndex().get(i).getName();
2597                                 i=listManager.getTagIndex().size();
2598                         }
2599                 }
2600                 if (tagName == null)
2601                         return;
2602
2603                 for (int i=0; i<listManager.getMasterNoteIndex().size(); i++) {
2604                         if (listManager.getMasterNoteIndex().get(i).getGuid().equals(noteGuid)) {
2605                                 List<String> tagNames = new ArrayList<String>();
2606                                 tagNames.add(new String(tagName));
2607                                 Note n = listManager.getMasterNoteIndex().get(i);
2608                                 for (int j=0; j<n.getTagNames().size(); j++) {
2609                                         tagNames.add(new String(n.getTagNames().get(j)));
2610                                 }
2611                                 listManager.getNoteTableModel().updateNoteTags(noteGuid, n.getTagGuids(), tagNames);
2612                                 if (n.getGuid().equals(currentNoteGuid)) {
2613                                         Collections.sort(tagNames);
2614                                         String display = "";
2615                                         for (int j=0; j<tagNames.size(); j++) {
2616                                                 display = display+tagNames.get(j);
2617                                                 if (j+2<tagNames.size())
2618                                                         display = display+Global.tagDelimeter+" ";
2619                                         }
2620                                         browserWindow.setTag(display);
2621                                 }
2622                                 i=listManager.getMasterNoteIndex().size();
2623                         }
2624                 }
2625
2626
2627                 listManager.getNoteTableModel().updateNoteSyncStatus(noteGuid, false);
2628         }
2629         private void clearTagFilter() {
2630                 tagTree.blockSignals(true);
2631                 tagTree.clearSelection();
2632                 menuBar.noteRestoreAction.setVisible(false);
2633                 menuBar.tagEditAction.setEnabled(false);
2634                 menuBar.tagMergeAction.setEnabled(false);
2635                 menuBar.tagDeleteAction.setEnabled(false);
2636                 menuBar.tagIconAction.setEnabled(false);
2637                 selectedTagGUIDs.clear();
2638         listManager.setSelectedTags(selectedTagGUIDs);
2639         tagTree.blockSignals(false);
2640         }
2641         // Change the icon for a tag
2642         @SuppressWarnings("unused")
2643         private void setTagIcon() {
2644                 QTreeWidgetItem currentSelection;
2645                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
2646                 if (selections.size() == 0)
2647                         return;
2648
2649                 currentSelection = selections.get(0);
2650                 String guid = currentSelection.text(2);
2651
2652                 QIcon currentIcon = currentSelection.icon(0);
2653                 QIcon icon = conn.getTagTable().getIcon(guid);
2654                 SetIcon dialog;
2655                 if (icon == null) {
2656                         dialog = new SetIcon(currentIcon, saveLastPath);
2657                         dialog.setUseDefaultIcon(true);
2658                 } else {
2659                         dialog = new SetIcon(icon, saveLastPath);
2660                         dialog.setUseDefaultIcon(false);
2661                 }
2662                 dialog.exec();
2663                 if (dialog.okPressed()) {
2664                 saveLastPath = dialog.getPath();
2665                         QIcon newIcon = dialog.getIcon();
2666                         conn.getTagTable().setIcon(guid, newIcon, dialog.getFileType());
2667                         if (newIcon == null)
2668                                 newIcon = new QIcon(iconPath+"tag.png");
2669                         currentSelection.setIcon(0, newIcon);
2670                 }
2671
2672         }
2673         // Merge tags
2674         @SuppressWarnings("unused")
2675         private void mergeTags() {
2676                 List<Tag> tags = new ArrayList<Tag>();
2677                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
2678                 for (int i=0; i<selections.size(); i++) {
2679                         Tag record = new Tag();
2680                         record.setGuid(selections.get(i).text(2));
2681                         record.setName(selections.get(i).text(0));
2682                         tags.add(record);
2683                 }
2684
2685                 TagMerge mergeDialog = new TagMerge(tags);
2686                 mergeDialog.exec();
2687                 if (!mergeDialog.okClicked())
2688                         return;
2689                 String newGuid = mergeDialog.getNewTagGuid();
2690
2691                 for (int i=0; i<tags.size(); i++) {
2692                         if (!tags.get(i).getGuid().equals(newGuid)) {
2693                                 List<String> noteGuids = conn.getNoteTable().noteTagsTable.getTagNotes(tags.get(i).getGuid());
2694                                 for (int j=0; j<noteGuids.size(); j++) {
2695                                         String noteGuid = noteGuids.get(j);
2696                                         conn.getNoteTable().noteTagsTable.deleteNoteTag(noteGuid);
2697                                         if (!conn.getNoteTable().noteTagsTable.checkNoteNoteTags(noteGuid, newGuid))
2698                                                 conn.getNoteTable().noteTagsTable.saveNoteTag(noteGuid, newGuid, true);
2699                                 }
2700                         }
2701                 }
2702                 listManager.reloadIndexes();
2703         }
2704
2705     //***************************************************************
2706     //***************************************************************
2707     //** These functions deal with Saved Search menu items
2708     //***************************************************************
2709     //***************************************************************
2710         // Add a new notebook
2711         @SuppressWarnings("unused")
2712         private void addSavedSearch() {
2713                 logger.log(logger.HIGH, "Inside NeverNote.addSavedSearch");
2714                 SavedSearchEdit edit = new SavedSearchEdit();
2715                 edit.setSearchList(listManager.getSavedSearchIndex());
2716                 edit.exec();
2717
2718                 if (!edit.okPressed())
2719                         return;
2720
2721                 Calendar currentTime = new GregorianCalendar();
2722                 Long l = new Long(currentTime.getTimeInMillis());
2723                 String randint = new String(Long.toString(l));
2724
2725                 SavedSearch search = new SavedSearch();
2726                 search.setUpdateSequenceNum(0);
2727                 search.setGuid(randint);
2728                 search.setName(edit.getName());
2729                 search.setQuery(edit.getQuery());
2730                 search.setFormat(QueryFormat.USER);
2731                 listManager.getSavedSearchIndex().add(search);
2732                 conn.getSavedSearchTable().addSavedSearch(search, true);
2733                 savedSearchIndexUpdated();
2734                 logger.log(logger.HIGH, "Leaving NeverNote.addSavedSearch");
2735         }
2736         // Edit an existing tag
2737         @SuppressWarnings("unused")
2738         private void editSavedSearch() {
2739                 logger.log(logger.HIGH, "Entering NeverNote.editSavedSearch");
2740                 SavedSearchEdit edit = new SavedSearchEdit();
2741                 edit.setTitle(tr("Edit Search"));
2742                 List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
2743                 QTreeWidgetItem currentSelection;
2744                 currentSelection = selections.get(0);
2745                 String guid = currentSelection.text(1);
2746                 SavedSearch s = conn.getSavedSearchTable().getSavedSearch(guid);
2747                 edit.setName(currentSelection.text(0));
2748                 edit.setQuery(s.getQuery());
2749                 edit.setSearchList(listManager.getSavedSearchIndex());
2750                 edit.exec();
2751
2752                 if (!edit.okPressed())
2753                         return;
2754
2755                 List<SavedSearch> list = listManager.getSavedSearchIndex();
2756                 SavedSearch search = null;
2757                 boolean found = false;
2758                 for (int i=0; i<list.size(); i++) {
2759                         search = list.get(i);
2760                         if (search.getGuid().equals(guid)) {
2761                                 i=list.size();
2762                                 found = true;
2763                         }
2764                 }
2765                 if (!found)
2766                         return;
2767                 search.setName(edit.getName());
2768                 search.setQuery(edit.getQuery());
2769                 conn.getSavedSearchTable().updateSavedSearch(search, true);
2770                 savedSearchIndexUpdated();
2771                 logger.log(logger.HIGH, "Leaving NeverNote.editSavedSearch");
2772         }
2773         // Delete an existing tag
2774         @SuppressWarnings("unused")
2775         private void deleteSavedSearch() {
2776                 logger.log(logger.HIGH, "Entering NeverNote.deleteSavedSearch");
2777
2778                 if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected search?"),
2779                         QMessageBox.StandardButton.Yes,
2780                         QMessageBox.StandardButton.No)==StandardButton.No.value()) {
2781                                                         return;
2782                 }
2783
2784                 List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
2785         for (int i=selections.size()-1; i>=0; i--) {
2786                 QTreeWidgetItem currentSelection;
2787                 currentSelection = selections.get(i);
2788                 for (int j=0; j<listManager.getSavedSearchIndex().size(); j++) {
2789                         if (listManager.getSavedSearchIndex().get(j).getGuid().equals(currentSelection.text(1))) {
2790                                 conn.getSavedSearchTable().expungeSavedSearch(listManager.getSavedSearchIndex().get(j).getGuid(), true);
2791                                 listManager.getSavedSearchIndex().remove(j);
2792                                 j=listManager.getSavedSearchIndex().size()+1;
2793                         }
2794                 }
2795                 selections.remove(i);
2796         }
2797         savedSearchIndexUpdated();
2798         logger.log(logger.HIGH, "Leaving NeverNote.deleteSavedSearch");
2799         }
2800     // Setup the tree containing the user's tags
2801     private void initializeSavedSearchTree() {
2802         logger.log(logger.HIGH, "Entering NeverNote.initializeSavedSearchTree");
2803         savedSearchTree.itemSelectionChanged.connect(this, "savedSearchTreeSelection()");
2804         logger.log(logger.HIGH, "Leaving NeverNote.initializeSavedSearchTree");
2805     }
2806     // Listener when a tag is selected
2807     @SuppressWarnings("unused")
2808         private void savedSearchTreeSelection() {
2809         logger.log(logger.HIGH, "Entering NeverNote.savedSearchTreeSelection");
2810
2811         clearNotebookFilter();
2812         clearTagFilter();
2813         clearTrashFilter();
2814         clearAttributeFilter();
2815
2816         String currentGuid = selectedSavedSearchGUID;
2817         menuBar.savedSearchEditAction.setEnabled(true);
2818         menuBar.savedSearchDeleteAction.setEnabled(true);
2819         menuBar.savedSearchIconAction.setEnabled(true);
2820
2821                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
2822                 if (!rensoNoteListDock.isEnabled()) {
2823                         rensoNoteListDock.setEnabled(true);
2824                 }
2825
2826         List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
2827         QTreeWidgetItem currentSelection;
2828         selectedSavedSearchGUID = "";
2829         for (int i=0; i<selections.size(); i++) {
2830                 currentSelection = selections.get(i);
2831                 if (currentSelection.text(1).equals(currentGuid)) {
2832                         currentSelection.setSelected(false);
2833                 } else {
2834                         selectedSavedSearchGUID = currentSelection.text(1);
2835                 }
2836 //              i = selections.size() +1;
2837         }
2838
2839         // There is the potential for no notebooks to be selected if this
2840         // happens then we make it look like all notebooks were selecetd.
2841         // If that happens, just select the "all notebooks"
2842         if (selections.size()==0) {
2843                 clearSavedSearchFilter();
2844         }
2845         listManager.setSelectedSavedSearch(selectedSavedSearchGUID);
2846
2847         logger.log(logger.HIGH, "Leaving NeverNote.savedSearchTreeSelection");
2848     }
2849     private void clearSavedSearchFilter() {
2850         menuBar.savedSearchEditAction.setEnabled(false);
2851         menuBar.savedSearchDeleteAction.setEnabled(false);
2852         menuBar.savedSearchIconAction.setEnabled(false);
2853         savedSearchTree.blockSignals(true);
2854         savedSearchTree.clearSelection();
2855         savedSearchTree.blockSignals(false);
2856         selectedSavedSearchGUID = "";
2857         searchField.setEditText("");
2858         searchPerformed = false;
2859         listManager.setSelectedSavedSearch(selectedSavedSearchGUID);
2860     }
2861     // trigger the tag index to be refreshed
2862         private void savedSearchIndexUpdated() {
2863                 if (selectedSavedSearchGUID == null)
2864                         selectedSavedSearchGUID = new String();
2865                 savedSearchTree.blockSignals(true);
2866                 savedSearchTree.setIcons(conn.getSavedSearchTable().getAllIcons());
2867         savedSearchTree.load(listManager.getSavedSearchIndex());
2868         savedSearchTree.selectGuid(selectedSavedSearchGUID);
2869         savedSearchTree.blockSignals(false);
2870     }
2871     // trigger when the saved search selection changes
2872     @SuppressWarnings("unused")
2873         private void updateSavedSearchSelection() {
2874                 logger.log(logger.HIGH, "Entering NeverNote.updateSavedSearchSelection()");
2875
2876         menuBar.savedSearchEditAction.setEnabled(true);
2877         menuBar.savedSearchDeleteAction.setEnabled(true);
2878         menuBar.savedSearchIconAction.setEnabled(true);
2879         List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
2880
2881         if (selections.size() > 0) {
2882                 menuBar.savedSearchEditAction.setEnabled(true);
2883                 menuBar.savedSearchDeleteAction.setEnabled(true);
2884                 menuBar.savedSearchIconAction.setEnabled(true);
2885                 selectedSavedSearchGUID = selections.get(0).text(1);
2886                 SavedSearch s = conn.getSavedSearchTable().getSavedSearch(selectedSavedSearchGUID);
2887                 searchField.setEditText(s.getQuery());
2888         } else {
2889                 menuBar.savedSearchEditAction.setEnabled(false);
2890                 menuBar.savedSearchDeleteAction.setEnabled(false);
2891                 menuBar.savedSearchIconAction.setEnabled(false);
2892                 selectedSavedSearchGUID = "";
2893                 searchField.setEditText("");
2894         }
2895         searchFieldChanged();
2896
2897                 logger.log(logger.HIGH, "Leaving NeverNote.updateSavedSearchSelection()");
2898
2899
2900     }
2901     // Show/Hide note information
2902         @SuppressWarnings("unused")
2903         private void toggleSavedSearchWindow() {
2904                 logger.log(logger.HIGH, "Entering NeverNote.toggleSavedSearchWindow");
2905         if (savedSearchTree.isVisible())
2906                 savedSearchTree.hide();
2907         else
2908                 savedSearchTree.show();
2909         menuBar.hideSavedSearches.setChecked(savedSearchTree.isVisible());
2910
2911                 Global.saveWindowVisible("savedSearchTree", savedSearchTree.isVisible());
2912         logger.log(logger.HIGH, "Leaving NeverNote.toggleSavedSearchWindow");
2913     }
2914         // Change the icon for a saved search
2915         @SuppressWarnings("unused")
2916         private void setSavedSearchIcon() {
2917                 QTreeWidgetItem currentSelection;
2918                 List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
2919                 if (selections.size() == 0)
2920                         return;
2921
2922                 currentSelection = selections.get(0);
2923                 String guid = currentSelection.text(1);
2924
2925                 QIcon currentIcon = currentSelection.icon(0);
2926                 QIcon icon = conn.getSavedSearchTable().getIcon(guid);
2927                 SetIcon dialog;
2928                 if (icon == null) {
2929                         dialog = new SetIcon(currentIcon, saveLastPath);
2930                         dialog.setUseDefaultIcon(true);
2931                 } else {
2932                         dialog = new SetIcon(icon, saveLastPath);
2933                         dialog.setUseDefaultIcon(false);
2934                 }
2935                 dialog.exec();
2936                 if (dialog.okPressed()) {
2937                 saveLastPath = dialog.getPath();
2938                         QIcon newIcon = dialog.getIcon();
2939                         conn.getSavedSearchTable().setIcon(guid, newIcon, dialog.getFileType());
2940                         if (newIcon == null)
2941                                 newIcon = new QIcon(iconPath+"search.png");
2942                         currentSelection.setIcon(0, newIcon);
2943                 }
2944
2945         }
2946
2947
2948
2949
2950     //***************************************************************
2951     //***************************************************************
2952     //** These functions deal with Help menu & tool menu items
2953     //***************************************************************
2954     //***************************************************************
2955         // Show database status
2956         @SuppressWarnings("unused")
2957         private void databaseStatus() {
2958                 waitCursor(true);
2959                 indexRunner.interrupt = true;
2960                 int dirty = conn.getNoteTable().getDirtyCount();
2961                 int unindexed = conn.getNoteTable().getUnindexedCount();
2962                 DatabaseStatus status = new DatabaseStatus();
2963                 status.setUnsynchronized(dirty);
2964                 status.setUnindexed(unindexed);
2965                 status.setNoteCount(conn.getNoteTable().getNoteCount());
2966                 status.setNotebookCount(listManager.getNotebookIndex().size());
2967                 status.setUnindexedResourceCount(conn.getNoteTable().noteResourceTable.getUnindexedCount());
2968                 status.setSavedSearchCount(listManager.getSavedSearchIndex().size());
2969                 status.setTagCount(listManager.getTagIndex().size());
2970                 status.setResourceCount(conn.getNoteTable().noteResourceTable.getResourceCount());
2971                 status.setWordCount(conn.getWordsTable().getWordCount());
2972                 status.setHistoryCount(conn.getHistoryTable().getHistoryCount());
2973                 waitCursor(false);
2974                 status.exec();
2975         }
2976         // Compact the database
2977         @SuppressWarnings("unused")
2978         private void compactDatabase() {
2979         logger.log(logger.HIGH, "Entering NeverNote.compactDatabase");
2980                 if (QMessageBox.question(this, tr("Confirmation"), tr("This will free unused space in the database, "+
2981                                 "but please be aware that depending upon the size of your database this can be time consuming " +
2982                                 "and NeighborNote will be unresponsive until it is complete.  Do you wish to continue?"),
2983                                 QMessageBox.StandardButton.Yes,
2984                                 QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
2985                                                         return;
2986                 }
2987                 setMessage("Compacting database.");
2988                 waitCursor(true);
2989                 listManager.compactDatabase();
2990                 waitCursor(false);
2991                 setMessage("Database compact is complete.");
2992         logger.log(logger.HIGH, "Leaving NeverNote.compactDatabase");
2993     }
2994         @SuppressWarnings("unused")
2995         private void accountInformation() {
2996                 logger.log(logger.HIGH, "Entering NeverNote.accountInformation");
2997                 AccountDialog dialog = new AccountDialog();
2998                 dialog.show();
2999                 logger.log(logger.HIGH, "Leaving NeverNote.accountInformation");
3000         }
3001         @SuppressWarnings("unused")
3002         private void releaseNotes() {
3003                 logger.log(logger.HIGH, "Entering NeverNote.releaseNotes");
3004                 QDialog dialog = new QDialog(this);
3005                 QHBoxLayout layout = new QHBoxLayout();
3006                 QTextEdit textBox = new QTextEdit();
3007                 layout.addWidget(textBox);
3008                 textBox.setReadOnly(true);
3009                 QFile file = new QFile(Global.getFileManager().getProgramDirPath("release.txt"));
3010                 if (!file.open(new QIODevice.OpenMode(QIODevice.OpenModeFlag.ReadOnly,
3011                 QIODevice.OpenModeFlag.Text)))
3012                         return;
3013                 // ICHANGED 日本語文字化け対策
3014                 QTextCodec codec = QTextCodec.codecForName("UTF-8");
3015                 QTextStream textStream = new QTextStream(file);
3016                 textStream.setCodec(codec);
3017                 textBox.setText(textStream.readAll().toString());
3018
3019                 file.close();
3020                 dialog.setWindowTitle(tr("Release Notes"));
3021                 dialog.setLayout(layout);
3022                 dialog.show();
3023                 logger.log(logger.HIGH, "Leaving NeverNote.releaseNotes");
3024         }
3025         // Called when user picks Log from the help menu
3026         @SuppressWarnings("unused")
3027         private void logger() {
3028                 logger.log(logger.HIGH, "Entering NeverNote.logger");
3029                 LogFileDialog dialog = new LogFileDialog(emitLog);
3030                 dialog.exec();
3031                 logger.log(logger.HIGH, "Leaving NeverNote.logger");
3032         }
3033         // Menu option "help/about" was selected
3034         @SuppressWarnings("unused")
3035         private void about() {
3036                 logger.log(logger.HIGH, "Entering NeverNote.about");
3037                 // ICHANGED based on...の記述を付加
3038                 QMessageBox.about(this,
3039                                                 tr("About NeighborNote"),
3040                                                 tr("<h4><center><b>NeighborNote</b></center></h4><hr><center>Version ")
3041                                                 +Global.version + "(based on NixNote 1.5)"
3042                                                 //+"1.2.120724"
3043                                                 +tr("<hr>"
3044                                                                 +"Open Source Evernote Client.<br><br>"
3045                                                                 +"Licensed under GPL v2.  <br><hr><br>"
3046                                                                 +"</center>Evernote is copyright 2001-2012 by Evernote Corporation<br>"
3047                                                                 +"Jambi and QT are the licensed trademark of Nokia Corporation<br>"
3048                                                                 +"PDFRenderer is licened under the LGPL<br>"
3049                                                                 +"JTidy is copyrighted under the World Wide Web Consortium<br>"
3050                                                                 +"Apache Common Utilities licensed under the Apache License Version 2.0<br>"
3051                                                                 +"Jazzy is licened under the LGPL<br>"
3052                                                                 +"Java is a registered trademark of Oracle Corporation.<br><hr>"
3053                                                                 +"Special thanks to:<br>BitRock InstallBuilder for the Windows installer"
3054                                                                 +"<br>CodeCogs (www.codecogs.com) for the LaTeX image rendering."));
3055                 logger.log(logger.HIGH, "Leaving NeverNote.about");
3056         }
3057         // Hide the entire left hand side
3058         @SuppressWarnings("unused")
3059         private void toggleLeftSide() {
3060                 boolean hidden;
3061
3062                 hidden = !menuBar.hideLeftSide.isChecked();
3063                 menuBar.hideLeftSide.setChecked(!hidden);
3064
3065                 if (!hidden)
3066                         leftSplitter1.setHidden(true);
3067                 else
3068                         leftSplitter1.setHidden(false);
3069
3070                 Global.saveWindowVisible("leftPanel", hidden);
3071
3072         }
3073         public void checkForUpdates() {
3074                 // Send off thread to check for a new version
3075                 versionChecker = new QNetworkAccessManager(this);
3076                 versionChecker.finished.connect(this, "upgradeFileRead(QNetworkReply)");
3077                 QNetworkRequest request = new QNetworkRequest();
3078                 request.setUrl(new QUrl(Global.getUpdatesAvailableUrl()));
3079                 versionChecker.get(request);
3080         }
3081         @SuppressWarnings("unused")
3082         private void upgradeFileRead(QNetworkReply reply) {
3083                 if (!reply.isReadable())
3084                         return;
3085
3086                 String winVersion = Global.version;
3087                 String osxVersion = Global.version;
3088                 String linuxVersion = Global.version;
3089                 String linux64Version = Global.version;
3090                 String version = Global.version;
3091
3092                 // Determine the versions available
3093                 QByteArray data = reply.readLine();
3094                 while (data != null && !reply.atEnd()) {
3095                         String line = data.toString();
3096                         String lineVersion;
3097                         if (line.contains(":"))
3098                                 lineVersion = line.substring(line.indexOf(":")+1).replace(" ", "").replace("\n", "");
3099                         else
3100                                 lineVersion = "";
3101                         if (line.toLowerCase().contains("windows"))
3102                                 winVersion = lineVersion;
3103                         else if (line.toLowerCase().contains("os-x"))
3104                                 osxVersion = lineVersion;
3105                         else if (line.toLowerCase().contains("linux amd64"))
3106                                 linux64Version = lineVersion;
3107                         else if (line.toLowerCase().contains("linux i386"))
3108                                 linuxVersion = lineVersion;
3109                         else if (line.toLowerCase().contains("default"))
3110                                 version = lineVersion;
3111
3112                         // Read the next line
3113                         data = reply.readLine();
3114                 }
3115
3116                 // Now we need to determine what system we are on.
3117                 if (System.getProperty("os.name").toLowerCase().contains("windows"))
3118                         version = winVersion;
3119                 if (System.getProperty("os.name").toLowerCase().contains("mac os"))
3120                         version = osxVersion;
3121                 if (System.getProperty("os.name").toLowerCase().contains("Linux")) {
3122                         if (System.getProperty("os.arch").contains("amd64") ||
3123                                 System.getProperty("os.arch").contains("x86_64"))
3124                                         version = linux64Version;
3125                         else
3126                                 version = linuxVersion;
3127                 }
3128
3129
3130                 for (String validVersion : Global.validVersions) {
3131                         if (version.equals(validVersion))
3132                                 return;
3133                 }
3134
3135                 UpgradeAvailableDialog dialog = new UpgradeAvailableDialog();
3136                 dialog.exec();
3137                 if (dialog.remindMe())
3138                         Global.setCheckVersionUpgrade(true);
3139                 else
3140                         Global.setCheckVersionUpgrade(false);
3141         }
3142
3143
3144     //***************************************************************
3145     //***************************************************************
3146     //** These functions deal with the Toolbar
3147     //***************************************************************
3148     //***************************************************************
3149         @SuppressWarnings("unused")
3150         private void focusSearch() {
3151                 searchField.setFocus();
3152         }
3153
3154         // Text in the search bar has been cleared
3155         private void searchFieldCleared() {
3156                 saveNote();
3157
3158                 // This is done because we want to force a reload of
3159                 // images.  Some images we may want to highlight the text.
3160                 readOnlyCache.clear();
3161                 inkNoteCache.clear();
3162                 noteCache.clear();
3163                 QWebSettings.setMaximumPagesInCache(0);
3164                 QWebSettings.setObjectCacheCapacities(0, 0, 0);
3165
3166                 searchField.setEditText("");
3167                 saveNoteColumnPositions();
3168                 saveNoteIndexWidth();
3169                 noteIndexUpdated(true);
3170                 if (currentNote == null && listManager.getNoteIndex().size() > 0) {
3171                         currentNote = listManager.getNoteIndex().get(0);
3172                         currentNoteGuid = currentNote.getGuid();
3173                 }
3174                 refreshEvernoteNote(true);
3175                 if (currentNote != null)
3176                         loadNoteBrowserInformation(browserWindow, currentNoteGuid, currentNote);
3177         }
3178         // text in the search bar changed.  We only use this to tell if it was cleared,
3179         // otherwise we trigger off searchFieldChanged.
3180         @SuppressWarnings("unused")
3181         private void searchFieldTextChanged(String text) {
3182                 QWebSettings.setMaximumPagesInCache(0);
3183                 QWebSettings.setObjectCacheCapacities(0, 0, 0);
3184
3185                 if (text.trim().equals("")) {
3186                         searchFieldCleared();
3187                         if (searchPerformed) {
3188
3189                                 // This is done because we want to force a reload of
3190                                 // images.  Some images we may want to highlight the text.
3191                                 noteCache.clear();
3192                                 readOnlyCache.clear();
3193                                 inkNoteCache.clear();
3194
3195                                 listManager.setEnSearch("");
3196                                 listManager.loadNotesIndex();
3197                                 refreshEvernoteNote(true);
3198                                 noteIndexUpdated(false);
3199                                 refreshEvernoteNote(true);
3200                         }
3201                         searchPerformed = false;
3202                 }
3203         }
3204     // Text in the toolbar has changed
3205     private void searchFieldChanged() {
3206         logger.log(logger.HIGH, "Entering NeverNote.searchFieldChanged");
3207         noteCache.clear();
3208         readOnlyCache.clear();
3209         inkNoteCache.clear();
3210         saveNoteColumnPositions();
3211         saveNoteIndexWidth();
3212         String text = searchField.currentText();
3213         listManager.setEnSearch(text.trim());
3214         listManager.loadNotesIndex();
3215         noteIndexUpdated(false);
3216
3217         refreshEvernoteNote(true);
3218         searchPerformed = true;
3219         waitCursor(false);
3220         logger.log(logger.HIGH, "Leaving NeverNote.searchFieldChanged");
3221     }
3222
3223     // Build the window tool bar
3224     private void setupToolBar() {
3225         logger.log(logger.HIGH, "Entering NeverNote.setupToolBar");
3226         toolBar = addToolBar(tr("Tool Bar"));
3227         toolBar.setObjectName("toolBar");
3228         menuBar.setupToolBarVisible();
3229         if (!Global.isWindowVisible("toolBar"))
3230                 toolBar.setVisible(false);
3231         else
3232                 toolBar.setVisible(true);
3233
3234 //      toolBar.addWidget(menuBar);
3235 //      menuBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
3236 //      toolBar.addSeparator();
3237         prevButton = toolBar.addAction(tr("Previous"));
3238         QIcon prevIcon = new QIcon(iconPath+"back.png");
3239         prevButton.setIcon(prevIcon);
3240         prevButton.triggered.connect(this, "previousViewedAction()");
3241         togglePrevArrowButton(Global.isToolbarButtonVisible("prevArrow"));
3242
3243         nextButton = toolBar.addAction(tr("Next"));
3244         QIcon nextIcon = new QIcon(iconPath+"forward.png");
3245         nextButton.setIcon(nextIcon);
3246         nextButton.triggered.connect(this, "nextViewedAction()");
3247         toggleNextArrowButton(Global.isToolbarButtonVisible("nextArrow"));
3248
3249         upButton = toolBar.addAction(tr("Up"));
3250         QIcon upIcon = new QIcon(iconPath+"up.png");
3251         upButton.setIcon(upIcon);
3252         upButton.triggered.connect(this, "upAction()");
3253         toggleUpArrowButton(Global.isToolbarButtonVisible("upArrow"));
3254
3255
3256         downButton = toolBar.addAction(tr("Down"));
3257         QIcon downIcon = new QIcon(iconPath+"down.png");
3258         downButton.setIcon(downIcon);
3259         downButton.triggered.connect(this, "downAction()");
3260         toggleDownArrowButton(Global.isToolbarButtonVisible("downArrow"));
3261
3262         synchronizeButton = toolBar.addAction(tr("Synchronize"));
3263         synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
3264         synchronizeIconAngle = 0;
3265         synchronizeButton.triggered.connect(this, "evernoteSync()");
3266         toggleSynchronizeButton(Global.isToolbarButtonVisible("synchronize"));
3267
3268         printButton = toolBar.addAction(tr("Print"));
3269         QIcon printIcon = new QIcon(iconPath+"print.png");
3270         printButton.setIcon(printIcon);
3271         printButton.triggered.connect(this, "printNote()");
3272         togglePrintButton(Global.isToolbarButtonVisible("print"));
3273
3274         tagButton = toolBar.addAction(tr("Tag"));
3275         QIcon tagIcon = new QIcon(iconPath+"tag.png");
3276         tagButton.setIcon(tagIcon);
3277         tagButton.triggered.connect(browserWindow, "modifyTags()");
3278         toggleTagButton(Global.isToolbarButtonVisible("tag"));
3279
3280         attributeButton = toolBar.addAction(tr("Attributes"));
3281         QIcon attributeIcon = new QIcon(iconPath+"attribute.png");
3282         attributeButton.setIcon(attributeIcon);
3283         attributeButton.triggered.connect(this, "toggleNoteAttributes()");
3284         toggleAttributeButton(Global.isToolbarButtonVisible("attribute"));
3285
3286         emailButton = toolBar.addAction(tr("Email"));
3287         QIcon emailIcon = new QIcon(iconPath+"email.png");
3288         emailButton.setIcon(emailIcon);
3289         emailButton.triggered.connect(this, "emailNote()");
3290         toggleEmailButton(Global.isToolbarButtonVisible("email"));
3291
3292         deleteButton = toolBar.addAction(tr("Delete"));
3293         QIcon deleteIcon = new QIcon(iconPath+"delete.png");
3294         deleteButton.setIcon(deleteIcon);
3295         deleteButton.triggered.connect(this, "deleteNote()");
3296         toggleDeleteButton(Global.isToolbarButtonVisible("delete"));
3297
3298         newButton = toolBar.addAction(tr("New"));
3299         QIcon newIcon = new QIcon(iconPath+"new.png");
3300         newButton.triggered.connect(this, "addNote()");
3301         newButton.setIcon(newIcon);
3302         toggleNewButton(Global.isToolbarButtonVisible("new"));
3303
3304         allNotesButton = toolBar.addAction(tr("All Notes"));
3305         QIcon allIcon = new QIcon(iconPath+"books.png");
3306         allNotesButton.triggered.connect(this, "allNotes()");
3307         allNotesButton.setIcon(allIcon);
3308         toggleAllNotesButton(Global.isToolbarButtonVisible("allNotes"));
3309
3310         //toolBar.addSeparator();
3311         //toolBar.addWidget(new QLabel(tr("Quota:")));
3312         //toolBar.addWidget(quotaBar);
3313         //quotaBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
3314         updateQuotaBar();
3315         //toolBar.addSeparator();
3316
3317         //toolBar.addWidget(new QLabel(tr("Zoom")));
3318         //toolBar.addWidget(zoomSpinner);
3319
3320         //toolBar.addWidget(new QLabel("                    "));
3321         //toolBar.addSeparator();
3322         //toolBar.addWidget(new QLabel(tr("  Search:")));
3323         //toolBar.addWidget(searchField);
3324         QSizePolicy sizePolicy = new QSizePolicy();
3325         sizePolicy.setHorizontalPolicy(Policy.MinimumExpanding);
3326         QLabel spacer = new QLabel("");
3327         spacer.setSizePolicy(sizePolicy);
3328         toolBar.addWidget(spacer);
3329         //searchField.setInsertPolicy(InsertPolicy.InsertAtTop);
3330
3331         //searchClearButton = toolBar.addAction("Search Clear");
3332         //QIcon searchClearIcon = new QIcon(iconPath+"searchclear.png");
3333         //searchClearButton.setIcon(searchClearIcon);
3334         //searchClearButton.triggered.connect(this, "searchFieldCleared()");
3335         //toggleSearchClearButton(Global.isToolbarButtonVisible("searchClear"));
3336
3337         logger.log(logger.HIGH, "Leaving NeverNote.setupToolBar");
3338     }
3339     // Update the sychronize button picture
3340     @Override
3341         public QMenu createPopupMenu() {
3342         QMenu contextMenu = super.createPopupMenu();
3343
3344         contextMenu.addSeparator();
3345         QAction prevAction = addContextAction("prevArrow", tr("Previous Arrow"));
3346         contextMenu.addAction(prevAction);
3347         prevAction.triggered.connect(this, "togglePrevArrowButton(Boolean)");
3348
3349         QAction nextAction = addContextAction("nextArrow", tr("Next Arrow"));
3350         contextMenu.addAction(nextAction);
3351         nextAction.triggered.connect(this, "toggleNextArrowButton(Boolean)");
3352
3353         QAction upAction = addContextAction("upArrow", tr("Up Arrow"));
3354         contextMenu.addAction(upAction);
3355         upAction.triggered.connect(this, "toggleUpArrowButton(Boolean)");
3356
3357         QAction downAction = addContextAction("downArrow", tr("Down Arrow"));
3358         contextMenu.addAction(downAction);
3359         downAction.triggered.connect(this, "toggleDownArrowButton(Boolean)");
3360
3361         QAction synchronizeAction = addContextAction("synchronize", tr("Synchronize"));
3362         contextMenu.addAction(synchronizeAction);
3363         synchronizeAction.triggered.connect(this, "toggleSynchronizeButton(Boolean)");
3364
3365         QAction printAction = addContextAction("print", tr("Print"));
3366         contextMenu.addAction(printAction);
3367         printAction.triggered.connect(this, "togglePrintButton(Boolean)");
3368
3369         QAction tagAction = addContextAction("tag", tr("Tag"));
3370         contextMenu.addAction(tagAction);
3371         tagAction.triggered.connect(this, "toggleTagButton(Boolean)");
3372
3373         QAction attributeAction = addContextAction("attribute", tr("Attribute"));
3374         contextMenu.addAction(attributeAction);
3375         attributeAction.triggered.connect(this, "toggleAttributeButton(Boolean)");
3376
3377         QAction emailAction = addContextAction("email", tr("Email"));
3378         contextMenu.addAction(emailAction);
3379         emailAction.triggered.connect(this, "toggleEmailButton(Boolean)");
3380
3381         QAction deleteAction = addContextAction("delete", tr("Delete"));
3382         contextMenu.addAction(deleteAction);
3383         deleteAction.triggered.connect(this, "toggleDeleteButton(Boolean)");
3384
3385         QAction newAction = addContextAction("new", tr("Add"));
3386         contextMenu.addAction(newAction);
3387         newAction.triggered.connect(this, "toggleNewButton(Boolean)");
3388
3389         QAction allNotesAction = addContextAction("allNotes", tr("All Notes"));
3390         contextMenu.addAction(allNotesAction);
3391         allNotesAction.triggered.connect(this, "toggleAllNotesButton(Boolean)");
3392
3393         QAction searchClearAction = addContextAction("searchClear", tr("Search Clear"));
3394         contextMenu.addAction(searchClearAction);
3395         searchClearAction.triggered.connect(this, "toggleSearchClearButton(Boolean)");
3396
3397         return contextMenu;
3398
3399     }
3400     private QAction addContextAction(String config, String name) {
3401         QAction newAction = new QAction(this);
3402                 newAction.setText(name);
3403                 newAction.setCheckable(true);
3404                 newAction.setChecked(Global.isToolbarButtonVisible(config));
3405                 return newAction;
3406     }
3407     private void togglePrevArrowButton(Boolean toggle) {
3408                 prevButton.setVisible(toggle);
3409                 Global.saveToolbarButtonsVisible("prevArrow", toggle);
3410     }
3411     private void toggleNextArrowButton(Boolean toggle) {
3412                 nextButton.setVisible(toggle);
3413                 Global.saveToolbarButtonsVisible("nextArrow", toggle);
3414     }
3415     private void toggleUpArrowButton(Boolean toggle) {
3416                 upButton.setVisible(toggle);
3417                 Global.saveToolbarButtonsVisible("upArrow", toggle);
3418     }
3419     private void toggleDownArrowButton(Boolean toggle) {
3420                 downButton.setVisible(toggle);
3421                 Global.saveToolbarButtonsVisible("downArrow", toggle);
3422     }
3423     private void toggleSynchronizeButton(Boolean toggle) {
3424                 synchronizeButton.setVisible(toggle);
3425                 Global.saveToolbarButtonsVisible("synchronize", toggle);
3426     }
3427     private void togglePrintButton(Boolean toggle) {
3428                 printButton.setVisible(toggle);
3429                 Global.saveToolbarButtonsVisible("print", toggle);
3430     }
3431     private void toggleTagButton(Boolean toggle) {
3432                 tagButton.setVisible(toggle);
3433                 Global.saveToolbarButtonsVisible("tag", toggle);
3434     }
3435     private void toggleAttributeButton(Boolean toggle) {
3436                 attributeButton.setVisible(toggle);
3437                 Global.saveToolbarButtonsVisible("attribute", toggle);
3438     }
3439     private void toggleEmailButton(Boolean toggle) {
3440                 emailButton.setVisible(toggle);
3441                 Global.saveToolbarButtonsVisible("email", toggle);
3442     }
3443     private void toggleDeleteButton(Boolean toggle) {
3444                 deleteButton.setVisible(toggle);
3445                 Global.saveToolbarButtonsVisible("delete", toggle);
3446     }
3447     private void toggleNewButton(Boolean toggle) {
3448                 newButton.setVisible(toggle);
3449                 Global.saveToolbarButtonsVisible("new", toggle);
3450     }
3451     private void toggleAllNotesButton(Boolean toggle) {
3452                 allNotesButton.setVisible(toggle);
3453                 Global.saveToolbarButtonsVisible("allNotes", toggle);
3454     }
3455     @SuppressWarnings("unused")
3456         private void toggleSearchClearButton(Boolean toggle) {
3457                 searchClearButton.setVisible(toggle);
3458                 Global.saveToolbarButtonsVisible("searchClear", toggle);
3459     }
3460
3461
3462
3463
3464
3465     @SuppressWarnings("unused")
3466         private void updateSyncButton() {
3467
3468         if (syncIcons == null) {
3469                 syncIcons = new ArrayList<QPixmap>();
3470                 double angle = 0.0;
3471                 synchronizeIconAngle = 0;
3472                 QPixmap pix = new QPixmap(iconPath+"synchronize.png");
3473                 syncIcons.add(pix);
3474                 for (int i=0; i<=360; i++) {
3475                         QPixmap rotatedPix = new QPixmap(pix.size());
3476                         QPainter p = new QPainter(rotatedPix);
3477                 rotatedPix.fill(toolBar.palette().color(ColorRole.Button));
3478                 QSize size = pix.size();
3479                 p.translate(size.width()/2, size.height()/2);
3480                 angle = angle+1.0;
3481                 p.rotate(angle);
3482                 p.setBackgroundMode(BGMode.OpaqueMode);
3483                 p.translate(-size.width()/2, -size.height()/2);
3484                 p.drawPixmap(0,0, pix);
3485                 p.end();
3486                 syncIcons.add(rotatedPix);
3487                 }
3488         }
3489
3490         synchronizeIconAngle++;
3491         if (synchronizeIconAngle > 359)
3492                 synchronizeIconAngle=0;
3493         synchronizeButton.setIcon(syncIcons.get(synchronizeIconAngle));
3494
3495     }
3496     // Synchronize with Evernote
3497
3498         private void evernoteSync() {
3499         logger.log(logger.HIGH, "Entering NeverNote.evernoteSync");
3500         if (!Global.isConnected)
3501                 remoteConnect();
3502         if (Global.isConnected)
3503                 synchronizeAnimationTimer.start(5);
3504 //                      synchronizeAnimationTimer.start(200);
3505         syncTimer();
3506         logger.log(logger.HIGH, "Leaving NeverNote.evernoteSync");
3507     }
3508     private void updateQuotaBar() {
3509         long limit = Global.getUploadLimit();
3510         long amount = Global.getUploadAmount();
3511         if (amount>0 && limit>0) {
3512                 int percent =(int)(amount*100/limit);
3513                 quotaBar.setValue(percent);
3514         } else
3515                 quotaBar.setValue(0);
3516     }
3517         // Zoom changed
3518     @SuppressWarnings("unused")
3519         private void zoomChanged() {
3520         browserWindow.getBrowser().setZoomFactor(new Double(zoomSpinner.value())/100);
3521     }
3522
3523     //****************************************************************
3524     //****************************************************************
3525     //* System Tray functions
3526     //****************************************************************
3527     //****************************************************************
3528         private void trayToggleVisible() {
3529         if (isVisible()) {
3530                 hide();
3531         } else {
3532                 show();
3533                 if (windowMaximized)
3534                         showMaximized();
3535                 else
3536                         showNormal();
3537                 raise();
3538         }
3539     }
3540     @SuppressWarnings("unused")
3541         private void trayActivated(QSystemTrayIcon.ActivationReason reason) {
3542         if (reason == QSystemTrayIcon.ActivationReason.DoubleClick) {
3543                 String name = QSystemTrayIcon.MessageIcon.resolve(reason.value()).name();
3544                 trayToggleVisible();
3545         }
3546     }
3547
3548
3549     //***************************************************************
3550     //***************************************************************
3551     //** These functions deal with the trash tree
3552     //***************************************************************
3553     //***************************************************************
3554     // Setup the tree containing the trash.
3555     @SuppressWarnings("unused")
3556         private void trashTreeSelection() {
3557         logger.log(logger.HIGH, "Entering NeverNote.trashTreeSelection");
3558
3559         clearNotebookFilter();
3560         clearTagFilter();
3561         clearAttributeFilter();
3562         clearSavedSearchFilter();
3563
3564         String tempGuid = currentNoteGuid;
3565
3566 //      currentNoteGuid = "";
3567         currentNote = new Note();
3568         selectedNoteGUIDs.clear();
3569         listManager.getSelectedNotebooks().clear();
3570         listManager.getSelectedTags().clear();
3571         listManager.setSelectedSavedSearch("");
3572         browserWindow.clear();
3573
3574         // toggle the add buttons
3575         newButton.setEnabled(!newButton.isEnabled());
3576         menuBar.noteAdd.setEnabled(newButton.isEnabled());
3577         menuBar.noteAdd.setVisible(true);
3578
3579         List<QTreeWidgetItem> selections = trashTree.selectedItems();
3580         if (selections.size() == 0) {
3581                 currentNoteGuid = trashNoteGuid;
3582                         trashNoteGuid = tempGuid;
3583                 Global.showDeleted = false;
3584                 menuBar.noteRestoreAction.setEnabled(false);
3585                 menuBar.noteRestoreAction.setVisible(false);
3586                         // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
3587                         rensoNoteListDock.setEnabled(true);
3588         }
3589         else {
3590                 trashNoteGuid = tempGuid;
3591                 currentNoteGuid = trashNoteGuid;
3592                 menuBar.noteRestoreAction.setEnabled(true);
3593                 menuBar.noteRestoreAction.setVisible(true);
3594                 // ICHANGED ゴミ箱を開く。連想ノートリストをOFFに。
3595                 rensoNoteListDock.setEnabled(false);
3596
3597                 Global.showDeleted = true;
3598         }
3599
3600         menuBar.noteAddNewTab.setEnabled(newButton.isEnabled());
3601                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
3602                         menuBar.noteAddNewTab.setEnabled(false);
3603                 }
3604
3605         listManager.loadNotesIndex();
3606         noteIndexUpdated(false);
3607 ////            browserWindow.setEnabled(newButton.isEnabled());
3608         browserWindow.setReadOnly(!newButton.isEnabled());
3609         logger.log(logger.HIGH, "Leaving NeverNote.trashTreeSelection");
3610     }
3611     // Empty the trash file
3612     @SuppressWarnings("unused")
3613         private void emptyTrash() {
3614 //      browserWindow.clear();
3615         logger.log(logger.EXTREME, "Emptying Trash");
3616         listManager.emptyTrash();
3617         logger.log(logger.EXTREME, "Resetting view after trash empty");
3618         if (trashTree.selectedItems().size() > 0) {
3619                 listManager.getSelectedNotebooks().clear();
3620                 listManager.getSelectedTags().clear();
3621                 listManager.setSelectedSavedSearch("");
3622                 newButton.setEnabled(!newButton.isEnabled());
3623                 menuBar.noteAdd.setEnabled(newButton.isEnabled());
3624                 menuBar.noteAddNewTab.setEnabled(newButton.isEnabled());
3625                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
3626                         menuBar.noteAddNewTab.setEnabled(false);
3627                 }
3628                 menuBar.noteAdd.setVisible(true);
3629                 browserWindow.clear();
3630
3631                 clearTagFilter();
3632                 clearNotebookFilter();
3633                 clearSavedSearchFilter();
3634                 clearAttributeFilter();
3635
3636                 Global.showDeleted = false;
3637                 menuBar.noteRestoreAction.setEnabled(false);
3638                 menuBar.noteRestoreAction.setVisible(false);
3639
3640                 listManager.loadNotesIndex();
3641                 noteIndexUpdated(false);
3642
3643                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
3644                 if (!rensoNoteListDock.isEnabled()) {
3645                         rensoNoteListDock.setEnabled(true);
3646                 }
3647         }
3648    }
3649     // Show/Hide trash window
3650         @SuppressWarnings("unused")
3651         private void toggleTrashWindow() {
3652                 logger.log(logger.HIGH, "Entering NeverNote.toggleTrashWindow");
3653         if (trashTree.isVisible())
3654                 trashTree.hide();
3655         else
3656                 trashTree.show();
3657         menuBar.hideTrash.setChecked(trashTree.isVisible());
3658
3659                 Global.saveWindowVisible("trashTree", trashTree.isVisible());
3660         logger.log(logger.HIGH, "Leaving NeverNote.trashWindow");
3661     }
3662         private void clearTrashFilter() {
3663                 Global.showDeleted = false;
3664         newButton.setEnabled(true);
3665         menuBar.noteAdd.setEnabled(true);
3666                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
3667                         menuBar.noteAddNewTab.setEnabled(false);
3668                 } else {
3669                         menuBar.noteAddNewTab.setEnabled(true);
3670                 }
3671         menuBar.noteAdd.setVisible(true);
3672                 trashTree.blockSignals(true);
3673                 trashTree.clearSelection();
3674                 trashTree.blockSignals(false);
3675
3676         }
3677
3678
3679     //***************************************************************
3680     //***************************************************************
3681     //** These functions deal with connection settings
3682     //***************************************************************
3683     //***************************************************************
3684         // SyncRunner had a problem and things are disconnected
3685         @SuppressWarnings("unused")
3686         private void remoteErrorDisconnect() {
3687                 menuBar.connectAction.setText(tr("Connect"));
3688                 menuBar.connectAction.setToolTip(tr("Connect to Evernote"));
3689                 menuBar.synchronizeAction.setEnabled(false);
3690                 Global.isConnected = false;
3691                 synchronizeAnimationTimer.stop();
3692                 return;
3693         }
3694         // Do a manual connect/disconnect
3695     private void remoteConnect() {
3696
3697         logger.log(logger.HIGH, "Entering NeverNote.remoteConnect");
3698
3699         // If we are already connected, we just disconnect
3700         if (Global.isConnected) {
3701                 Global.isConnected = false;
3702                 syncRunner.enDisconnect();
3703                 setupConnectMenuOptions();
3704                 setupOnlineMenu();
3705                 return;
3706         }
3707
3708         OAuthTokenizer tokenizer = new OAuthTokenizer();
3709         AESEncrypter aes = new AESEncrypter();
3710         try {
3711                         aes.decrypt(new FileInputStream(Global.getFileManager().getHomeDirFile("oauth.txt")));
3712                 } catch (FileNotFoundException e) {
3713                         // File not found, so we'll just get empty strings anyway.
3714                 }
3715
3716
3717                 if (Global.getProxyValue("url").equals("")) {
3718                         System.setProperty("http.proxyHost","") ;
3719                         System.setProperty("http.proxyPort", "") ;
3720                         System.setProperty("https.proxyHost","") ;
3721                         System.setProperty("https.proxyPort", "") ;
3722                 } else {
3723                         // PROXY
3724                         System.setProperty("http.proxyHost",Global.getProxyValue("url")) ;
3725                         System.setProperty("http.proxyPort", Global.getProxyValue("port")) ;
3726                         System.setProperty("https.proxyHost",Global.getProxyValue("url")) ;
3727                         System.setProperty("https.proxyPort", Global.getProxyValue("port")) ;
3728
3729                         if (Global.getProxyValue("userid").equals("")) {
3730                                 Authenticator.setDefault(new Authenticator() {
3731                         @Override
3732                         protected PasswordAuthentication getPasswordAuthentication() {
3733                                 return new
3734                                 PasswordAuthentication(Global.getProxyValue("userid"),Global.getProxyValue("password").toCharArray());
3735                                 }
3736                         });
3737                 }
3738         }
3739
3740                 syncRunner.userStoreUrl = Global.userStoreUrl;
3741                 syncRunner.noteStoreUrl = Global.noteStoreUrl;
3742                 syncRunner.noteStoreUrlBase = Global.noteStoreUrlBase;
3743
3744
3745
3746                 String authString = aes.getString();
3747                 if (!authString.equals("")) {
3748                         tokenizer.tokenize(authString);
3749                         syncRunner.authToken = tokenizer.oauth_token;
3750                 syncRunner.enConnect();
3751                 }
3752
3753                 Global.isConnected = syncRunner.isConnected;
3754
3755                 if (!Global.isConnected) {
3756                 OAuthWindow window = new OAuthWindow(logger);
3757                 if (window.error) {
3758                         setMessage(window.errorMessage);
3759                         return;
3760                 }
3761                 window.exec();
3762                 if (window.error) {
3763                         setMessage(window.errorMessage);
3764                         return;
3765                         }
3766                 tokenizer.tokenize(window.response);
3767                 if (tokenizer.oauth_token.equals("")) {
3768                         setMessage(tr("Invalid authorization token received."));
3769                         return;
3770                 }
3771                 aes.setString(window.response);
3772                 try {
3773                                 aes.encrypt(new FileOutputStream(Global.getFileManager().getHomeDirFile("oauth.txt")));
3774                         } catch (FileNotFoundException e) {
3775                                 // TODO Auto-generated catch block
3776                                 e.printStackTrace();
3777                         }
3778                 syncRunner.authToken = tokenizer.oauth_token;
3779                         syncRunner.enConnect();
3780                         Global.isConnected = syncRunner.isConnected;
3781                 }
3782 //              Global.username = syncRunner.username;
3783
3784                 if (!Global.isConnected)
3785                         return;
3786                 setupOnlineMenu();
3787                 setupConnectMenuOptions();
3788                 logger.log(logger.HIGH, "Leaving NeverNote.remoteConnect");
3789
3790
3791     }
3792     private void setupConnectMenuOptions() {
3793         logger.log(logger.HIGH, "entering NeverNote.setupConnectMenuOptions");
3794                 if (!Global.isConnected) {
3795                         menuBar.connectAction.setText(tr("Connect"));
3796                         menuBar.connectAction.setToolTip(tr("Connect to Evernote"));
3797                         menuBar.synchronizeAction.setEnabled(false);
3798                 } else {
3799                         menuBar.connectAction.setText(tr("Disconnect"));
3800                         menuBar.connectAction.setToolTip(tr("Disconnect from Evernote"));
3801                         menuBar.synchronizeAction.setEnabled(true);
3802                 }
3803                 logger.log(logger.HIGH, "Leaving NeverNote.setupConnectionMenuOptions");
3804     }
3805
3806
3807
3808     //***************************************************************
3809     //***************************************************************
3810     //** These functions deal with the GUI Attribute tree
3811     //***************************************************************
3812     //***************************************************************
3813     @SuppressWarnings("unused")
3814         private void attributeTreeClicked(QTreeWidgetItem item, Integer integer) {
3815
3816 //      clearTagFilter();
3817 //      clearNotebookFilter();
3818         clearTrashFilter();
3819 //      clearSavedSearchFilter();
3820
3821                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
3822                 if (!rensoNoteListDock.isEnabled()) {
3823                         rensoNoteListDock.setEnabled(true);
3824                 }
3825
3826         if (attributeTreeSelected == null || item.nativeId() != attributeTreeSelected.nativeId()) {
3827                 if (item.childCount() > 0) {
3828                         item.setSelected(false);
3829                 } else {
3830                 Global.createdBeforeFilter.reset();
3831                 Global.createdSinceFilter.reset();
3832                 Global.changedBeforeFilter.reset();
3833                 Global.changedSinceFilter.reset();
3834                 Global.containsFilter.reset();
3835                         attributeTreeSelected = item;
3836                         DateAttributeFilterTable f = null;
3837                         f = findDateAttributeFilterTable(item.parent());
3838                         if (f!=null)
3839                                 f.select(item.parent().indexOfChild(item));
3840                         else {
3841                                 Global.containsFilter.select(item.parent().indexOfChild(item));
3842                         }
3843                 }
3844                 listManager.loadNotesIndex();
3845                 noteIndexUpdated(false);
3846                 return;
3847         }
3848                 attributeTreeSelected = null;
3849                 item.setSelected(false);
3850         Global.createdBeforeFilter.reset();
3851         Global.createdSinceFilter.reset();
3852         Global.changedBeforeFilter.reset();
3853         Global.changedSinceFilter.reset();
3854         Global.containsFilter.reset();
3855         listManager.loadNotesIndex();
3856                 noteIndexUpdated(false);
3857     }
3858     // This determines what attribute filter we need, depending upon the selection
3859     private DateAttributeFilterTable findDateAttributeFilterTable(QTreeWidgetItem w) {
3860                 if (w.parent() != null && w.childCount() > 0) {
3861                         QTreeWidgetItem parent = w.parent();
3862                         if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Created &&
3863                                 w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Since)
3864                                         return Global.createdSinceFilter;
3865                         if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Created &&
3866                         w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Before)
3867                                         return Global.createdBeforeFilter;
3868                         if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.LastModified &&
3869                         w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Since)
3870                                         return Global.changedSinceFilter;
3871                 if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.LastModified &&
3872                         w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Before)
3873                                                 return Global.changedBeforeFilter;
3874                 }
3875                 return null;
3876     }
3877
3878     // Show/Hide attribute search window
3879         @SuppressWarnings("unused")
3880         private void toggleAttributesWindow() {
3881                 logger.log(logger.HIGH, "Entering NeverNote.toggleAttributesWindow");
3882         if (attributeTree.isVisible())
3883                 attributeTree.hide();
3884         else
3885                 attributeTree.show();
3886         menuBar.hideAttributes.setChecked(attributeTree.isVisible());
3887
3888                 Global.saveWindowVisible("attributeTree", attributeTree.isVisible());
3889         logger.log(logger.HIGH, "Leaving NeverNote.toggleAttributeWindow");
3890     }
3891         private void clearAttributeFilter() {
3892         Global.createdBeforeFilter.reset();
3893         Global.createdSinceFilter.reset();
3894         Global.changedBeforeFilter.reset();
3895         Global.changedSinceFilter.reset();
3896         Global.containsFilter.reset();
3897         attributeTreeSelected = null;
3898                 attributeTree.blockSignals(true);
3899                 attributeTree.clearSelection();
3900                 attributeTree.blockSignals(false);
3901         }
3902
3903
3904     //***************************************************************
3905     //***************************************************************
3906     //** These functions deal with the GUI Note index table
3907     //***************************************************************
3908     //***************************************************************
3909     // Initialize the note list table
3910         private void initializeNoteTable() {
3911                 logger.log(logger.HIGH, "Entering NeverNote.initializeNoteTable");
3912                 noteTableView.setSelectionMode(QAbstractItemView.SelectionMode.ExtendedSelection);
3913                 noteTableView.selectionModel().selectionChanged.connect(this, "noteTableSelection()");
3914                 logger.log(logger.HIGH, "Leaving NeverNote.initializeNoteTable");
3915         }
3916     // Show/Hide trash window
3917         @SuppressWarnings("unused")
3918         private void toggleNoteListWindow() {
3919                 logger.log(logger.HIGH, "Entering NeverNote.toggleNoteListWindow");
3920         if (noteTableView.isVisible())
3921                 noteTableView.hide();
3922         else
3923                 noteTableView.show();
3924         menuBar.hideNoteList.setChecked(noteTableView.isVisible());
3925
3926                 Global.saveWindowVisible("noteList", noteTableView.isVisible());
3927         logger.log(logger.HIGH, "Leaving NeverNote.toggleNoteListWindow");
3928     }
3929         // Handle the event that a user selects a note from the table
3930     @SuppressWarnings("unused")
3931         private void noteTableSelection() {
3932                 logger.log(logger.HIGH, "Entering NeverNote.noteTableSelection");
3933
3934                 saveNote();
3935
3936                 // ICHANGED
3937                 // 右クリックだったときの処理
3938                 if (QApplication.mouseButtons().isSet(MouseButton.RightButton)) {
3939                         // 選択されたノートのguidをselectedNoteGUIDsにセット
3940                         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
3941                         if(selections.size() > 0){
3942                                 selectedNoteGUIDs.clear();
3943                                 for(int i = 0; i < selections.size(); i++){
3944                                         int row = selections.get(i).row();
3945                                         QModelIndex index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
3946                                         SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
3947                                         selectedNoteGUIDs.add((String) ix.values().toArray()[0]);
3948                                 }
3949                         }
3950                         return;
3951                 }
3952
3953                 // If we have more than one selection, then set the merge note action to true.
3954         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
3955                 if (selections.size() > 1)
3956                 menuBar.noteMergeAction.setEnabled(true);
3957                 else
3958                         menuBar.noteMergeAction.setEnabled(false);
3959
3960                 // If the ctrl key is pressed, then they are selecting multiple
3961                 // entries and we don't want to change the currently viewed note.
3962                 // ICHANGED
3963                 // Shiftキーを押しながらの場合の処理も追加
3964                 if ((QApplication.keyboardModifiers().isSet(KeyboardModifier.ControlModifier) ||
3965                                 QApplication.keyboardModifiers().isSet(KeyboardModifier.ShiftModifier)) &&
3966                                 QApplication.mouseButtons().isSet(MouseButton.LeftButton)){
3967                         selectedNoteGUIDs.clear();
3968                 for (int i=0; i<selections.size(); i++) {
3969                         int row = selections.get(i).row();
3970                         QModelIndex index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
3971                         SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
3972                         selectedNoteGUIDs.add((String)ix.values().toArray()[0]);
3973                 }
3974                         return;
3975                 }
3976
3977                 // ICHANGED たぶんこれは不要
3978                 // IFIXED ?
3979                 /*if (historyGuids.size() == 0) {
3980                         historyGuids.add(currentNoteGuid);
3981                         historyPosition = 1;
3982                 }*/
3983
3984         noteTableView.showColumn(Global.noteTableGuidPosition);
3985
3986         if (!Global.isColumnVisible("guid"))
3987                 noteTableView.hideColumn(Global.noteTableGuidPosition);
3988
3989         if (selections.size() > 0) {
3990                 QModelIndex index;
3991                 menuBar.noteDuplicateAction.setEnabled(true);
3992                 menuBar.noteOnlineHistoryAction.setEnabled(true);
3993                 menuBar.noteMergeAction.setEnabled(true);
3994                 selectedNoteGUIDs.clear();
3995                 if (currentNoteGuid != null && !currentNoteGuid.equals("") && !Global.showDeleted) {
3996                         menuBar.noteAddNewTab.setEnabled(true);
3997                 }
3998                 if (selections.size() != 1 || Global.showDeleted) {
3999                         menuBar.noteDuplicateAction.setEnabled(false);
4000                 }
4001                 if (selections.size() != 1 || !Global.isConnected) {
4002                         menuBar.noteOnlineHistoryAction.setEnabled(false);
4003                 }
4004                 if (selections.size() == 1) {
4005                         menuBar.noteMergeAction.setEnabled(false);
4006                 }
4007                 for (int i=0; i<selections.size(); i++) {
4008                         int row = selections.get(i).row();
4009                         if (row == 0)
4010                                 upButton.setEnabled(false);
4011                         else
4012                                 upButton.setEnabled(true);
4013                         if (row < listManager.getNoteTableModel().rowCount()-1)
4014                                 downButton.setEnabled(true);
4015                         else
4016                                 downButton.setEnabled(false);
4017                         index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
4018                         SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
4019
4020                         currentNoteGuid = (String)ix.values().toArray()[0];
4021                         selectedNoteGUIDs.add(currentNoteGuid);
4022                 }
4023         }
4024
4025         nextButton.setEnabled(true);
4026                 prevButton.setEnabled(true);
4027
4028                 // ICHANGED
4029                 int currentIndex = tabBrowser.currentIndex();
4030                 ArrayList<String> histGuids = historyGuids.get(currentIndex);
4031                 int histPosition = historyPosition.get(currentIndex);
4032                 boolean fromHist = fromHistory.get(currentIndex);
4033
4034                 // ICHANGED
4035                 if (!fromHist) {
4036                         int endPosition = histGuids.size() - 1;
4037
4038                         for (int j = histPosition; j <= endPosition; j++) {
4039                                 histGuids.remove(histGuids.size() - 1);
4040                         }
4041                         histGuids.add(currentNoteGuid);
4042                         historyPosition.put(currentIndex, histGuids.size());
4043                         histPosition = histGuids.size();
4044                 }
4045                 if (histPosition <= 1){
4046                         prevButton.setEnabled(false);
4047                 }
4048                 if (histPosition == histGuids.size())
4049                         nextButton.setEnabled(false);
4050                 fromHistory.put(currentIndex, false);
4051                 fromHist = false;
4052
4053         scrollToGuid(currentNoteGuid);
4054         refreshEvernoteNote(true);
4055
4056                 // ICHANGED
4057                 if (currentNoteGuid != null && !currentNoteGuid.equals("")) {
4058                         if (!Global.showDeleted) { // ゴミ箱じゃなければ
4059                                 addBrowseHistory();
4060                         }
4061                 }
4062
4063                 // ICHANGED
4064                 // 連想ノートリストを更新
4065                 rensoNoteList.refreshRensoNoteList(currentNoteGuid);
4066
4067                 waitCursor(false);
4068                 logger.log(logger.HIGH, "Leaving NeverNote.noteTableSelection");
4069     }
4070
4071
4072         // ICHANGED
4073     // 複数ノートの同時閲覧履歴をデータベースに保存
4074         private void addBrowseHistory() {
4075                 // このノートと他のタブウィンドウノートの関連性を内部データベースのHistoryテーブルに登録
4076                 if (tabWindows.size() >= 2) {
4077                         Iterator<Integer> it = tabWindows.keySet().iterator();
4078                         while (it.hasNext()) {
4079                                 int tabIndex = it.next();
4080                                 String nextGuid = ((TabBrowse) tabBrowser.widget(tabIndex)).getBrowserWindow().getNote().getGuid();
4081                                 // guid1=guid2のデータは登録しない
4082                                 if (!currentNoteGuid.equals(nextGuid)) {
4083                                         conn.getHistoryTable().addHistory("browse", currentNoteGuid, nextGuid);
4084                                 }
4085                         }
4086                 }
4087                 // このノートと他の外部ウィンドウノートの関連性を内部データベースのHistoryテーブルに登録
4088                 if (externalWindows.size() >= 1) {
4089                         Iterator<String> it = externalWindows.keySet().iterator();
4090                         while (it.hasNext()) {
4091                                 String nextGuid = it.next();
4092                                 // guid1=guid2のデータは登録しない
4093                                 if (!currentNoteGuid.equals(nextGuid)) {
4094                                         conn.getHistoryTable().addHistory("browse", currentNoteGuid, nextGuid);
4095                                 }
4096                         }
4097                 }
4098         }
4099
4100         // Trigger a refresh when the note db has been updated
4101         private void noteIndexUpdated(boolean reload) {
4102                 logger.log(logger.HIGH, "Entering NeverNote.noteIndexUpdated");
4103                 saveNote();
4104         refreshEvernoteNoteList();
4105         logger.log(logger.HIGH, "Calling note table reload in NeverNote.noteIndexUpdated() - "+reload);
4106         noteTableView.load(reload);
4107         if (currentNoteGuid == null || currentNoteGuid.equals("")) {
4108                 int pos;
4109                 if (noteTableView.proxyModel.sortOrder() == SortOrder.AscendingOrder)
4110                         pos = noteTableView.proxyModel.rowCount();
4111                 else
4112                         pos = 1;
4113                 if (noteTableView.proxyModel.rowCount() == 0)
4114                         pos = 0;
4115                 if (pos>0)      {
4116                         QModelIndex i = noteTableView.proxyModel.index(pos-1, Global.noteTableGuidPosition);
4117                         if (i!=null) {
4118                                 currentNoteGuid = (String)i.data();
4119                         }
4120                 }
4121         }
4122                 if (!noteTableView.isColumnHidden(Global.noteTableGuidPosition))
4123                         showColumns();
4124                 scrollToGuid(currentNoteGuid);
4125                 logger.log(logger.HIGH, "Leaving NeverNote.noteIndexUpdated");
4126     }
4127         // Called when the list of notes is updated
4128     private void refreshEvernoteNoteList() {
4129         logger.log(logger.HIGH, "Entering NeverNote.refreshEvernoteNoteList");
4130         browserWindow.setDisabled(false);
4131                 if (selectedNoteGUIDs == null)
4132                         selectedNoteGUIDs = new ArrayList<String>();
4133                 selectedNoteGUIDs.clear();  // clear out old entries
4134
4135                 String saveCurrentNoteGuid = new String();
4136                 String tempNoteGuid = new String();
4137
4138                 // ICHANGED
4139                 int currentIndex = tabBrowser.currentIndex();
4140                 ArrayList<String> histGuids = historyGuids.get(currentIndex);
4141                 histGuids.clear();
4142                 historyPosition.put(currentIndex, 0);
4143
4144                 prevButton.setEnabled(false);
4145                 nextButton.setEnabled(false);
4146
4147                 if (currentNoteGuid == null)
4148                         currentNoteGuid = new String();
4149
4150                 //determine current note guid
4151                 for (Note note : listManager.getNoteIndex()) {
4152                         tempNoteGuid = note.getGuid();
4153                         if (currentNoteGuid.equals(tempNoteGuid)) {
4154                                 saveCurrentNoteGuid = tempNoteGuid;
4155                         }
4156                 }
4157
4158                 if (listManager.getNoteIndex().size() == 0) {
4159                         currentNoteGuid = "";
4160                         currentNote = null;
4161                         browserWindow.clear();
4162                         browserWindow.setDisabled(true);
4163                         waitCursor(false);
4164                 }
4165
4166                 if (Global.showDeleted && listManager.getNoteIndex().size() > 0 && saveCurrentNoteGuid.equals("")) {
4167                         currentNoteGuid = listManager.getNoteIndex().get(0).getGuid();
4168                         saveCurrentNoteGuid = currentNoteGuid;
4169                         refreshEvernoteNote(true);
4170                 }
4171
4172                 if (!saveCurrentNoteGuid.equals("")) {
4173                         refreshEvernoteNote(false);
4174                 } else {
4175                                 currentNoteGuid = "";
4176                 }
4177                 reloadTagTree(false);
4178
4179                 logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNoteList");
4180         }
4181
4182         // ICHANGED
4183         // Called when the previous arrow button is clicked
4184         @SuppressWarnings("unused")
4185         private void previousViewedAction() {
4186                 int currentIndex = tabBrowser.currentIndex();
4187                 ArrayList<String> histGuids = historyGuids.get(currentIndex);
4188                 int histPosition = historyPosition.get(currentIndex);
4189                 boolean fromHist = fromHistory.get(currentIndex);
4190                 if (!prevButton.isEnabled())
4191                         return;
4192                 if (histPosition == 0)
4193                         return;
4194                 histPosition--;
4195                 historyPosition.put(currentIndex, histPosition);
4196                 if (histPosition <= 0)
4197                         return;
4198                 String historyGuid = histGuids.get(histPosition - 1);
4199                 fromHistory.put(currentIndex, true);
4200                 fromHist = true;
4201                 for (int i = 0; i < noteTableView.model().rowCount(); i++) {
4202                         QModelIndex modelIndex = noteTableView.model().index(i,
4203                                         Global.noteTableGuidPosition);
4204                         if (modelIndex != null) {
4205                                 SortedMap<Integer, Object> ix = noteTableView.model().itemData(
4206                                                 modelIndex);
4207                                 String tableGuid = (String) ix.values().toArray()[0];
4208                                 if (tableGuid.equals(historyGuid)) {
4209                                         noteTableView.selectRow(i);
4210                                         return;
4211                                 }
4212                         }
4213                 }
4214         }
4215
4216     @SuppressWarnings("unused")
4217         private void nextViewedAction() {
4218         if (!nextButton.isEnabled())
4219                 return;
4220                 // ICHANGED
4221                 int currentIndex = tabBrowser.currentIndex();
4222                 ArrayList<String> histGuids = historyGuids.get(currentIndex);
4223                 int histPosition = historyPosition.get(currentIndex);
4224                 boolean fromHist = fromHistory.get(currentIndex);
4225                 String historyGuid = histGuids.get(histPosition);
4226                 histPosition++;
4227                 historyPosition.put(currentIndex, histPosition);
4228                 fromHistory.put(currentIndex, true);
4229                 fromHist = true;
4230                 for (int i = 0; i < noteTableView.model().rowCount(); i++) {
4231                         QModelIndex modelIndex = noteTableView.model().index(i,
4232                                         Global.noteTableGuidPosition);
4233                         if (modelIndex != null) {
4234                                 SortedMap<Integer, Object> ix = noteTableView.model().itemData(
4235                                                 modelIndex);
4236                                 String tableGuid = (String) ix.values().toArray()[0];
4237                                 if (tableGuid.equals(historyGuid)) {
4238                                         noteTableView.selectRow(i);
4239                                         return;
4240                                 }
4241                         }
4242                 }
4243     }
4244     // Called when the up arrow is clicked
4245     @SuppressWarnings("unused")
4246         private void upAction() {
4247         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
4248         int row = selections.get(0).row();
4249         if (row > 0) {
4250                 noteTableView.selectRow(row-1);
4251         }
4252     }
4253     // Called when the down arrow is clicked
4254     @SuppressWarnings("unused")
4255         private void downAction() {
4256         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
4257         int row = selections.get(0).row();
4258         int max = listManager.getNoteTableModel().rowCount();
4259         if (row < max-1) {
4260                 noteTableView.selectRow(row+1);
4261         }
4262     }
4263     // Update a tag string for a specific note in the list
4264     @SuppressWarnings("unused")
4265         private void updateListTags(String guid, List<String> tags) {
4266         logger.log(logger.HIGH, "Entering NeverNote.updateListTags");
4267         StringBuffer tagBuffer = new StringBuffer();
4268         for (int i=0; i<tags.size(); i++) {
4269                 tagBuffer.append(tags.get(i));
4270                 if (i<tags.size()-1)
4271                         tagBuffer.append(", ");
4272         }
4273
4274         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4275                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4276                 if (modelIndex != null) {
4277                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4278                         String tableGuid =  (String)ix.values().toArray()[0];
4279                         if (tableGuid.equals(guid)) {
4280                                 listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition,tagBuffer.toString());
4281                                 listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4282                                 noteTableView.proxyModel.invalidate();
4283                                 return;
4284                         }
4285                 }
4286         }
4287         logger.log(logger.HIGH, "Leaving NeverNote.updateListTags");
4288     }
4289     // Update a title for a specific note in the list
4290     @SuppressWarnings("unused")
4291         private void updateListAuthor(String guid, String author) {
4292         logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
4293
4294         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4295                 //QModelIndex modelIndex =  noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
4296                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4297                 if (modelIndex != null) {
4298                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4299                         String tableGuid =  (String)ix.values().toArray()[0];
4300                         if (tableGuid.equals(guid)) {
4301                                 listManager.getNoteTableModel().setData(i, Global.noteTableAuthorPosition,author);
4302                                 listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4303                                 noteTableView.proxyModel.invalidate();
4304                                 return;
4305                         }
4306                 }
4307         }
4308
4309         logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
4310     }
4311         private void updateListNoteNotebook(String guid, String notebook) {
4312         logger.log(logger.HIGH, "Entering NeverNote.updateListNoteNotebook");
4313         listManager.getNoteTableModel().updateNoteSyncStatus(guid, false);
4314         logger.log(logger.HIGH, "Leaving NeverNote.updateListNoteNotebook");
4315     }
4316     // Update a title for a specific note in the list
4317     @SuppressWarnings("unused")
4318         private void updateListSourceUrl(String guid, String url) {
4319         logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
4320
4321         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4322                 //QModelIndex modelIndex =  noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
4323                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4324                 if (modelIndex != null) {
4325 //                      SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(modelIndex);
4326                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4327                         String tableGuid =  (String)ix.values().toArray()[0];
4328                         if (tableGuid.equals(guid)) {
4329                                 listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4330                                 listManager.getNoteTableModel().setData(i, Global.noteTableSourceUrlPosition,url);
4331                                 noteTableView.proxyModel.invalidate();
4332                                 return;
4333                         }
4334                 }
4335         }
4336         logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
4337     }
4338         @SuppressWarnings("unused")
4339         private void updateListGuid(String oldGuid, String newGuid) {
4340         logger.log(logger.HIGH, "Entering NeverNote.updateListTitle");
4341
4342         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4343                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4344                 if (modelIndex != null) {
4345                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4346                         String tableGuid =  (String)ix.values().toArray()[0];
4347                         if (tableGuid.equals(oldGuid)) {
4348                                 listManager.getNoteTableModel().setData(i, Global.noteTableGuidPosition,newGuid);
4349                                 //listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4350                                 return;
4351                         }
4352                 }
4353         }
4354         logger.log(logger.HIGH, "Leaving NeverNote.updateListTitle");
4355     }
4356         private void updateListTagName(String guid) {
4357         logger.log(logger.HIGH, "Entering NeverNote.updateTagName");
4358
4359                 for (int j=0; j<listManager.getNoteIndex().size(); j++) {
4360                         if (listManager.getNoteIndex().get(j).getTagGuids().contains(guid)) {
4361                                 String newName = listManager.getTagNamesForNote(listManager.getNoteIndex().get(j));
4362
4363                                 for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4364                                         QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4365                                         if (modelIndex != null) {
4366                                                 SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4367                                                 String noteGuid = (String)ix.values().toArray()[0];
4368                                                 if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
4369                                                         listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
4370                                                         i=listManager.getNoteTableModel().rowCount();
4371                                                 }
4372                                         }
4373                                 }
4374                         }
4375                 }
4376         logger.log(logger.HIGH, "Leaving NeverNote.updateListNotebook");
4377     }
4378         private void removeListTagName(String guid) {
4379         logger.log(logger.HIGH, "Entering NeverNote.updateTagName");
4380
4381                 for (int j=0; j<listManager.getNoteIndex().size(); j++) {
4382                         if (listManager.getNoteIndex().get(j).getTagGuids().contains(guid)) {
4383                                 for (int i=listManager.getNoteIndex().get(j).getTagGuids().size()-1; i>=0; i--) {
4384                                         if (listManager.getNoteIndex().get(j).getTagGuids().get(i).equals(guid))
4385                                                 listManager.getNoteIndex().get(j).getTagGuids().remove(i);
4386                                 }
4387
4388                                 String newName = listManager.getTagNamesForNote(listManager.getNoteIndex().get(j));
4389                                 for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4390                                         QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4391                                         if (modelIndex != null) {
4392                                                 SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4393                                                 String noteGuid = (String)ix.values().toArray()[0];
4394                                                 if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
4395                                                         listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
4396                                                         i=listManager.getNoteTableModel().rowCount();
4397                                                 }
4398                                         }
4399                                 }
4400                         }
4401                 }
4402         logger.log(logger.HIGH, "Leaving NeverNote.updateListNotebook");
4403     }
4404     private void updateListNotebookName(String oldName, String newName) {
4405         logger.log(logger.HIGH, "Entering NeverNote.updateListNotebookName");
4406
4407         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4408                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableNotebookPosition);
4409                 if (modelIndex != null) {
4410                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4411                         String tableName =  (String)ix.values().toArray()[0];
4412                         if (tableName.equalsIgnoreCase(oldName)) {
4413                                 listManager.getNoteTableModel().setData(i, Global.noteTableNotebookPosition, newName);
4414                         }
4415                 }
4416         }
4417         logger.log(logger.HIGH, "Leaving NeverNote.updateListNotebookName");
4418     }
4419     @SuppressWarnings("unused")
4420         private void updateListDateCreated(String guid, QDateTime date) {
4421         logger.log(logger.HIGH, "Entering NeverNote.updateListDateCreated");
4422
4423         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4424                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4425                 if (modelIndex != null) {
4426                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4427                         String tableGuid =  (String)ix.values().toArray()[0];
4428                         if (tableGuid.equals(guid)) {
4429                                 listManager.getNoteTableModel().setData(i, Global.noteTableCreationPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
4430                                 noteTableView.proxyModel.invalidate();
4431                                 return;
4432                         }
4433                 }
4434         }
4435         logger.log(logger.HIGH, "Leaving NeverNote.updateListDateCreated");
4436     }
4437     @SuppressWarnings("unused")
4438         private void updateListDateSubject(String guid, QDateTime date) {
4439         logger.log(logger.HIGH, "Entering NeverNote.updateListDateSubject");
4440
4441         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4442                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4443                 if (modelIndex != null) {
4444                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4445                         String tableGuid =  (String)ix.values().toArray()[0];
4446                         if (tableGuid.equals(guid)) {
4447                                 listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4448                                 listManager.getNoteTableModel().setData(i, Global.noteTableSubjectDatePosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
4449                                 noteTableView.proxyModel.invalidate();
4450                                 return;
4451                         }
4452                 }
4453         }
4454         logger.log(logger.HIGH, "Leaving NeverNote.updateListDateCreated");
4455     }
4456         private void updateListDateChanged(String guid, QDateTime date) {
4457         logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
4458
4459         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4460                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4461                 if (modelIndex != null) {
4462                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4463                         String tableGuid =  (String)ix.values().toArray()[0];
4464                         if (tableGuid.equals(guid)) {
4465                                 listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
4466                                 listManager.getNoteTableModel().setData(i, Global.noteTableChangedPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
4467                                 return;
4468                         }
4469                 }
4470         }
4471         logger.log(logger.HIGH, "Leaving NeverNote.updateListDateChanged");
4472     }
4473     private void updateListDateChanged() {
4474         logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
4475         QDateTime date = new QDateTime(QDateTime.currentDateTime());
4476         updateListDateChanged(currentNoteGuid, date);
4477         logger.log(logger.HIGH, "Leaving NeverNote.updateListDateChanged");
4478     }
4479     // Redo scroll
4480         private void scrollToCurrentGuid() {
4481         //scrollToGuid(currentNoteGuid);
4482         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
4483         if (selections.size() == 0)
4484                 return;
4485         QModelIndex index = selections.get(0);
4486         int row = selections.get(0).row();
4487         String guid = (String)index.model().index(row, Global.noteTableGuidPosition).data();
4488         scrollToGuid(guid);
4489     }
4490         // Scroll to the current GUID in tthe list.
4491     // Scroll to a particular index item
4492     private void scrollToGuid(String guid) {
4493         if (currentNote == null || guid == null)
4494                 return;
4495         if (currentNote.isActive() && Global.showDeleted) {
4496                 for (int i=0; i<listManager.getNoteIndex().size(); i++) {
4497                         if (!listManager.getNoteIndex().get(i).isActive()) {
4498                                 currentNote = listManager.getNoteIndex().get(i);
4499                                 currentNoteGuid =  currentNote.getGuid();
4500                                 i = listManager.getNoteIndex().size();
4501                         }
4502                 }
4503         }
4504         if (!currentNote.isActive() && !Global.showDeleted) {
4505                 for (int i=0; i<listManager.getNoteIndex().size(); i++) {
4506                         if (listManager.getNoteIndex().get(i).isActive()) {
4507                                 currentNote = listManager.getNoteIndex().get(i);
4508                                 currentNoteGuid =  currentNote.getGuid();
4509                                 i = listManager.getNoteIndex().size();
4510                         }
4511                 }
4512         }
4513         QModelIndex index;
4514         for (int i=0; i<noteTableView.model().rowCount(); i++) {
4515                 index = noteTableView.model().index(i, Global.noteTableGuidPosition);
4516                 if (currentNoteGuid.equals(index.data())) {
4517 //                      noteTableView.selectionModel().blockSignals(true);
4518                         noteTableView.selectRow(i);
4519 //                              noteTableView.selectionModel().blockSignals(false);
4520                         noteTableView.scrollTo(index, ScrollHint.EnsureVisible);  // This should work, but it doesn't
4521                                 i=listManager.getNoteTableModel().rowCount();
4522                 }
4523         }
4524         noteTableView.repaint();
4525     }
4526     // Show/Hide columns
4527     private void showColumns() {
4528                 noteTableView.setColumnHidden(Global.noteTableCreationPosition, !Global.isColumnVisible("dateCreated"));
4529                 noteTableView.setColumnHidden(Global.noteTableChangedPosition, !Global.isColumnVisible("dateChanged"));
4530                 noteTableView.setColumnHidden(Global.noteTableSubjectDatePosition, !Global.isColumnVisible("dateSubject"));
4531                 noteTableView.setColumnHidden(Global.noteTableAuthorPosition, !Global.isColumnVisible("author"));
4532                 noteTableView.setColumnHidden(Global.noteTableSourceUrlPosition, !Global.isColumnVisible("sourceUrl"));
4533                 noteTableView.setColumnHidden(Global.noteTableTagPosition, !Global.isColumnVisible("tags"));
4534                 noteTableView.setColumnHidden(Global.noteTableNotebookPosition, !Global.isColumnVisible("notebook"));
4535                 noteTableView.setColumnHidden(Global.noteTableSynchronizedPosition, !Global.isColumnVisible("synchronized"));
4536                 noteTableView.setColumnHidden(Global.noteTableGuidPosition, !Global.isColumnVisible("guid"));
4537                 noteTableView.setColumnHidden(Global.noteTableThumbnailPosition, !Global.isColumnVisible("thumbnail"));
4538                 noteTableView.setColumnHidden(Global.noteTableTitlePosition, !Global.isColumnVisible("title"));
4539                 noteTableView.setColumnHidden(Global.noteTablePinnedPosition, !Global.isColumnVisible("pinned"));
4540     }
4541     // Title color has changed
4542     @SuppressWarnings("unused")
4543         private void titleColorChanged(Integer color) {
4544         logger.log(logger.HIGH, "Entering NeverNote.titleColorChanged");
4545
4546         setNoteDirty();
4547         QColor backgroundColor = new QColor();
4548                 QColor foregroundColor = new QColor(QColor.black);
4549                 backgroundColor.setRgb(color);
4550
4551                 if (backgroundColor.rgb() == QColor.black.rgb() || backgroundColor.rgb() == QColor.blue.rgb())
4552                         foregroundColor.setRgb(QColor.white.rgb());
4553
4554                 if (selectedNoteGUIDs.size() == 0)
4555                         selectedNoteGUIDs.add(currentNoteGuid);
4556
4557         for (int j=0; j<selectedNoteGUIDs.size(); j++) {
4558                 for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
4559                         QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
4560                         if (modelIndex != null) {
4561                                 SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
4562                                 String tableGuid =  (String)ix.values().toArray()[0];
4563                                 if (tableGuid.equals(selectedNoteGUIDs.get(j))) {
4564                                         for (int k=0; k<Global.noteTableColumnCount; k++) {
4565                                                 listManager.getNoteTableModel().setData(i, k, backgroundColor, Qt.ItemDataRole.BackgroundRole);
4566                                                 listManager.getNoteTableModel().setData(i, k, foregroundColor, Qt.ItemDataRole.ForegroundRole);
4567                                                 listManager.updateNoteTitleColor(selectedNoteGUIDs.get(j), backgroundColor.rgb());
4568                                         }
4569                                         i=listManager.getNoteTableModel().rowCount();
4570                                 }
4571                         }
4572                 }
4573         }
4574         logger.log(logger.HIGH, "Leaving NeverNote.titleColorChanged");
4575     }
4576     // A note has been pinned or unpinned
4577         @SuppressWarnings("unused")
4578         private void notePinned() {
4579                 logger.log(logger.EXTREME, "Entering NeverNote.notePinned()");
4580                 setNoteDirty();
4581
4582         for (int j=0; j<selectedNoteGUIDs.size(); j++) {
4583                 NoteMetadata meta = listManager.getNoteMetadata().get(selectedNoteGUIDs.get(j));
4584                 boolean pinned = !meta.isPinned();
4585                 meta.setPinned(pinned);   // Toggle the pinned/unpinned
4586
4587                 // Update the list & table
4588                 listManager.updateNoteMetadata(meta);
4589                 noteTableView.proxyModel.addGuid(selectedNoteGUIDs.get(j), meta);
4590         }
4591                 logger.log(logger.EXTREME, "Leaving NeverNote.notePinned()");
4592     }
4593     // Wide list was chosen
4594     public void narrowListView() {
4595         saveNoteColumnPositions();
4596         saveNoteIndexWidth();
4597         saveWindowState();
4598                 int sortCol = noteTableView.proxyModel.sortColumn();
4599                 int sortOrder = noteTableView.proxyModel.sortOrder().value();
4600                 Global.setSortColumn(sortCol);
4601                 Global.setSortOrder(sortOrder);
4602
4603                 Global.setListView(Global.View_List_Narrow);
4604
4605         menuBar.wideListView.blockSignals(true);
4606         menuBar.narrowListView.blockSignals(true);
4607
4608         menuBar.wideListView.setChecked(false);
4609         menuBar.narrowListView.setChecked(true);
4610
4611         menuBar.wideListView.blockSignals(false);
4612         menuBar.narrowListView.blockSignals(false);
4613
4614         mainLeftRightSplitter.addWidget(noteTableView);
4615         // ICHANGED browserWindow → tabBrowser
4616         mainLeftRightSplitter.addWidget(tabBrowser);
4617
4618         restoreWindowState(false);
4619         noteTableView.repositionColumns();
4620         noteTableView.resizeColumnWidths();
4621         noteTableView.resizeRowHeights();
4622
4623         sortCol = Global.getSortColumn();
4624                 sortOrder = Global.getSortOrder();
4625                 noteTableView.proxyModel.blocked = true;
4626                 noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
4627                 noteTableView.proxyModel.blocked = false;
4628
4629
4630         showColumns();
4631         noteTableView.load(false);
4632         refreshEvernoteNote(true);
4633         scrollToCurrentGuid();
4634     }
4635     public void wideListView() {
4636                 int sortCol = noteTableView.proxyModel.sortColumn();
4637                 int sortOrder = noteTableView.proxyModel.sortOrder().value();
4638                 Global.setSortColumn(sortCol);
4639                 Global.setSortOrder(sortOrder);
4640
4641                 saveWindowState();
4642         saveNoteColumnPositions();
4643         saveNoteIndexWidth();
4644         Global.setListView(Global.View_List_Wide);
4645
4646         menuBar.wideListView.blockSignals(true);
4647         menuBar.narrowListView.blockSignals(true);
4648
4649         menuBar.wideListView.setChecked(true);
4650         menuBar.narrowListView.setChecked(false);
4651
4652         menuBar.wideListView.blockSignals(false);
4653         menuBar.narrowListView.blockSignals(false);
4654         browserIndexSplitter.setVisible(true);
4655         browserIndexSplitter.addWidget(noteTableView);
4656                 // ICHANGED browserWindow → tabBrowser
4657                 browserIndexSplitter.addWidget(tabBrowser);
4658
4659         restoreWindowState(false);
4660         noteTableView.repositionColumns();
4661         noteTableView.resizeColumnWidths();
4662         noteTableView.resizeRowHeights();
4663
4664         sortCol = Global.getSortColumn();
4665                 sortOrder = Global.getSortOrder();
4666                 noteTableView.proxyModel.blocked = true;
4667                 noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
4668                 noteTableView.proxyModel.blocked = false;
4669
4670         showColumns();
4671         noteTableView.load(false);
4672         scrollToCurrentGuid();
4673     }
4674     // Sort order for the notebook has changed
4675     public void tableSortOrderChanged(Integer column, Integer order) {
4676
4677         // Find what notebook (if any) is selected.  We ignore stacks & the "All Notebooks".
4678         List<QTreeWidgetItem> selectedNotebook = notebookTree.selectedItems();
4679         if (selectedNotebook.size() > 0 && !selectedNotebook.get(0).text(0).equalsIgnoreCase("All Notebooks") && !selectedNotebook.get(0).text(2).equalsIgnoreCase("STACK")) {
4680                 QTreeWidgetItem currentSelectedNotebook = selectedNotebook.get(0);
4681                 String notebook;
4682                 notebook = currentSelectedNotebook.text(2);
4683                 conn.getNotebookTable().setSortOrder(notebook, column, order);
4684         }
4685     }
4686
4687     //***************************************************************
4688     @SuppressWarnings("unused")
4689         private void evernoteLinkClick(String syncGuid, String locGuid) {
4690         String guid = null;
4691         if (conn.getNoteTable().guidExists(syncGuid)) {
4692                 guid = syncGuid;
4693         } else {
4694                 // If we didn't find it via the synchronized guid, look under the local guid
4695                 // Iwe don't find it there, look to see if the GUID is posted under the local GUID, but was
4696                 // later synchronized (that causes the guid to change so we need to find the new one).
4697                 if (conn.getNoteTable().guidExists(locGuid))
4698                         guid = locGuid;
4699                 else
4700                         guid = conn.getNoteTable().findAlternateGuid(locGuid);
4701         }
4702                 if (guid != null) {
4703                         openExternalEditor(guid);
4704                         return;
4705                 }
4706
4707         //If we've gotten this far, we can't find the note
4708         QMessageBox.information(this, tr("Note Not Found"), tr("Sorry, but I can't"+
4709                         " seem to find that note."));
4710     }
4711     //***************************************************************
4712     //***************************************************************
4713     //** External editor window functions
4714     //***************************************************************
4715     //***************************************************************
4716         private void listDoubleClick() {
4717                 saveNote();
4718         openExternalEditor(currentNoteGuid);
4719     }
4720     private void openExternalEditor(String guid) {
4721
4722         if (externalWindows.containsKey(guid)) {
4723                 externalWindows.get(guid).raise();
4724                 return;
4725         }
4726
4727         Note note = conn.getNoteTable().getNote(guid, true, true, false, true, true);
4728         // We have a new external editor to create
4729         QIcon appIcon = new QIcon(iconPath+"nevernote.png");
4730         // ICHANGED
4731         ExternalBrowse newBrowser = new ExternalBrowse(conn, cbObserver);
4732
4733         newBrowser.setWindowIcon(appIcon);
4734         externalWindows.put(guid, newBrowser);
4735         showEditorButtons(newBrowser.getBrowserWindow());
4736         loadNoteBrowserInformation(newBrowser.getBrowserWindow(), guid, note);
4737         setupBrowserWindowListeners(newBrowser.getBrowserWindow(), false);
4738         newBrowser.windowClosing.connect(this, "externalWindowClosing(String)");
4739         //newBrowser.getBrowserWindow().noteSignal.titleChanged.connect(this, "externalWindowTitleEdited(String, String)");
4740         newBrowser.getBrowserWindow().noteSignal.tagsChanged.connect(this, "externalWindowTagsEdited(String, List)");
4741         newBrowser.contentsChanged.connect(this, "saveNoteExternalBrowser(String, String, Boolean, BrowserWindow)");
4742         newBrowser.getBrowserWindow().blockApplication.connect(this, "blockApplication(BrowserWindow)");
4743         newBrowser.getBrowserWindow().unblockApplication.connect(this, "unblockApplication()");
4744
4745         browserWindow.noteSignal.tagsChanged.connect(newBrowser, "updateTags(String, List)");
4746         browserWindow.noteSignal.titleChanged.connect(newBrowser, "updateTitle(String, String)");
4747         browserWindow.noteSignal.notebookChanged.connect(newBrowser, "updateNotebook(String, String)");
4748
4749         newBrowser.show();
4750     }
4751     @SuppressWarnings({ "rawtypes", "unused" })
4752         private void externalWindowTagsEdited(String guid, List values) {
4753         StringBuffer line = new StringBuffer(100);
4754         for (int i=0; i<values.size(); i++) {
4755                 if (i>0)
4756                         line.append(Global.tagDelimeter+" ");
4757                 line.append(values.get(i));
4758         }
4759         if (guid.equals(currentNoteGuid)) {
4760                 browserWindow.setTag(line.toString());
4761         }
4762     }
4763     @SuppressWarnings("unused")
4764         private void externalWindowClosing(String guid) {
4765                 externalWindows.remove(guid);
4766     }
4767
4768         // ***************************************************************
4769         // ***************************************************************
4770         // ** タブウィンドウの機能
4771         // ***************************************************************
4772         // ***************************************************************
4773         @SuppressWarnings("unused")
4774         private void openNewTab() {
4775                 saveNote();
4776
4777                 // selectedNoteGUIDsをディープコピー
4778                 List<String> copySelected = new ArrayList<String>(selectedNoteGUIDs);
4779
4780                 for (int i=0; i < copySelected.size() ; i++) {
4781                         openTabEditor(copySelected.get(i));
4782                 }
4783         }
4784
4785         // ICHANGED 連想ノートリストから新しいタブで開く
4786         @SuppressWarnings("unused")
4787         private void openNewTabFromRNL(){
4788                 if(rensoNotePressedItemGuid != null){
4789                         String prevCurrentNoteGuid = new String(currentNoteGuid);
4790
4791                         saveNote();
4792                         openTabEditor(rensoNotePressedItemGuid);
4793
4794                         // 連想ノートリストアイテムクリック操作を記録
4795                         conn.getHistoryTable().addHistory("rensoItemClick", prevCurrentNoteGuid, rensoNotePressedItemGuid);
4796                 }
4797         }
4798
4799         // ICHANGED
4800         private void openTabEditor(String guid) {
4801
4802                 Note note = conn.getNoteTable().getNote(guid, true, true, false, true, true);
4803                 // 新しいタブエディタを作成
4804                 TabBrowse newBrowser = new TabBrowse(conn, tabBrowser, cbObserver);
4805                 showEditorButtons(newBrowser.getBrowserWindow());
4806
4807                 String noteTitle = note.getTitle();
4808                 int index = tabBrowser.addNewTab(newBrowser, noteTitle);
4809                 tabWindows.put(index, newBrowser);
4810                 noteDirty.put(index, false);
4811
4812                 // noteTableViewの選択を変更するとselectionChangedが発生してしまうので一度切断
4813                 noteTableView.selectionModel().selectionChanged.disconnect(this, "noteTableSelection()");
4814                 loadNoteBrowserInformation(newBrowser.getBrowserWindow(), guid, note);
4815                 // 再接続
4816                 noteTableView.selectionModel().selectionChanged.connect(this, "noteTableSelection()");
4817
4818                 setupBrowserWindowListeners(newBrowser.getBrowserWindow(), false);
4819
4820                 // ExtendedInformationを必要があれば表示する
4821                 toggleNoteInformation();
4822                 // Sourceを必要があれば表示する
4823                 viewSource();
4824                 // EditorButtonsBarを必要があれば表示する
4825                 toggleEditorButtonBar();
4826
4827                 // 履歴記録のハッシュマップを初期化
4828                 ArrayList<String> histGuids = new ArrayList<String>();
4829                 historyGuids.put(index, histGuids);
4830                 historyPosition.put(index, 0);
4831                 fromHistory.put(index, false);
4832
4833                 // 履歴に今開いたノートを追加
4834                 histGuids.add(guid);
4835                 historyPosition.put(index, histGuids.size());
4836
4837                 tabBrowser.setCurrentIndex(index);
4838
4839                 if (guid != null && !guid.equals("")) {
4840                         if (!Global.showDeleted) { // ゴミ箱じゃなければ
4841                                 addBrowseHistory();
4842                         }
4843                 }
4844         }
4845
4846         // ICHANGED タブが閉じられた
4847         private void tabWindowClosing(int index) {
4848                 // タブが1つしかなかったら閉じない
4849                 if (tabBrowser.count() <= 1) {
4850                         return;
4851                 }
4852
4853                 TabBrowse t = (TabBrowse) tabBrowser.widget(index);
4854                 String guid = t.getBrowserWindow().getNote().getGuid();
4855                 String content = t.getBrowserWindow().getContent();
4856                 BrowserWindow browser = t.getBrowserWindow();
4857                 // ノートが変更されていたら保存
4858                 if (t.getNoteDirty()) {
4859                         saveNoteTabBrowser(guid, content, true, browser);
4860                 }
4861
4862                 // シグナル切断
4863                 browser.noteSignal.tagsChanged.disconnect();
4864                 browser.noteSignal.titleChanged.disconnect();
4865                 browser.noteSignal.noteChanged.disconnect();
4866                 browser.noteSignal.notebookChanged.disconnect();
4867                 browser.noteSignal.createdDateChanged.disconnect();
4868                 browser.noteSignal.alteredDateChanged.disconnect();
4869
4870                 // ノートを削除
4871                 tabWindows.remove(index);
4872                 tabBrowser.removeTab(index);
4873                 noteDirty.remove(index);
4874                 inkNote.remove(index);
4875                 readOnly.remove(index);
4876
4877                 // 履歴記録のハッシュマップを削除
4878                 historyGuids.remove(index);
4879                 historyPosition.remove(index);
4880                 fromHistory.remove(index);
4881
4882                 // タブのインデックスを更新（削除によって空いた部分を詰める）
4883                 for(int i = index ; tabWindows.containsKey(i + 1) ; i++){
4884                         // tabWindows
4885                         TabBrowse tab = tabWindows.get(i + 1);
4886                         tabWindows.put(i, tab);
4887                         tabWindows.remove(i + 1);
4888                         // noteDirty
4889                         boolean isNoteDirty = noteDirty.get(i + 1);
4890                         noteDirty.put(i, isNoteDirty);
4891                         noteDirty.remove(i + 1);
4892                         // inkNote
4893                         boolean isInkNote = inkNote.get(i + 1);
4894                         inkNote.put(i, isInkNote);
4895                         inkNote.remove(i + 1);
4896                         // readOnly
4897                         boolean isReadOnly = readOnly.get(i + 1);
4898                         readOnly.put(i, isReadOnly);
4899                         readOnly.remove(i + 1);
4900                         // historyGuids
4901                         ArrayList<String> histGuids = historyGuids.get(i + 1);
4902                         historyGuids.put(i, histGuids);
4903                         historyGuids.remove(i + 1);
4904                         // historyPosition
4905                         int histPosition = historyPosition.get(i + 1);
4906                         historyPosition.put(i, histPosition);
4907                         historyPosition.remove(i + 1);
4908                         // fromHistory
4909                         boolean fromHist = fromHistory.get(i + 1);
4910                         fromHistory.put(i,  fromHist);
4911                         fromHistory.remove(i + 1);
4912                 }
4913
4914                 // タブの閉じるボタンを押すと、tabWindowClosingより先にtabWindowChangedが呼ばれてしまうので、手動で呼びなおす
4915                 tabWindowChanged(tabBrowser.currentIndex());
4916         }
4917
4918         @SuppressWarnings("unused")
4919         private void noteAddNewTab() {
4920                 saveNote();
4921
4922                 // ノート追加前に開いていたノートとの関連性を記録するためにguidをとっておく
4923                 TabBrowse prevTab = (TabBrowse)tabBrowser.currentWidget();
4924                 String prevTabGuid = null;
4925                 if (prevTab.getBrowserWindow() != null && prevTab.getBrowserWindow().getNote() != null) {
4926                         prevTabGuid = prevTab.getBrowserWindow().getNote().getGuid();
4927                 }
4928
4929                 openEmptyTabEditor();
4930                 addNote();
4931
4932                 // 追加されたノートのguidを取得し、ノート追加操作履歴としてデータベースに登録
4933                 if (prevTabGuid != null && !prevTabGuid.equals("")) {
4934                         TabBrowse addedTab = (TabBrowse)tabBrowser.currentWidget();
4935                         String addedTabGuid = addedTab.getBrowserWindow().getNote().getGuid();
4936                         if (addedTabGuid != null && !addedTabGuid.equals("")) {
4937                                 if (!prevTabGuid.equals(addedTabGuid)) {
4938                                         conn.getHistoryTable().addHistory("addNewNote", prevTabGuid, addedTabGuid);
4939                                 }
4940                         }
4941                 }
4942         }
4943
4944         // ICHANGED
4945         private void openEmptyTabEditor() {
4946                 // 新しいタブエディタを作成
4947                 TabBrowse newBrowser = new TabBrowse(conn, tabBrowser, cbObserver);
4948                 showEditorButtons(newBrowser.getBrowserWindow());
4949
4950                 setupBrowserWindowListeners(newBrowser.getBrowserWindow(), false);
4951
4952                 int index = tabBrowser.addNewTab(newBrowser, "");
4953                 tabWindows.put(index, newBrowser);
4954                 noteDirty.put(index, false);
4955
4956                 // ExtendedInformationを必要があれば表示する
4957                 toggleNoteInformation();
4958                 // Sourceを必要があれば表示する
4959                 viewSource();
4960                 // EditorButtonsBarを必要があれば表示する
4961                 toggleEditorButtonBar();
4962
4963                 // 履歴記録のハッシュマップを初期化
4964                 ArrayList<String> histGuids = new ArrayList<String>();
4965                 historyGuids.put(index, histGuids);
4966                 historyPosition.put(index, 0);
4967                 fromHistory.put(index, false);
4968
4969                 tabBrowser.setCurrentIndex(index);
4970         }
4971
4972     //***************************************************************
4973     //***************************************************************
4974     //** These functions deal with Note specific things
4975     //***************************************************************
4976     //***************************************************************
4977         // ICHANGED
4978         private void setNoteDirty() {
4979                 for (String guid: selectedNoteGUIDs) {
4980                         setNoteDirty(guid);
4981                 }
4982         }
4983
4984         // ICHANGED
4985         private void setNoteDirty(String targetGuid) {
4986                 logger.log(logger.EXTREME, "Entering NeverNote.setNoteDirty()");
4987
4988                 // Find if the note is being edited externally.  If it is, update it.
4989                 if (externalWindows.containsKey(targetGuid)) {
4990                         QTextCodec codec = QTextCodec.codecForName("UTF-8");
4991                 QByteArray unicode =  codec.fromUnicode(browserWindow.getContent());
4992                         ExternalBrowse window = externalWindows.get(targetGuid);
4993                 window.getBrowserWindow().setContent(unicode);
4994                 }
4995
4996                 // 他のタブで同じノートを開いていないか探す。もしあったら、内容を更新する。
4997                 Collection<Integer> tabIndexes = tabWindows.keySet();
4998                 Iterator<Integer>       indexIterator = tabIndexes.iterator();
4999
5000                 for (TabBrowse tab: tabWindows.values()) {
5001                         int index = indexIterator.next();
5002                         String guid = tab.getBrowserWindow().getNote().getGuid();
5003
5004                         QTextCodec codec = QTextCodec.codecForName("UTF-8");
5005                         QByteArray unicode = codec.fromUnicode(browserWindow.getContent());
5006
5007                         if (guid.equals(guid)) {
5008                                 if (index != tabBrowser.currentIndex()) {
5009                                         TabBrowse window = tabWindows.get(index);
5010                                         window.getBrowserWindow().setContent(unicode);
5011                                 }
5012                         }
5013                 }
5014
5015                 // ターゲットノートがタブで開かれていて、かつDirty = trueかどうかを取得する
5016                 // If the note is dirty, then it is unsynchronized by default.
5017                 int index = -1;
5018                 boolean isNoteDirty = false;
5019                 for (TabBrowse tab: tabWindows.values()) {
5020                         if (tab.getBrowserWindow().getNote().getGuid().equals(targetGuid)) {
5021                                 index = tabBrowser.indexOf(tab);
5022                                 isNoteDirty = noteDirty.get(index);
5023                                 break;
5024                         }
5025                 }
5026                 if (isNoteDirty) {
5027                         return;
5028                 }
5029
5030                 // Set the note as dirty and check if its status is synchronized in the display table
5031                 // まだダーティでなく、かつタブで開かれている場合にnoteDirty = trueにする
5032                 if (index >= 0) {
5033                         noteDirty.put(index, true);
5034                 }
5035
5036                 if (listManager.getNoteMetadata().containsKey(targetGuid) &&
5037                                 listManager.getNoteMetadata().get(targetGuid).isDirty()) {
5038                                 return;
5039                 }
5040
5041                 // If this wasn't already marked as unsynchronized, then we need to update the table
5042                 listManager.getNoteTableModel().updateNoteSyncStatus(targetGuid, false);
5043 //      listManager.getUnsynchronizedNotes().add(targetGuid);
5044         for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
5045                 QModelIndex modelIndex =  listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
5046                 if (modelIndex != null) {
5047                         SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
5048                         String tableGuid =  (String)ix.values().toArray()[0];
5049                         if (tableGuid.equals(targetGuid)) {
5050                                 listManager.getNoteTableModel().proxyModel.setData(i, Global.noteTableSynchronizedPosition, "false");
5051                                 return;
5052                         }
5053                 }
5054         }
5055
5056                 logger.log(logger.EXTREME, "Leaving NeverNote.setNoteDirty()");
5057     }
5058     @SuppressWarnings("unused")
5059         private void saveNoteExternalBrowser(String guid, String content, Boolean save, BrowserWindow browser) {
5060                 QTextCodec codec = QTextCodec.codecForName("UTF-8");
5061         QByteArray unicode =  codec.fromUnicode(content);
5062         noteCache.remove(guid);
5063                 noteCache.put(guid, unicode.toString());
5064         if (guid.equals(currentNoteGuid)) {
5065                 // ICHANGED
5066                 int index = tabBrowser.currentIndex();
5067                 noteDirty.put(index, true);
5068                 browserWindow.setContent(unicode);
5069         }
5070         if (save) {
5071                 thumbnailRunner.addWork("GENERATE "+ guid);
5072                 saveNote(guid, browser);
5073         }
5074
5075     }
5076
5077         // ICHANGED
5078         private void saveNoteTabBrowser(String guid, String content, Boolean save,
5079                         BrowserWindow browser) {
5080                 QTextCodec codec = QTextCodec.codecForName("UTF-8");
5081                 QByteArray unicode = codec.fromUnicode(content);
5082                 noteCache.remove(guid);
5083                 noteCache.put(guid, unicode.toString());
5084                 if (save) {
5085                         thumbnailRunner.addWork("GENERATE " + guid);
5086                         saveNote(guid, browser);
5087                 }
5088         }
5089
5090     private void saveNote() {
5091         // ICHANGED
5092         // すべてのタブに対して、Dirtyを確認し、trueならセーブする
5093         Collection<Integer> dirtyIndex = noteDirty.keySet();
5094         Iterator<Integer> indexIterator = dirtyIndex.iterator();
5095         for (boolean isNoteDirty: noteDirty.values()) {
5096                 int index = indexIterator.next();
5097                 if (isNoteDirty) {
5098                         if (index < 0) {
5099                                 return;
5100                         }
5101                         BrowserWindow b = tabWindows.get(index).getBrowserWindow();
5102                         String guid = b.getNote().getGuid();
5103                         saveNote(guid, b);
5104                         thumbnailRunner.addWork("GENERATE "+ guid);
5105                         noteDirty.put(index, false);
5106                 }
5107         }
5108     }
5109     private void saveNote(String guid, BrowserWindow window) {
5110                 logger.log(logger.EXTREME, "Inside NeverNote.saveNote()");
5111                 waitCursor(true);
5112
5113                 logger.log(logger.EXTREME, "Saving to cache");
5114                 QTextCodec codec = QTextCodec.codecForLocale();
5115 //              QTextDecoder decoder = codec.makeDecoder();
5116                 codec = QTextCodec.codecForName("UTF-8");
5117         QByteArray unicode =  codec.fromUnicode(window.getContent());
5118                 noteCache.put(guid, unicode.toString());
5119
5120                 logger.log(logger.EXTREME, "updating list manager");
5121                 listManager.updateNoteContent(guid, window.getContent());
5122                 logger.log(logger.EXTREME, "Updating title");
5123                 listManager.updateNoteTitle(guid, window.getTitle());
5124                 updateListDateChanged();
5125
5126                 logger.log(logger.EXTREME, "Looking through note index for refreshed note");
5127                 for (int i=0; i<listManager.getNoteIndex().size(); i++) {
5128                 if (listManager.getNoteIndex().get(i).getGuid().equals(guid)) {
5129                         currentNote = listManager.getNoteIndex().get(i);
5130                         i = listManager.getNoteIndex().size();
5131                 }
5132         }
5133         waitCursor(false);
5134     }
5135     // Get a note from Evernote (and put it in the browser)
5136         private void refreshEvernoteNote(boolean reload) {
5137                 logger.log(logger.HIGH, "Entering NeverNote.refreshEvernoteNote");
5138
5139                 if (Global.disableViewing) {
5140                         browserWindow.setEnabled(false);
5141                         return;
5142                 }
5143                 // ICHANGED
5144                 inkNote.put(tabBrowser.currentIndex(), false);
5145                 readOnly.put(tabBrowser.currentIndex(), false);
5146
5147                 if (Global.showDeleted || currentNoteGuid == null || currentNoteGuid.equals("")) {
5148                         readOnly.put(tabBrowser.currentIndex(), true);
5149                 }
5150                 Global.cryptCounter =0;
5151                 if (readOnly.get(tabBrowser.currentIndex())) {
5152                         browserWindow.setReadOnly(true);
5153                 }
5154
5155                 if (!reload)
5156                         return;
5157
5158                 waitCursor(true);
5159                 browserWindow.loadingData(true);
5160
5161                 currentNote = conn.getNoteTable().getNote(currentNoteGuid, true,true,false,false,true);
5162                 if (currentNote == null) {
5163                         waitCursor(false);
5164                         return;
5165                 }
5166
5167                 // ICHANGED
5168                 tabBrowser.setTabTitle(tabBrowser.currentIndex(), currentNote.getTitle());
5169
5170                 loadNoteBrowserInformation(browserWindow, currentNoteGuid, currentNote);
5171         }
5172
5173         // ICHANGED
5174         private void loadNoteBrowserInformation(BrowserWindow browser, String guid, Note note) {
5175                 NoteFormatter   formatter = new NoteFormatter(logger, conn, tempFiles);
5176                 formatter.setNote(note, Global.pdfPreview());
5177                 formatter.setHighlight(listManager.getEnSearch());
5178                 QByteArray js;
5179                 int tabIndex = -1;
5180
5181                 // 対象のタブインデックスを取得
5182                 for (TabBrowse tab: tabWindows.values()) {
5183                         if (tab.getBrowserWindow() == browser) {
5184                                 tabIndex = tabBrowser.indexOf(tab);
5185                                 break;
5186                         }
5187                 }
5188
5189                 if (!noteCache.containsKey(guid)) {
5190                         js = new QByteArray();
5191                         // We need to prepend the note with <HEAD></HEAD> or encoded characters are ugly
5192                         js.append("<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");
5193                         js.append("<style type=\"text/css\">.en-crypt-temp { border-collapse:collapse; border-style:solid; border-color:blue; padding:0.0mm 0.0mm 0.0mm 0.0mm; }</style>");
5194                         js.append("<style type=\"text/css\">en-hilight { background-color: rgb(255,255,0) }</style>");
5195                         js.append("<style> img { height:auto; width:auto; max-height:auto; max-width:100%; }</style>");
5196                         if (Global.displayRightToLeft())
5197                                 js.append("<style> body { direction:rtl; }</style>");
5198                         js.append("<style type=\"text/css\">en-spell { text-decoration: none; border-bottom: dotted 1px #cc0000; }</style>");
5199                         js.append("</head>");
5200                         formatter.setNote(note, Global.pdfPreview());
5201                         js.append(formatter.rebuildNoteHTML());
5202                         js.append("</HTML>");
5203                         js.replace("<!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml.dtd'>", "");
5204                         js.replace("<!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml2.dtd'>", "");
5205                         js.replace("<?xml version='1.0' encoding='UTF-8'?>", "");
5206 //              if (Global.enableHTMLEntitiesFix) {
5207 //                      browser.getBrowser().setContent(new QByteArray(StringEscapeUtils.unescapeHtml(js.toString())));
5208 //              } else
5209                         browser.setContent(js);
5210                         noteCache.put(guid, js.toString());
5211
5212                         if (formatter.resourceError)
5213                                 resourceErrorMessage(tabIndex);
5214                         if (formatter.formatError) {
5215                                 waitCursor(false);
5216                              QMessageBox.information(this, tr("Error"),
5217                                                 tr("NeighborNote had issues formatting this note." +
5218                                                 " To protect your data this note is being marked as read-only."));
5219                              waitCursor(true);
5220                         }
5221
5222                         if (tabIndex >= 0) {
5223                                 readOnly.put(tabIndex, formatter.readOnly);
5224                                 inkNote.put(tabIndex, formatter.inkNote);
5225                         }
5226
5227                         if (tabIndex >= 0 && readOnly.get(tabIndex)) {
5228                                 readOnlyCache.put(guid, true);
5229                         }
5230                         if (tabIndex >= 0 && inkNote.get(tabIndex)) {
5231                                 inkNoteCache.put(guid, true);
5232                         }
5233
5234                 } else {
5235                         logger.log(logger.HIGH, "Note content is being pulled from the cache");
5236                         String cachedContent = formatter.modifyCachedTodoTags(noteCache.get(guid));
5237                         js = new QByteArray(cachedContent);
5238                         browser.setContent(js);
5239                         if (readOnlyCache.containsKey(guid) && tabIndex >= 0) {
5240                                 readOnly.put(tabIndex, true);
5241                         } else {
5242                                 readOnly.put(tabIndex, false);
5243                         }
5244                         if (inkNoteCache.containsKey(guid) && tabIndex >= 0) {
5245                                 inkNote.put(tabIndex, true);
5246                         } else {
5247                                 inkNote.put(tabIndex, false);
5248                         }
5249                 }
5250                 if (conn.getNoteTable().isThumbnailNeeded(guid)) {
5251                         thumbnailHTMLReady(guid, js, Global.calculateThumbnailZoom(js.toString()));
5252                 }
5253                 if (tabIndex >= 0 && (readOnly.get(tabIndex) || inkNote.get(tabIndex) ||
5254                                 (note.getAttributes() != null && note.getAttributes().getContentClass() != null && note.getAttributes().getContentClass() != "")))
5255                         browser.getBrowser().page().setContentEditable(false);  // We don't allow editing of ink notes
5256                 else
5257                         browser.getBrowser().page().setContentEditable(true);
5258                 if (tabIndex >= 0) {
5259                         browser.setReadOnly(readOnly.get(tabIndex));
5260                         deleteButton.setEnabled(!readOnly.get(tabIndex));
5261                         tagButton.setEnabled(!readOnly.get(tabIndex));
5262                         menuBar.noteDelete.setEnabled(!readOnly.get(tabIndex));
5263                         menuBar.noteTags.setEnabled(!readOnly.get(tabIndex));
5264                 }
5265                 browser.setNote(note);
5266
5267                 if (note != null && note.getNotebookGuid() != null &&
5268                                 conn.getNotebookTable().isLinked(note.getNotebookGuid())) {
5269                         deleteButton.setEnabled(false);
5270                         menuBar.notebookDeleteAction.setEnabled(false);
5271                 } else {
5272                         deleteButton.setEnabled(true);
5273                         menuBar.notebookDeleteAction.setEnabled(true);
5274                 }
5275
5276                 // Build a list of non-closed notebooks
5277                 List<Notebook> nbooks = new ArrayList<Notebook>();
5278                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
5279                         boolean found=false;
5280                         for (int j=0; j<listManager.getArchiveNotebookIndex().size(); j++) {
5281                                 if (listManager.getArchiveNotebookIndex().get(j).getGuid().equals(listManager.getNotebookIndex().get(i).getGuid()))
5282                                         found = true;
5283                         }
5284                         if (!found)
5285                                 nbooks.add(listManager.getNotebookIndex().get(i));
5286                 }
5287
5288                 browser.setTitle(note.getTitle());
5289                 browser.setTag(getTagNamesForNote(note));
5290                 browser.setAuthor(note.getAttributes().getAuthor());
5291
5292                 browser.setAltered(note.getUpdated());
5293                 browser.setCreation(note.getCreated());
5294                 if (note.getAttributes().getSubjectDate() > 0)
5295                         browser.setSubjectDate(note.getAttributes().getSubjectDate());
5296                 else
5297                         browser.setSubjectDate(note.getCreated());
5298                 browser.setUrl(note.getAttributes().getSourceURL());
5299
5300                 FilterEditorTags tagFilter = new FilterEditorTags(conn, logger);
5301                 List<Tag> tagList = tagFilter.getValidTags(note);
5302                 browser.setAllTags(tagList);
5303
5304                 browser.setCurrentTags(note.getTagNames());
5305                 // ICHANGED
5306                 for (TabBrowse tab: tabWindows.values()) {
5307                         if (tab.getBrowserWindow().getNote().getGuid().equals(guid)) {
5308                                 int index = tabBrowser.indexOf(tab);
5309                                 noteDirty.put(index, false);
5310                                 break;
5311                         }
5312                 }
5313
5314                 scrollToGuid(guid);
5315
5316                 browser.loadingData(false);
5317                 if (thumbnailViewer.isActiveWindow())
5318                         thumbnailView();
5319
5320                 FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
5321                 browser.setNotebookList(notebookFilter.getValidNotebooks(note, listManager.getNotebookIndex()));
5322
5323                 waitCursor(false);
5324                 logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNote");
5325         }
5326
5327         // ICHANGED
5328         @SuppressWarnings("unused")
5329         private void toggleNoteAttributes() {
5330                 menuBar.noteAttributes.setChecked(!menuBar.noteAttributes.isChecked());
5331                 toggleNoteInformation();
5332         }
5333
5334         // Save a generated thumbnail
5335         private void toggleNoteInformation() {
5336                 logger.log(logger.HIGH, "Entering NeverNote.toggleNoteInformation");
5337
5338         // ICHANGED
5339                 boolean isChecked = menuBar.noteAttributes.isChecked();
5340
5341         for(int i = 0; i < tabBrowser.count(); i++){
5342                 BrowserWindow browser = ((TabBrowse) tabBrowser.widget(i)).getBrowserWindow();
5343                 boolean isExtended = browser.isExtended();
5344                 if((isChecked && !isExtended) || (!isChecked && isExtended)){
5345                         browser.toggleInformation();
5346                 }
5347         }
5348
5349         menuBar.noteAttributes.setChecked(browserWindow.isExtended());
5350         Global.saveWindowVisible("noteInformation", browserWindow.isExtended());
5351         logger.log(logger.HIGH, "Leaving NeverNote.toggleNoteInformation");
5352     }
5353
5354         // Listener triggered when a print button is pressed
5355     @SuppressWarnings("unused")
5356         private void printNote() {
5357                 logger.log(logger.HIGH, "Entering NeverNote.printNote");
5358
5359         QPrintDialog dialog = new QPrintDialog();
5360         if (dialog.exec() == QDialog.DialogCode.Accepted.value()) {
5361                 QPrinter printer = dialog.printer();
5362                 browserWindow.getBrowser().print(printer);
5363         }
5364                 logger.log(logger.HIGH, "Leaving NeverNote.printNote");
5365
5366     }
5367     // Listener triggered when the email button is pressed
5368     @SuppressWarnings("unused")
5369         private void emailNote() {
5370         logger.log(logger.HIGH, "Entering NeverNote.emailNote");
5371
5372         if (Desktop.isDesktopSupported()) {
5373             Desktop desktop = Desktop.getDesktop();
5374
5375             String text2 = browserWindow.getContentsToEmail();
5376             QUrl url = new QUrl("mailto:");
5377             url.addQueryItem("subject", currentNote.getTitle());
5378 //            url.addQueryItem("body", QUrl.toPercentEncoding(text2).toString());
5379             url.addQueryItem("body", text2);
5380             QDesktopServices.openUrl(url);
5381         }
5382 /*
5383
5384             if (desktop.isSupported(Desktop.Action.MAIL)) {
5385                 URI uriMailTo = null;
5386                 try {
5387                         //String text = browserWindow.getBrowser().page().currentFrame().toPlainText();
5388                         String text = browserWindow.getContentsToEmail();
5389                         //text = "<b>" +text +"</b>";
5390                                         uriMailTo = new URI("mailto", "&SUBJECT="+currentNote.getTitle()
5391                                                         +"&BODY=" +text, null);
5392                                         uriMailTo = new URI("mailto", "&SUBJECT="+currentNote.getTitle()
5393                                                         +"&ATTACHMENT=d:/test.pdf", null);
5394                                         desktop.mail(uriMailTo);
5395                                 } catch (URISyntaxException e) {
5396                                         e.printStackTrace();
5397                                 } catch (IOException e) {
5398                                         e.printStackTrace();
5399                                 }
5400
5401             }
5402
5403         }
5404  */
5405         logger.log(logger.HIGH, "Leaving NeverNote.emailNote");
5406     }
5407         // Reindex all notes
5408     @SuppressWarnings("unused")
5409         private void fullReindex() {
5410         logger.log(logger.HIGH, "Entering NeverNote.fullReindex");
5411         indexRunner.addWork("REINDEXALL");
5412         setMessage(tr("Database will be reindexed."));
5413         logger.log(logger.HIGH, "Leaving NeverNote.fullReindex");
5414     }
5415     // Listener when a user wants to reindex a specific note
5416     @SuppressWarnings("unused")
5417         private void reindexNote() {
5418         logger.log(logger.HIGH, "Entering NeverNote.reindexNote");
5419                 for (int i=0; i<selectedNoteGUIDs.size(); i++) {
5420                         indexRunner.addWork("REINDEXNOTE "+selectedNoteGUIDs.get(i));
5421                 }
5422                 if (selectedNotebookGUIDs.size() > 1)
5423                         setMessage(tr("Notes will be reindexed."));
5424                 else
5425                         setMessage(tr("Note will be reindexed."));
5426         logger.log(logger.HIGH, "Leaving NeverNote.reindexNote");
5427     }
5428     // Delete the note
5429     @SuppressWarnings("unused")
5430         private void deleteNote() {
5431         logger.log(logger.HIGH, "Entering NeverNote.deleteNote");
5432         if (currentNote == null)
5433                 return;
5434         if (currentNoteGuid.equals(""))
5435                 return;
5436         String title = null;
5437         if (selectedNoteGUIDs.size() == 1)
5438                 title = conn.getNoteTable().getNote(selectedNoteGUIDs.get(0),false,false,false,false,false).getTitle();
5439
5440         // If we are deleting non-trash notes
5441         if (currentNote.isActive()) {
5442                 if (Global.verifyDelete()) {
5443                         String msg;
5444                         if (selectedNoteGUIDs.size() > 1) {
5445                                 msg = new String(tr("Delete ") +selectedNoteGUIDs.size() +" notes?");
5446                         } else {
5447                                 if (title != null)
5448                                         msg = new String(tr("Delete note \"") +title +"\"?");
5449                                 else
5450                                         msg = new String(tr("Delete note selected note?"));
5451                         }
5452                         if (QMessageBox.question(this, tr("Confirmation"), msg,
5453                                         QMessageBox.StandardButton.Yes,
5454                                         QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
5455                                         return;
5456                         }
5457                 }
5458                 if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
5459                         selectedNoteGUIDs.add(currentNoteGuid);
5460                 closeTabs(selectedNoteGUIDs);
5461                 for (int i=0; i<selectedNoteGUIDs.size(); i++) {
5462                         listManager.deleteNote(selectedNoteGUIDs.get(i));
5463                 }
5464         } else {
5465                 // If we are deleting from the trash.
5466                 if (Global.verifyDelete()) {
5467                         String msg;
5468                         if (selectedNoteGUIDs.size() > 1) {
5469                                 msg = new String(tr("Permanently delete ") +selectedNoteGUIDs.size() +" notes?");
5470                         } else {
5471                                 if (title != null)
5472                                 msg = new String(tr("Permanently delete note \"") +title +"\"?");
5473                                 else
5474                                         msg = new String(tr("Permanently delete note selected note?"));
5475                         }
5476                         if (QMessageBox.question(this, "Confirmation", msg,
5477                                 QMessageBox.StandardButton.Yes,
5478                                         QMessageBox.StandardButton.No)==StandardButton.No.value()) {
5479                                         return;
5480                         }
5481                 }
5482                 if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
5483                         selectedNoteGUIDs.add(currentNoteGuid);
5484                 for (int i=selectedNoteGUIDs.size()-1; i>=0; i--) {
5485                         for (int j=listManager.getNoteTableModel().rowCount()-1; j>=0; j--) {
5486                         QModelIndex modelIndex =  listManager.getNoteTableModel().index(j, Global.noteTableGuidPosition);
5487                         if (modelIndex != null) {
5488                                 SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
5489                                 String tableGuid =  (String)ix.values().toArray()[0];
5490                                 if (tableGuid.equals(selectedNoteGUIDs.get(i))) {
5491                                         listManager.getNoteTableModel().removeRow(j);
5492                                         j=-1;
5493                                 }
5494                         }
5495                 }
5496                         closeTabs(selectedNoteGUIDs);
5497                         listManager.expungeNote(selectedNoteGUIDs.get(i));
5498
5499                         // ICHANGED
5500                         conn.getHistoryTable().expungeHistory(selectedNoteGUIDs.get(i));
5501                         conn.getExcludedTable().expungeExcludedNote(selectedNoteGUIDs.get(i));
5502                         conn.getStaredTable().expungeStaredNote(selectedNoteGUIDs.get(i));
5503
5504                 }
5505         }
5506         currentNoteGuid = "";
5507         closeExternalWindows(selectedNoteGUIDs);
5508                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
5509                         menuBar.noteAddNewTab.setEnabled(false);
5510                 }
5511
5512         listManager.loadNotesIndex();
5513         noteIndexUpdated(false);
5514         refreshEvernoteNote(true);
5515         scrollToGuid(currentNoteGuid);
5516         logger.log(logger.HIGH, "Leaving NeverNote.deleteNote");
5517     }
5518
5519     // 対象ノートをタブで開いていたら閉じる
5520     private void closeTabs(List<String> noteGUIDs) {
5521                 Collection<TabBrowse> tabBrowsers = tabWindows.values();
5522                 Iterator<TabBrowse> tabIterator = tabBrowsers.iterator();
5523                 Collection<Integer> tabIndexes = tabWindows.keySet();
5524                 Iterator<Integer>       indexIterator = tabIndexes.iterator();
5525                 List<Integer> closeIndexes = new ArrayList<Integer>();  //イテレータ操作中に中身をいじっちゃダメなので
5526
5527                 while (tabIterator.hasNext()) {
5528                         TabBrowse tab = tabIterator.next();
5529                         int index = indexIterator.next();
5530                         String guid = tab.getBrowserWindow().getNote().getGuid();
5531
5532                         for(int i = 0; i < noteGUIDs.size(); i++){
5533                                 if(guid.equals(noteGUIDs.get(i))){
5534                                         closeIndexes.add(index);
5535                                 }
5536                         }
5537                 }
5538
5539                 for(int i = closeIndexes.size() - 1; i >= 0; i--){
5540                         tabWindowClosing(closeIndexes.get(i));
5541                 }
5542     }
5543
5544     // 対象ノートを外部ウィンドウで開いていたら閉じる
5545     private void closeExternalWindows(List<String> noteGUIDs) {
5546                 Collection<ExternalBrowse>      windows = externalWindows.values();
5547                 Iterator<ExternalBrowse>        windowIterator = windows.iterator();
5548                 Collection<String>                      guids = externalWindows.keySet();
5549                 Iterator<String>                        guidIterator = guids.iterator();
5550                 List<ExternalBrowse>            closeWindows = new ArrayList<ExternalBrowse>(); // イテレータ操作中に中身をいじっちゃダメなので
5551
5552                 while (windowIterator.hasNext()) {
5553                         ExternalBrowse browser = windowIterator.next();
5554                         String guid = guidIterator.next();
5555
5556                         for (int i = 0; i < noteGUIDs.size(); i++) {
5557                                 if (guid.equals(noteGUIDs.get(i))) {
5558                                         closeWindows.add(browser);
5559                                 }
5560                         }
5561                 }
5562
5563                 for (int i = closeWindows.size() - 1; i >= 0; i--) {
5564                         closeWindows.get(i).close();
5565                 }
5566     }
5567
5568     // Add a new note
5569         private void addNote() {
5570         logger.log(logger.HIGH, "Inside NeverNote.addNote");
5571 //      browserWindow.setEnabled(true);
5572         browserWindow.setReadOnly(false);
5573         saveNote();
5574         Calendar currentTime = new GregorianCalendar();
5575         StringBuffer noteString = new StringBuffer(100);
5576         noteString.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
5577                 "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">\n" +
5578                 "<en-note>\n");
5579
5580         if (Global.overrideDefaultFont()) {
5581                 noteString.append("<font face=\"" +Global.getDefaultFont() +"\" >");
5582                 noteString.append("<span style=\"font-size:" +Global.getDefaultFontSize() +"pt;\">");
5583                 noteString.append("<br clear=\"none\" />\n");
5584                 noteString.append("</span>\n</font>\n");
5585         } else
5586                 noteString.append("<br clear=\"none\" />\n");
5587         noteString.append("</en-note>");
5588
5589         Long l = new Long(currentTime.getTimeInMillis());
5590         String randint = new String(Long.toString(l));
5591
5592         // Find a notebook.  We first look for a selected notebook (the "All Notebooks" one doesn't count).
5593         // Then we look
5594         // for the first non-archived notebook.  Finally, if nothing else we
5595         // pick the first notebook in the list.
5596         String notebook = null;
5597         listManager.getNotebookIndex().get(0).getGuid();
5598         List<QTreeWidgetItem> selectedNotebook = notebookTree.selectedItems();
5599         if (selectedNotebook.size() > 0 && !selectedNotebook.get(0).text(0).equalsIgnoreCase("All Notebooks") && !selectedNotebook.get(0).text(2).equalsIgnoreCase("STACK")) {
5600                 QTreeWidgetItem currentSelectedNotebook = selectedNotebook.get(0);
5601                 notebook = currentSelectedNotebook.text(2);
5602         } else {
5603                 boolean found = false;
5604                 List<Notebook> goodNotebooks = new ArrayList<Notebook>();
5605                 for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
5606                         boolean match = false;
5607                         for (int j=0; j<listManager.getArchiveNotebookIndex().size(); j++) {
5608                                 if (listManager.getArchiveNotebookIndex().get(j).getGuid().equals(listManager.getNotebookIndex().get(i).getGuid())) {
5609                                         match = true;
5610                                         j = listManager.getArchiveNotebookIndex().size();
5611                                 }
5612                         }
5613                         if (!match)
5614                                 //goodNotebooks.add(listManager.getNotebookIndex().get(i).deepCopy());
5615                                 goodNotebooks.add((Notebook)Global.deepCopy(listManager.getNotebookIndex().get(i)));
5616                 }
5617                 // Now we have a list of good notebooks, so we can look for the default
5618                 found = false;
5619                 for (int i=0; i<goodNotebooks.size(); i++) {
5620                         if (goodNotebooks.get(i).isDefaultNotebook()) {
5621                                 notebook = goodNotebooks.get(i).getGuid();
5622                                 found = true;
5623                                 i = goodNotebooks.size();
5624                         }
5625                 }
5626
5627                 if (goodNotebooks.size() > 0 && !found)
5628                         notebook = goodNotebooks.get(0).getGuid();
5629
5630                 if (notebook==null)
5631                         notebook = listManager.getNotebookIndex().get(0).getGuid();
5632         }
5633
5634         Note newNote = new Note();
5635         newNote.setUpdateSequenceNum(0);
5636         newNote.setGuid(randint);
5637         newNote.setNotebookGuid(notebook);
5638         newNote.setTitle("Untitled Note");
5639         newNote.setContent(noteString.toString());
5640         newNote.setDeleted(0);
5641         newNote.setCreated(System.currentTimeMillis());
5642         newNote.setUpdated(System.currentTimeMillis());
5643         newNote.setActive(true);
5644         NoteAttributes na = new NoteAttributes();
5645         na.setLatitude(0.0);
5646         na.setLongitude(0.0);
5647         na.setAltitude(0.0);
5648         newNote.setAttributes(new NoteAttributes());
5649                 newNote.setTagGuids(new ArrayList<String>());
5650                 newNote.setTagNames(new ArrayList<String>());
5651
5652         // If new notes are to be created based upon the selected tags, then we need to assign the tags
5653         if (Global.newNoteWithSelectedTags()) {
5654                 List<QTreeWidgetItem> selections = tagTree.selectedItems();
5655                 QTreeWidgetItem currentSelection;
5656                 for (int i=0; i<selections.size(); i++) {
5657                         currentSelection = selections.get(i);
5658                         newNote.getTagGuids().add(currentSelection.text(2));
5659                         newNote.getTagNames().add(currentSelection.text(0));
5660                 }
5661         }
5662
5663         conn.getNoteTable().addNote(newNote, true);
5664         NoteMetadata metadata = new NoteMetadata();
5665         metadata.setGuid(newNote.getGuid());
5666         metadata.setDirty(true);
5667         listManager.addNote(newNote, metadata);
5668 //      noteTableView.insertRow(newNote, true, -1);
5669
5670         // ICHANGED
5671         String prevCurrentNoteGuid = new String(currentNoteGuid);
5672
5673         currentNote = newNote;
5674         currentNoteGuid = currentNote.getGuid();
5675         // IFIXED こいつのせいで、ノート追加時にcurrentNoteGuidが更新されないので消す
5676         // noteTableView.clearSelection();
5677
5678         // ICHANGED 新規に作成したノートとそれまで開いていたノートの関連性を追加
5679         if (prevCurrentNoteGuid != null && !prevCurrentNoteGuid.equals("")) {
5680                 if (currentNoteGuid != null && !currentNoteGuid.equals("")) {
5681                         conn.getHistoryTable().addHistory("addNewNote", prevCurrentNoteGuid, currentNoteGuid);
5682                 }
5683         }
5684
5685         refreshEvernoteNote(true);
5686         listManager.countNotebookResults(listManager.getNoteIndex());
5687         browserWindow.titleLabel.setFocus();
5688         browserWindow.titleLabel.selectAll();
5689 //      notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
5690
5691         // If the window is hidden, then we want to popup this in an external window &
5692         if (!isVisible())
5693                 listDoubleClick();
5694         waitCursor(false);
5695         logger.log(logger.HIGH, "Leaving NeverNote.addNote");
5696     }
5697     // Restore a note from the trash;
5698     @SuppressWarnings("unused")
5699         private void restoreNote() {
5700         waitCursor(true);
5701                 if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
5702                         selectedNoteGUIDs.add(currentNoteGuid);
5703                 for (int i=0; i<selectedNoteGUIDs.size(); i++) {
5704                         listManager.restoreNote(selectedNoteGUIDs.get(i));
5705                 }
5706         currentNoteGuid = "";
5707         listManager.loadNotesIndex();
5708         noteIndexUpdated(false);
5709         waitCursor(false);
5710     }
5711     // Search a note for specific txt
5712     @SuppressWarnings("unused")
5713         private void findText() {
5714         find.show();
5715         find.setFocusOnTextField();
5716     }
5717     @SuppressWarnings("unused")
5718         private void doFindText() {
5719         browserWindow.getBrowser().page().findText(find.getText(), find.getFlags());
5720         find.setFocus();
5721     }
5722     @SuppressWarnings("unused")
5723         private void updateNoteTitle(String guid, String title) {
5724         listManager.setNoteSynchronized(guid, false);
5725
5726         // We do this manually because if we've edited the note in an
5727         // external window we run into the possibility of signal recursion
5728         // looping.
5729         if (guid.equals(currentNoteGuid)) {
5730                 browserWindow.titleLabel.blockSignals(true);
5731                 browserWindow.titleLabel.setText(title);
5732                 browserWindow.titleLabel.blockSignals(false);
5733         }
5734     }
5735     // Signal received that note content has changed.  Normally we just need the guid to remove
5736     // it from the cache.
5737     @SuppressWarnings("unused")
5738         private void invalidateNoteCache(String guid, String content) {
5739         noteCache.remove(guid);
5740                 refreshEvernoteNote(true);
5741     }
5742     // Signal received that a note guid has changed
5743     @SuppressWarnings("unused")
5744         private void noteGuidChanged(String oldGuid, String newGuid) {
5745         if (noteCache.containsKey(oldGuid)) {
5746                 if (!oldGuid.equals(currentNoteGuid)) {
5747                         String cache = noteCache.get(oldGuid);
5748                         noteCache.put(newGuid, cache);
5749                         noteCache.remove(oldGuid);
5750                 } else {
5751                         noteCache.remove(oldGuid);
5752                         noteCache.put(newGuid, browserWindow.getContent());
5753                 }
5754         }
5755
5756         listManager.updateNoteGuid(oldGuid, newGuid, false);
5757         if (currentNoteGuid.equals(oldGuid)) {
5758                 if (currentNote != null)
5759                         currentNote.setGuid(newGuid);
5760                 currentNoteGuid = newGuid;
5761         }
5762
5763         if (externalWindows.containsKey(oldGuid)) {
5764                         ExternalBrowse b = externalWindows.get(oldGuid);
5765                         externalWindows.remove(oldGuid);
5766                         b.getBrowserWindow().getNote().setGuid(newGuid);
5767                         externalWindows.put(newGuid, b);
5768                 }
5769
5770                 // ICHANGED
5771                 for(int i = 0; i < tabBrowser.count(); i++){
5772                         TabBrowse b = (TabBrowse)tabBrowser.widget(i);
5773                         if (b.getBrowserWindow().getNote().getGuid().equals(oldGuid)) {
5774                                 b.getBrowserWindow().getNote().setGuid(newGuid);
5775                         }
5776                 }
5777
5778         for (int i=0; i<listManager.getNoteIndex().size(); i++) {
5779                 if (listManager.getNoteIndex().get(i).getGuid().equals(newGuid)) {
5780                         noteTableView.proxyModel.addGuid(newGuid, listManager.getNoteMetadata().get(newGuid));
5781                         i=listManager.getNoteIndex().size();
5782                 }
5783         }
5784
5785         if (listManager.getNoteTableModel().metaData.containsKey(oldGuid)) {
5786                 NoteMetadata meta = listManager.getNoteTableModel().metaData.get(oldGuid);
5787                 listManager.getNoteTableModel().metaData.put(newGuid, meta);
5788                 listManager.getNoteTableModel().metaData.remove(oldGuid);
5789         }
5790
5791     }
5792
5793     // Toggle the note editor button bar
5794     // ICHANGED すべてのタブに
5795     private void toggleEditorButtonBar() {
5796         boolean isChecked = menuBar.showEditorBar.isChecked();
5797
5798         for(int i = 0; i < tabBrowser.count(); i++){
5799                 BrowserWindow browser = ((TabBrowse) tabBrowser.widget(i)).getBrowserWindow();
5800                 boolean isVisible = browser.buttonsVisible;
5801
5802                 if (isChecked && !isVisible) {
5803                         browser.buttonsVisible = true;
5804                         showEditorButtons(browser);
5805                 } else if(!isChecked && isVisible) {
5806                         browser.hideButtons();
5807                 }
5808         }
5809
5810         Global.saveWindowVisible("editorButtonBar", browserWindow.buttonsVisible);
5811     }
5812
5813     // Show editor buttons
5814     private void showEditorButtons(BrowserWindow browser) {
5815                 browser.buttonLayout.setVisible(true);
5816                 browser.undoAction.setVisible(false);
5817
5818                 browser.undoButton.setVisible(false);
5819
5820                 browser.undoAction.setVisible(Global.isEditorButtonVisible("undo"));
5821                 browser.redoAction.setVisible(Global.isEditorButtonVisible("redo"));
5822                 browser.cutAction.setVisible(Global.isEditorButtonVisible("cut"));
5823                 browser.copyAction.setVisible(Global.isEditorButtonVisible("copy"));
5824                 browser.pasteAction.setVisible(Global.isEditorButtonVisible("paste"));
5825                 browser.strikethroughAction.setVisible(Global.isEditorButtonVisible("strikethrough"));
5826                 browser.underlineAction.setVisible(Global.isEditorButtonVisible("underline"));
5827                 browser.boldAction.setVisible(Global.isEditorButtonVisible("bold"));
5828                 browser.italicAction.setVisible(Global.isEditorButtonVisible("italic"));
5829                 browser.hlineAction.setVisible(Global.isEditorButtonVisible("hline"));
5830                 browser.indentAction.setVisible(Global.isEditorButtonVisible("indent"));
5831                 browser.outdentAction.setVisible(Global.isEditorButtonVisible("outdent"));
5832                 browser.bulletListAction.setVisible(Global.isEditorButtonVisible("bulletList"));
5833                 browser.numberListAction.setVisible(Global.isEditorButtonVisible("numberList"));
5834                 browser.fontListAction.setVisible(Global.isEditorButtonVisible("font"));
5835                 browser.fontSizeAction.setVisible(Global.isEditorButtonVisible("fontSize"));
5836                 browser.fontColorAction.setVisible(Global.isEditorButtonVisible("fontColor"));
5837                 browser.fontHilightAction.setVisible(Global.isEditorButtonVisible("fontHilight"));
5838                 browser.leftAlignAction.setVisible(Global.isEditorButtonVisible("alignLeft"));
5839                 browser.centerAlignAction.setVisible(Global.isEditorButtonVisible("alignCenter"));
5840                 browser.rightAlignAction.setVisible(Global.isEditorButtonVisible("alignRight"));
5841                 browser.spellCheckAction.setVisible(Global.isEditorButtonVisible("spellCheck"));
5842                 browser.todoAction.setVisible(Global.isEditorButtonVisible("todo"));
5843     }
5844     private void duplicateNote(String guid) {
5845
5846                 Note oldNote = conn.getNoteTable().getNote(guid, true, false,false,false,true);
5847                 List<Resource> resList = conn.getNoteTable().noteResourceTable.getNoteResources(guid, true);
5848                 oldNote.setContent(conn.getNoteTable().getNoteContentNoUTFConversion(guid));
5849                 oldNote.setResources(resList);
5850                 duplicateNote(oldNote);
5851         }
5852         private void duplicateNote(Note oldNote) {
5853                 waitCursor(true);
5854                 // Now that we have a good notebook guid, we need to move the conflicting note
5855                 // to the local notebook
5856                 Calendar currentTime = new GregorianCalendar();
5857                 Long l = new Long(currentTime.getTimeInMillis());
5858                 String newGuid = new String(Long.toString(l));
5859
5860 //              Note newNote = oldNote.deepCopy();
5861                 Note newNote = (Note)Global.deepCopy(oldNote);
5862                 newNote.setUpdateSequenceNum(0);
5863                 newNote.setGuid(newGuid);
5864                 newNote.setDeleted(0);
5865                 newNote.setActive(true);
5866
5867                 /*
5868                 List<String> tagNames = new ArrayList<String>();
5869                 List<String> tagGuids = new ArrayList<String>();;
5870                 for (int i=0; i<oldNote.getTagGuidsSize(); i++) {
5871                         tagNames.add(oldNote.getTagNames().get(i));
5872                         tagGuids.add(oldNote.getTagGuids().get(i));
5873                 }
5874
5875                 // Sort note Tags to make them look nice
5876                 for (int i=0; i<tagNames.size()-1; i++) {
5877                         if (tagNames.get(i).compareTo(tagNames.get(i+1))<0) {
5878                                 String n1 = tagNames.get(i);
5879                                 String n2 = tagNames.get(i+1);
5880                                 tagNames.set(i, n2);
5881                                 tagNames.set(i+1, n1);
5882                         }
5883                 }
5884                 newNote.setTagGuids(tagGuids);
5885                 newNote.setTagNames(tagNames);
5886
5887                 // Add tag guids to note
5888                 */
5889
5890                 // Duplicate resources
5891                 List<Resource> resList = oldNote.getResources();
5892                 if (resList == null)
5893                         resList = new ArrayList<Resource>();
5894                 long prevGuid = 0;
5895                 for (int i=0; i<resList.size(); i++) {
5896                         l = prevGuid;
5897                         while (l == prevGuid) {
5898                                 currentTime = new GregorianCalendar();
5899                                 l = new Long(currentTime.getTimeInMillis());
5900                         }
5901                         prevGuid = l;
5902                         String newResGuid = new String(Long.toString(l));
5903                         resList.get(i).setNoteGuid(newGuid);
5904                         resList.get(i).setGuid(newResGuid);
5905                         resList.get(i).setUpdateSequenceNum(0);
5906                         resList.get(i).setActive(true);
5907                         conn.getNoteTable().noteResourceTable.saveNoteResource(
5908                                         (Resource)Global.deepCopy(resList.get(i)), true);
5909                 }
5910                 newNote.setResources(resList);
5911
5912                 // ICHANGED
5913                 // 操作履歴と除外ノートとスター付きノートも複製する
5914                 if(Global.getDuplicateRensoNote()) {
5915                         conn.getHistoryTable().duplicateHistory(newGuid, oldNote.getGuid());
5916                         conn.getExcludedTable().duplicateExcludedNotes(newGuid, oldNote.getGuid());
5917                         conn.getStaredTable().duplicateStaredNotes(newGuid, oldNote.getGuid());
5918                 }
5919
5920                 // Add note to the database
5921                 conn.getNoteTable().addNote(newNote, true);
5922                 NoteMetadata metaData = new NoteMetadata();
5923                 NoteMetadata oldMeta = listManager.getNoteMetadata().get(oldNote.getGuid());
5924                 metaData.copy(oldMeta);
5925                 metaData.setGuid(newNote.getGuid());
5926                 listManager.addNote(newNote, metaData);
5927                 noteTableView.insertRow(newNote, metaData, true, -1);
5928                 currentNoteGuid = newNote.getGuid();
5929                 currentNote = newNote;
5930                 refreshEvernoteNote(true);
5931                 listManager.countNotebookResults(listManager.getNoteIndex());
5932                 waitCursor(false);
5933
5934         }
5935         // View all notes
5936         @SuppressWarnings("unused")
5937         private void allNotes() {
5938                 clearAttributeFilter();
5939                 clearNotebookFilter();
5940                 clearSavedSearchFilter();
5941                 clearTrashFilter();
5942                 clearTagFilter();
5943                 searchField.clear();
5944                 if (Global.mimicEvernoteInterface) {
5945                         notebookTree.selectGuid("");
5946                 }
5947                 notebookTreeSelection();
5948                 refreshEvernoteNote(true);
5949
5950                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
5951                 if (!rensoNoteListDock.isEnabled()) {
5952                         rensoNoteListDock.setEnabled(true);
5953                 }
5954         }
5955         // Merge notes
5956         @SuppressWarnings("unused")
5957         private void mergeNotes() {
5958                 logger.log(logger.HIGH, "Merging notes");
5959                 waitCursor(true);
5960                 saveNote();
5961                 String masterGuid = null;
5962                 List<String> sources = new ArrayList<String>();
5963                 QModelIndex index;
5964                 for (int i=0; i<noteTableView.selectionModel().selectedRows().size(); i++) {
5965                         int r = noteTableView.selectionModel().selectedRows().get(i).row();
5966                         index = noteTableView.proxyModel.index(r, Global.noteTableGuidPosition);
5967                         SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
5968                 if (i == 0)
5969                         masterGuid = (String)ix.values().toArray()[0];
5970                 else
5971                         sources.add((String)ix.values().toArray()[0]);
5972                 }
5973
5974                 logger.log(logger.EXTREME, "Master guid=" +masterGuid);
5975                 logger.log(logger.EXTREME, "Children count: "+sources.size());
5976                 mergeNoteContents(masterGuid, sources);
5977                 currentNoteGuid = masterGuid;
5978
5979                 // ICHANGED 操作履歴と除外ノートとスター付きノートをマージ
5980                 if(Global.getMergeRensoNote()) {
5981                         for (int i = 0; i < sources.size(); i++) {
5982                                 String childGuid = sources.get(i);
5983                                 if(masterGuid != null && childGuid != null) {
5984                                         if(!masterGuid.equals(childGuid)) {
5985                                                 conn.getHistoryTable().mergeHistoryGuid(masterGuid, childGuid);
5986                                                 conn.getExcludedTable().mergeHistoryGuid(masterGuid, childGuid);
5987                                                 conn.getStaredTable().mergeHistoryGuid(masterGuid, childGuid);
5988                                         }
5989                                 }
5990                         }
5991                 }
5992
5993         // ICHANGED　↓↓↓ここから↓↓↓
5994                 // マージしたノート(child)を外部ウィンドウで開いていたら、閉じる
5995                 Collection<ExternalBrowse>      windows = externalWindows.values();
5996                 Iterator<ExternalBrowse>        windowIterator = windows.iterator();
5997                 Collection<String>                      guids = externalWindows.keySet();
5998                 Iterator<String>                        guidIterator = guids.iterator();
5999                 List<ExternalBrowse>            closeWindows = new ArrayList<ExternalBrowse>(); // イテレータ操作中に中身をいじっちゃダメなので
6000
6001                 while (windowIterator.hasNext()) {
6002                         ExternalBrowse browser = windowIterator.next();
6003                         String guid = guidIterator.next();
6004
6005                         for (int i = 0; i < sources.size(); i++) {
6006                                 if (guid.equals(sources.get(i))) {
6007                                         closeWindows.add(browser);
6008                                 }
6009                         }
6010                 }
6011
6012                 for (int i = closeWindows.size() - 1; i >= 0; i--) {
6013                         closeWindows.get(i).close();
6014                 }
6015                 // ICHANGED ↑↑↑ここまで↑↑↑
6016
6017         // ICHANGED　↓↓↓ここから↓↓↓
6018         // マージしたノート（child）をタブで開いていたら、閉じる
6019                 Collection<TabBrowse> tabBrowsers = tabWindows.values();
6020                 Iterator<TabBrowse> tabIterator = tabBrowsers.iterator();
6021                 Collection<Integer> tabIndexes = tabWindows.keySet();
6022                 Iterator<Integer>       indexIterator = tabIndexes.iterator();
6023                 List<Integer> closeIndexes = new ArrayList<Integer>();  //イテレータ操作中に中身をいじっちゃダメなので
6024
6025                 while (tabIterator.hasNext()) {
6026                         TabBrowse tab = tabIterator.next();
6027                         int tabIndex = indexIterator.next();
6028                         String guid = tab.getBrowserWindow().getNote().getGuid();
6029
6030                         for(int i = 0; i < sources.size(); i++){
6031                                 if(guid.equals(sources.get(i))){
6032                                         closeIndexes.add(tabIndex);
6033                                 }
6034                         }
6035                 }
6036
6037                 for(int i = closeIndexes.size() - 1; i >= 0; i--){
6038                         tabWindowClosing(closeIndexes.get(i));
6039                 }
6040                 // ICHANGED ↑↑↑ここまで↑↑↑
6041
6042                 noteIndexUpdated(false);
6043                 // IFIXED
6044                 // ICHANGED マージ後の新しいノートコンテンツを表示するためキャッシュを削除
6045                 noteCache.remove(masterGuid);
6046
6047                 refreshEvernoteNote(true);
6048                 waitCursor(false);
6049         }
6050         private void mergeNoteContents(String targetGuid, List<String> sources) {
6051                 Note target = conn.getNoteTable().getNote(targetGuid, true, false, false, false, false);
6052                 String newContent = target.getContent();
6053                 newContent = newContent.replace("</en-note>", "<br></br>");
6054
6055                 for (int i=0; i<sources.size(); i++) {
6056                         Note source = conn.getNoteTable().getNote(sources.get(i), true, true, false, false, false);
6057                         if (source.isSetTitle()) {
6058                                 newContent = newContent +("<table bgcolor=\"lightgrey\"><tr><td><font size=\"6\"><b>" +source.getTitle() +"</b></font></td></tr></table>");
6059                         }
6060                         String sourceContent = source.getContent();
6061                         logger.log(logger.EXTREME, "Merging contents into note");
6062                         logger.log(logger.EXTREME, sourceContent);
6063                         logger.log(logger.EXTREME, "End of content");
6064                         int startOfNote = sourceContent.indexOf("<en-note>");
6065                         sourceContent = sourceContent.substring(startOfNote+9);
6066                         int endOfNote = sourceContent.indexOf("</en-note>");
6067                         sourceContent = sourceContent.substring(0,endOfNote);
6068                         newContent = newContent + sourceContent;
6069                         logger.log(logger.EXTREME, "New note content");
6070                         logger.log(logger.EXTREME, newContent);
6071                         logger.log(logger.EXTREME, "End of content");
6072                         for (int j=0; j<source.getResourcesSize(); j++) {
6073                                 logger.log(logger.EXTREME, "Reassigning resource: "+source.getResources().get(j).getGuid());
6074                                 Resource r = source.getResources().get(j);
6075                                 Resource newRes = conn.getNoteTable().noteResourceTable.getNoteResource(r.getGuid(), true);
6076
6077                                 Calendar currentTime = new GregorianCalendar();
6078                                 Long l = new Long(currentTime.getTimeInMillis());
6079
6080                                 long prevGuid = 0;
6081                                 l = prevGuid;
6082                                 while (l == prevGuid) {
6083                                         currentTime = new GregorianCalendar();
6084                                         l = new Long(currentTime.getTimeInMillis());
6085                                 }
6086                                 String newResGuid = new String(Long.toString(l));
6087                                 newRes.setNoteGuid(targetGuid);
6088                                 newRes.setGuid(newResGuid);
6089                                 newRes.setUpdateSequenceNum(0);
6090                                 newRes.setActive(true);
6091                                 conn.getNoteTable().noteResourceTable.saveNoteResource(newRes, true);
6092                         }
6093                 }
6094                 logger.log(logger.EXTREME, "Updating note");
6095                 conn.getNoteTable().updateNoteContent(targetGuid, newContent +"</en-note>");
6096                 for (int i=0; i<sources.size(); i++) {
6097                         logger.log(logger.EXTREME, "Deleting note " +sources.get(i));
6098                         listManager.deleteNote(sources.get(i));
6099                 }
6100                 logger.log(logger.EXTREME, "Exiting merge note");
6101         }
6102         // A resource within a note has had a guid change
6103         @SuppressWarnings("unused")
6104         private void noteResourceGuidChanged(String noteGuid, String oldGuid, String newGuid) {
6105                 if (oldGuid != null && !oldGuid.equals(newGuid))
6106                         Global.resourceMap.put(oldGuid, newGuid);
6107         }
6108         // View a thumbnail of the note
6109         public void thumbnailView() {
6110
6111                 String thumbnailName = Global.getFileManager().getResDirPath("thumbnail-" + currentNoteGuid + ".png");
6112                 QFile thumbnail = new QFile(thumbnailName);
6113                 if (!thumbnail.exists()) {
6114
6115                         QImage img = new QImage();
6116                         img.loadFromData(conn.getNoteTable().getThumbnail(currentNoteGuid));
6117                         thumbnailViewer.setThumbnail(img);
6118                 } else
6119                         thumbnailViewer.setThumbnail(thumbnailName);
6120                 if (!thumbnailViewer.isVisible())
6121                         thumbnailViewer.showFullScreen();
6122         }
6123         // An error happened while saving a note.  Inform the user
6124         @SuppressWarnings("unused")
6125         private void saveRunnerError(String guid, String msg) {
6126                 if (msg == null) {
6127                         String title = "*Unknown*";
6128                         for (int i=0; i<listManager.getMasterNoteIndex().size(); i++) {
6129                                 if (listManager.getMasterNoteIndex().get(i).getGuid().equals(guid)) {
6130                                         title = listManager.getMasterNoteIndex().get(i).getTitle();
6131                                         i=listManager.getMasterNoteIndex().size();
6132                                 }
6133                         }
6134                         msg = tr("An error has happened while saving the note \"") +title+
6135                         tr("\".\n\nThis is probably due to a document that is too complex for NeighborNote to process.  "+
6136                         "As a result, changes to the note may not be saved properly in the database."+
6137                         "\n\nA cached copy is being preserved so you can recover any data, but data may" +
6138                         "\nbe lost.  Please review the note to recover any critical data before restarting.");
6139
6140                         QMessageBox.information(this, tr("Error Saving Note"), tr(msg));
6141                 }
6142         }
6143         private void thumbnailHTMLReady(String guid, QByteArray html, Integer zoom) {
6144                 logger.log(logger.HIGH, "Entering thumnailHTMLReady()");
6145                 logger.log(logger.HIGH, "Thumbnail ready for " +guid);
6146                 // Find an idle preview object
6147                 for (int i=0; i<thumbGenerators.size(); i++) {
6148                         if (thumbGenerators.get(i).mutex.tryLock()) {
6149                                 logger.log(logger.EXTREME, "Idle generator found - loading thumbnail for " +guid);
6150                                 thumbGenerators.get(i).loadContent(guid, html, zoom);
6151                                 return;
6152                         }
6153                 }
6154                 if (thumbGenerators.size() >= 1) {
6155                         logger.log(logger.EXTREME, "No available thumbnail generators.  Aborting " +guid);
6156                         return;
6157                 }
6158
6159                 logger.log(logger.EXTREME, "Creating new thumbnail generator " +guid);
6160                 Thumbnailer preview = new Thumbnailer(logger, conn, listManager, thumbnailRunner);
6161                 thumbGenerators.add(preview);
6162
6163                 if (preview.mutex.tryLock()) {
6164                         logger.log(logger.EXTREME, "Loading thumbnail for  " +guid);
6165                         preview.loadContent(guid, html, zoom);
6166                 }
6167                 logger.log(logger.HIGH, "Exiting thumnailHTMLReady()");
6168         }
6169
6170
6171
6172         //**********************************************************
6173     //**********************************************************
6174     //* Online user actions
6175     //**********************************************************
6176     //**********************************************************
6177     private void setupOnlineMenu() {
6178         if (!Global.isConnected) {
6179                 menuBar.noteOnlineHistoryAction.setEnabled(false);
6180                 menuBar.selectiveSyncAction.setEnabled(false);
6181                 return;
6182         } else {
6183                 menuBar.noteOnlineHistoryAction.setEnabled(true);
6184                 menuBar.selectiveSyncAction.setEnabled(true);
6185         }
6186     }
6187     @SuppressWarnings("unused")
6188         private void viewNoteHistory() {
6189         if (currentNoteGuid == null || currentNoteGuid.equals(""))
6190                 return;
6191         if (currentNote.getUpdateSequenceNum() == 0) {
6192                 setMessage(tr("Note has never been synchronized."));
6193                         QMessageBox.information(this, tr("Error"), tr("This note has never been sent to Evernote, so there is no history."));
6194                         return;
6195         }
6196
6197         setMessage(tr("Getting Note History"));
6198         waitCursor(true);
6199         Note currentOnlineNote = null;
6200         versions = null;
6201         try {
6202                 if (Global.isPremium())
6203                         versions = syncRunner.localNoteStore.listNoteVersions(syncRunner.authToken, currentNoteGuid);
6204                 else
6205                         versions = new ArrayList<NoteVersionId>();
6206                 currentOnlineNote = syncRunner.localNoteStore.getNote(syncRunner.authToken, currentNoteGuid, true, true, false, false);
6207                 } catch (EDAMUserException e) {
6208                         setMessage("EDAMUserException: " +e.getMessage());
6209                         return;
6210                 } catch (EDAMSystemException e) {
6211                         setMessage("EDAMSystemException: " +e.getMessage());
6212                         return;
6213                 } catch (EDAMNotFoundException e) {
6214                         setMessage(tr("Note not found on server."));
6215                         QMessageBox.information(this, tr("Error"), tr("This note could not be found on Evernote's servers."));
6216                         return;
6217                 } catch (TException e) {
6218                         setMessage("EDAMTransactionException: " +e.getMessage());
6219                         return;
6220                 }
6221
6222                 // If we've gotten this far, we have a good note.
6223                 if (historyWindow == null) {
6224                         // ICHANGED
6225                         historyWindow = new OnlineNoteHistory(logger, conn, cbObserver);
6226
6227                         historyWindow.historyCombo.activated.connect(this, "reloadHistoryWindow(String)");
6228                         historyWindow.restoreAsNew.clicked.connect(this, "restoreHistoryNoteAsNew()");
6229                         historyWindow.restore.clicked.connect(this, "restoreHistoryNote()");
6230                 } else {
6231                         historyWindow.historyCombo.clear();
6232                 }
6233                 boolean isDirty = conn.getNoteTable().isNoteDirty(currentNoteGuid);
6234                 if (currentNote.getUpdateSequenceNum() != currentOnlineNote.getUpdateSequenceNum())
6235                         isDirty = true;
6236                 historyWindow.setCurrent(isDirty);
6237
6238                 loadHistoryWindowContent(currentOnlineNote);
6239                 historyWindow.load(versions);
6240                 setMessage(tr("History retrieved"));
6241                 waitCursor(false);
6242                 historyWindow.exec();
6243     }
6244     private Note reloadHistoryWindow(String selection) {
6245         waitCursor(true);
6246                 String fmt = Global.getDateFormat() + " " + Global.getTimeFormat();
6247                 String dateTimeFormat = new String(fmt);
6248                 SimpleDateFormat simple = new SimpleDateFormat(dateTimeFormat);
6249                 int index = -1;
6250                 int usn = 0;
6251
6252                 for (int i=0; i<versions.size(); i++) {
6253                         StringBuilder versionDate = new StringBuilder(simple.format(versions.get(i).getSaved()));
6254                         if (versionDate.toString().equals(selection))
6255                                 index = i;
6256                 }
6257
6258                 if (index > -1 || selection.indexOf("Current") > -1) {
6259                         Note historyNote = null;
6260                         try {
6261                                 if (index > -1) {
6262                                         usn = versions.get(index).getUpdateSequenceNum();
6263                                         historyNote = syncRunner.localNoteStore.getNoteVersion(syncRunner.authToken, currentNoteGuid, usn, true, true, true);
6264                                 } else
6265                                         historyNote = syncRunner.localNoteStore.getNote(syncRunner.authToken, currentNoteGuid, true,true,true,true);
6266                         } catch (EDAMUserException e) {
6267                                 setMessage("EDAMUserException: " +e.getMessage());
6268                                 waitCursor(false);
6269                                 return null;
6270                         } catch (EDAMSystemException e) {
6271                                 setMessage("EDAMSystemException: " +e.getMessage());
6272                                 waitCursor(false);
6273                                 return null;
6274                         } catch (EDAMNotFoundException e) {
6275                                 setMessage("EDAMNotFoundException: " +e.getMessage());
6276                                 waitCursor(false);
6277                                 return null;
6278                         } catch (TException e) {
6279                                 setMessage("EDAMTransactionException: " +e.getMessage());
6280                                 waitCursor(false);
6281                                 return null;
6282                         }
6283
6284                         waitCursor(false);
6285                         if (historyNote != null)
6286                                 historyWindow.setContent(historyNote);
6287                         return historyNote;
6288                 }
6289                 waitCursor(false);
6290                 return null;
6291     }
6292     private void loadHistoryWindowContent(Note note) {
6293         note.setUpdateSequenceNum(0);
6294                 historyWindow.setContent(note);
6295     }
6296     @SuppressWarnings("unused")
6297         private void restoreHistoryNoteAsNew() {
6298         setMessage(tr("Restoring as new note."));
6299         duplicateNote(reloadHistoryWindow(historyWindow.historyCombo.currentText()));
6300         setMessage(tr("Note has been restored as a new note."));
6301     }
6302     @SuppressWarnings("unused")
6303         private void restoreHistoryNote() {
6304         setMessage(tr("Restoring note."));
6305         Note n = reloadHistoryWindow(historyWindow.historyCombo.currentText());
6306         conn.getNoteTable().expungeNote(n.getGuid(), true, false);
6307         n.setActive(true);
6308         n.setDeleted(0);
6309                 for (int i=0; i<n.getResourcesSize(); i++) {
6310                         n.getResources().get(i).setActive(true);
6311                         conn.getNoteTable().noteResourceTable.saveNoteResource(n.getResources().get(i), true);
6312                 }
6313                 NoteMetadata metadata = new NoteMetadata();
6314                 metadata.setGuid(n.getGuid());
6315         listManager.addNote(n, metadata);
6316         conn.getNoteTable().addNote(n, true);
6317         refreshEvernoteNote(true);
6318         setMessage(tr("Note has been restored."));
6319     }
6320     @SuppressWarnings("unused")
6321         private void setupSelectiveSync() {
6322
6323         // Get a list of valid notebooks
6324         List<Notebook> notebooks = null;
6325         List<Tag> tags = null;
6326         List<LinkedNotebook> linkedNotebooks = null;
6327         try {
6328                         notebooks = syncRunner.localNoteStore.listNotebooks(syncRunner.authToken);
6329                         tags = syncRunner.localNoteStore.listTags(syncRunner.authToken);
6330                         linkedNotebooks = syncRunner.localNoteStore.listLinkedNotebooks(syncRunner.authToken);
6331                 } catch (EDAMUserException e) {
6332                         setMessage("EDAMUserException: " +e.getMessage());
6333                         return;
6334                 } catch (EDAMSystemException e) {
6335                         setMessage("EDAMSystemException: " +e.getMessage());
6336                         return;
6337                 } catch (TException e) {
6338                         setMessage("EDAMTransactionException: " +e.getMessage());
6339                         return;
6340                 } catch (EDAMNotFoundException e) {
6341                         setMessage("EDAMNotFoundException: " +e.getMessage());
6342                         return;
6343                 }
6344
6345                 // Split up notebooks into synchronized & non-synchronized
6346         List<Notebook> ignoredBooks = new ArrayList<Notebook>();
6347         List<String> dbIgnoredNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
6348
6349         for (int i=notebooks.size()-1; i>=0; i--) {
6350                 for (int j=0; j<dbIgnoredNotebooks.size(); j++) {
6351                         if (notebooks.get(i).getGuid().equalsIgnoreCase(dbIgnoredNotebooks.get(j))) {
6352                                 ignoredBooks.add(notebooks.get(i));
6353                                 j=dbIgnoredNotebooks.size();
6354                         }
6355                 }
6356         }
6357
6358         // split up tags into synchronized & non-synchronized
6359         List<Tag> ignoredTags = new ArrayList<Tag>();
6360         List<String> dbIgnoredTags = conn.getSyncTable().getIgnoreRecords("TAG");
6361
6362         for (int i=tags.size()-1; i>=0; i--) {
6363                 for (int j=0; j<dbIgnoredTags.size(); j++) {
6364                         if (tags.get(i).getGuid().equalsIgnoreCase(dbIgnoredTags.get(j))) {
6365                                 ignoredTags.add(tags.get(i));
6366                                 j=dbIgnoredTags.size();
6367                         }
6368                 }
6369         }
6370
6371         // split up linked notebooks into synchronized & non-synchronized
6372         List<LinkedNotebook> ignoredLinkedNotebooks = new ArrayList<LinkedNotebook>();
6373         List<String> dbIgnoredLinkedNotebooks = conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK");
6374         for (int i=linkedNotebooks.size()-1; i>=0; i--) {
6375                 String notebookGuid = linkedNotebooks.get(i).getGuid();
6376                 for (int j=0; j<dbIgnoredLinkedNotebooks.size(); j++) {
6377                         if (notebookGuid.equalsIgnoreCase(dbIgnoredLinkedNotebooks.get(j))) {
6378                                 ignoredLinkedNotebooks.add(linkedNotebooks.get(i));
6379                                 j=dbIgnoredLinkedNotebooks.size();
6380                         }
6381                 }
6382         }
6383
6384                 IgnoreSync ignore = new IgnoreSync(notebooks, ignoredBooks, tags, ignoredTags, linkedNotebooks, ignoredLinkedNotebooks);
6385                 ignore.exec();
6386                 if (!ignore.okClicked())
6387                         return;
6388
6389                 waitCursor(true);
6390
6391                 // Clear out old notebooks & add  the new ones
6392                 List<String> oldIgnoreNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
6393                 for (int i=0; i<oldIgnoreNotebooks.size(); i++) {
6394                         conn.getSyncTable().deleteRecord("IGNORENOTEBOOK-"+oldIgnoreNotebooks.get(i));
6395                 }
6396
6397                 List<String> newNotebooks = new ArrayList<String>();
6398                 for (int i=ignore.getIgnoredBookList().count()-1; i>=0; i--) {
6399                         String text = ignore.getIgnoredBookList().takeItem(i).text();
6400                         for (int j=0; j<notebooks.size(); j++) {
6401                                 if (notebooks.get(j).getName().equalsIgnoreCase(text)) {
6402                                         Notebook n = notebooks.get(j);
6403                                         conn.getSyncTable().addRecord("IGNORENOTEBOOK-"+n.getGuid(), n.getGuid());
6404                                         j=notebooks.size();
6405                                         newNotebooks.add(n.getGuid());
6406                                 }
6407                         }
6408                 }
6409
6410                 // Clear out old tags & add new ones
6411                 List<String> oldIgnoreTags = conn.getSyncTable().getIgnoreRecords("TAG");
6412                 for (int i=0; i<oldIgnoreTags.size(); i++) {
6413                         conn.getSyncTable().deleteRecord("IGNORETAG-"+oldIgnoreTags.get(i));
6414                 }
6415
6416                 List<String> newTags = new ArrayList<String>();
6417                 for (int i=ignore.getIgnoredTagList().count()-1; i>=0; i--) {
6418                         String text = ignore.getIgnoredTagList().takeItem(i).text();
6419                         for (int j=0; j<tags.size(); j++) {
6420                                 if (tags.get(j).getName().equalsIgnoreCase(text)) {
6421                                         Tag t = tags.get(j);
6422                                         conn.getSyncTable().addRecord("IGNORETAG-"+t.getGuid(), t.getGuid());
6423                                         newTags.add(t.getGuid());
6424                                         j=tags.size();
6425                                 }
6426                         }
6427                 }
6428
6429                 // Clear out old tags & add new ones
6430                 List<String> oldIgnoreLinkedNotebooks = conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK");
6431                 for (int i=0; i<oldIgnoreLinkedNotebooks.size(); i++) {
6432                         conn.getSyncTable().deleteRecord("IGNORELINKEDNOTEBOOK-"+oldIgnoreLinkedNotebooks.get(i));
6433                 }
6434
6435                 List<String> newLinked = new ArrayList<String>();
6436                 for (int i=ignore.getIgnoredLinkedNotebookList().count()-1; i>=0; i--) {
6437                         String text = ignore.getIgnoredLinkedNotebookList().takeItem(i).text();
6438                         for (int j=0; j<linkedNotebooks.size(); j++) {
6439                                 if (linkedNotebooks.get(j).getShareName().equalsIgnoreCase(text)) {
6440                                         LinkedNotebook t = linkedNotebooks.get(j);
6441                                         conn.getSyncTable().addRecord("IGNORELINKEDNOTEBOOK-"+t.getGuid(), t.getGuid());
6442                                         newLinked.add(t.getGuid());
6443                                         j=linkedNotebooks.size();
6444                                 }
6445                         }
6446                 }
6447
6448                 conn.getNoteTable().expungeIgnoreSynchronizedNotes(newNotebooks, newTags, newLinked);
6449                 waitCursor(false);
6450                 refreshLists();
6451     }
6452
6453
6454         //**********************************************************
6455         //**********************************************************
6456         //* XML Modifying methods
6457         //**********************************************************
6458         //**********************************************************
6459         // An error has happended fetching a resource.  let the user know
6460     // ICHANGED
6461         private void resourceErrorMessage(int tabIndex) {
6462                 if (tabIndex < 0) {
6463                         return;
6464                 }
6465                 if (inkNote.get(tabIndex))
6466                         return;
6467                 waitCursor(false);
6468                 QMessageBox.information(this, tr("DOUGH!!!"), tr("Well, this is embarrassing."+
6469                 "\n\nSome attachments or images for this note appear to be missing from my database.\n"+
6470                 "In a perfect world this wouldn't happen, but it has.\n" +
6471                 "It is embarasing when a program like me, designed to save all your\n"+
6472                 "precious data, has a problem finding data.\n\n" +
6473                 "I guess life isn't fair, but I'll survive.  Somehow...\n\n" +
6474                 "In the mean time, I'm not going to let you make changes to this note.\n" +
6475                 "Don't get angry.  I'm doing it to prevent you from messing up\n"+
6476                 "this note on the Evernote servers.  Sorry."+
6477                 "\n\nP.S. You might want to re-synchronize to see if it corrects this problem.\nWho knows, you might get lucky."));
6478                 inkNote.put(tabIndex, true);
6479                 browserWindow.setReadOnly(true);
6480                 waitCursor(true);
6481         }
6482
6483
6484
6485
6486         //**********************************************************
6487         //**********************************************************
6488         //* Timer functions
6489         //**********************************************************
6490         //**********************************************************
6491         // We should now do a sync with Evernote
6492         private void syncTimer() {
6493                 logger.log(logger.EXTREME, "Entering NeverNote.syncTimer()");
6494                 syncRunner.syncNeeded = true;
6495                 syncRunner.disableUploads = Global.disableUploads;
6496                 syncStart();
6497                 logger.log(logger.EXTREME, "Leaving NeverNote.syncTimer()");
6498         }
6499         private void syncStart() {
6500                 logger.log(logger.EXTREME, "Entering NeverNote.syncStart()");
6501                 saveNote();
6502                 if (!syncRunning && Global.isConnected) {
6503                         syncRunner.setConnected(true);
6504                         syncRunner.setKeepRunning(Global.keepRunning);
6505                         syncRunner.syncDeletedContent = Global.synchronizeDeletedContent();
6506
6507                         if (syncThreadsReady > 0) {
6508                                 thumbnailRunner.interrupt = true;
6509                                 saveNoteIndexWidth();
6510                                 saveNoteColumnPositions();
6511                                 if (syncRunner.addWork("SYNC")) {
6512                                         syncRunning = true;
6513                                         syncRunner.syncNeeded = true;
6514                                         syncThreadsReady--;
6515                                 }
6516                         }
6517                 }
6518                 logger.log(logger.EXTREME, "Leaving NeverNote.syncStart");
6519         }
6520         @SuppressWarnings("unused")
6521         private void syncThreadComplete(Boolean refreshNeeded) {
6522                 setMessage(tr("Finalizing Synchronization"));
6523                 syncThreadsReady++;
6524                 syncRunning = false;
6525                 syncRunner.syncNeeded = false;
6526                 synchronizeAnimationTimer.stop();
6527                 synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
6528                 saveNote();
6529                 if (currentNote == null) {
6530                         currentNote = conn.getNoteTable().getNote(currentNoteGuid, false, false, false, false, true);
6531                 }
6532                 listManager.refreshNoteMetadata();
6533                 noteIndexUpdated(true);
6534                 noteTableView.selectionModel().blockSignals(true);
6535                 scrollToGuid(currentNoteGuid);
6536                 noteTableView.selectionModel().blockSignals(false);
6537                 refreshEvernoteNote(false);
6538                 scrollToGuid(currentNoteGuid);
6539                 waitCursor(false);
6540
6541                 // Check to see if there were any shared notebook errors
6542                 if (syncRunner.error && syncRunner.errorSharedNotebooks.size() > 0) {
6543                         String guid = syncRunner.errorSharedNotebooks.get(0);
6544                         String notebookGuid = conn.getLinkedNotebookTable().getLocalNotebookGuid(guid);
6545                         String localName = listManager.getNotebookNameByGuid(notebookGuid);
6546                         SharedNotebookSyncError syncDialog = new SharedNotebookSyncError(localName);
6547                         syncDialog.exec();
6548                         if (syncDialog.okPressed()) {
6549                                 if (syncDialog.doNothing.isChecked()) {
6550                                         syncRunner.errorSharedNotebooksIgnored.put(guid, guid);
6551                                         evernoteSync();
6552                                 }
6553                                 if (syncDialog.deleteNotebook.isChecked()) {
6554                                         conn.getNoteTable().expungeNotesByNotebook(notebookGuid, true, false);
6555                                         conn.getNotebookTable().expungeNotebook(notebookGuid, false);
6556                                         conn.getLinkedNotebookTable().expungeNotebook(guid, false);
6557                                         conn.getLinkedNotebookTable().expungeNotebook(guid, false);
6558                                         evernoteSync();
6559                                 }
6560                                 refreshLists();
6561                                 return;
6562                         }
6563                 }
6564
6565                 // Finalize the synchronization
6566                 if (!syncRunner.error)
6567                         setMessage(tr("Synchronization Complete"));
6568                 else
6569                         setMessage(tr("Synchronization completed with errors.  Please check the log for details."));
6570                 logger.log(logger.MEDIUM, "Sync complete.");
6571         }
6572         public void saveUploadAmount(long t) {
6573                 Global.saveUploadAmount(t);
6574         }
6575         public void saveUserInformation(User user) {
6576                 Global.saveUserInformation(user);
6577         }
6578         public void saveEvernoteUpdateCount(int i) {
6579                 Global.saveEvernoteUpdateCount(i);
6580         }
6581         public void refreshLists() {
6582                 logger.log(logger.EXTREME, "Entering NeverNote.refreshLists");
6583                 updateQuotaBar();
6584                 // ICHANGED
6585                 // すべてのタブのノートを調べて、Dirtyならばセーブする。その後refreshListsする。
6586                 Collection<Integer> tabIndex = noteDirty.keySet();
6587                 Iterator<Integer> indexIterator = tabIndex.iterator();
6588                 HashMap<Integer, Note> saveNotes = new HashMap<Integer, Note>();
6589                 HashMap<Integer, String> saveContents = new HashMap<Integer, String>();
6590                 for (boolean isNoteDirty: noteDirty.values()) {
6591                         int index = indexIterator.next();
6592                         if (isNoteDirty) {
6593                                 saveNotes.put(index, tabWindows.get(index).getBrowserWindow().getNote());
6594                                 saveContents.put(index, tabWindows.get(index).getBrowserWindow().getContent());
6595                         }
6596                 }
6597
6598                 listManager.saveUpdatedNotes(saveNotes, saveContents);
6599                 listManager.refreshLists();
6600
6601                 tagIndexUpdated(true);
6602                 notebookIndexUpdated();
6603                 savedSearchIndexUpdated();
6604                 listManager.loadNotesIndex();
6605
6606                 noteTableView.selectionModel().blockSignals(true);
6607         noteIndexUpdated(true);
6608                 noteTableView.selectionModel().blockSignals(false);
6609                 logger.log(logger.EXTREME, "Leaving NeverNote.refreshLists");
6610         }
6611
6612
6613         @SuppressWarnings("unused")
6614         private void authTimer() {
6615         Calendar cal = Calendar.getInstance();
6616
6617         // If we are not connected let's get out of here
6618         if (!Global.isConnected)
6619                 return;
6620
6621                 // If this is the first time through, then we need to set this
6622  //             if (syncRunner.authRefreshTime == 0 || cal.getTimeInMillis() > syncRunner.authRefreshTime)
6623 //                      syncRunner.authRefreshTime = cal.getTimeInMillis();
6624
6625 //              long now = new Date().getTime();
6626 //              if (now > Global.authRefreshTime && Global.isConnected) {
6627                         syncRunner.authRefreshNeeded = true;
6628                         syncStart();
6629 //              }
6630         }
6631         @SuppressWarnings("unused")
6632         private void authRefreshComplete(boolean goodSync) {
6633                 logger.log(logger.EXTREME, "Entering NeverNote.authRefreshComplete");
6634                 Global.isConnected = syncRunner.isConnected;
6635                 if (goodSync) {
6636 //                      authTimer.start((int)syncRunner.authTimeRemaining/4);
6637                         authTimer.start(1000*60*15);
6638                         logger.log(logger.LOW, "Authentication token has been renewed");
6639 //                      setMessage("Authentication token has been renewed.");
6640                 } else {
6641                         authTimer.start(1000*60*5);
6642                         logger.log(logger.LOW, "Authentication token renew has failed - retry in 5 minutes.");
6643 //                      setMessage("Authentication token renew has failed - retry in 5 minutes.");
6644                 }
6645                 logger.log(logger.EXTREME, "Leaving NeverNote.authRefreshComplete");
6646         }
6647
6648
6649         @SuppressWarnings("unused")
6650         private synchronized void indexTimer() {
6651                 logger.log(logger.EXTREME, "Index timer activated.  Sync running="+syncRunning);
6652                 if (syncRunning)
6653                         return;
6654                 if (!indexDisabled && indexRunner.idle) {
6655                         thumbnailRunner.interrupt = true;
6656                         indexRunner.addWork("SCAN");
6657                 }
6658                 logger.log(logger.EXTREME, "Leaving NeighborNote index timer");
6659         }
6660
6661         @SuppressWarnings("unused")
6662         private void indexStarted() {
6663                 setMessage(tr("Indexing notes"));
6664         }
6665         @SuppressWarnings("unused")
6666         private void indexComplete() {
6667                 setMessage(tr("Index complete"));
6668         }
6669         @SuppressWarnings("unused")
6670         private synchronized void toggleNoteIndexing() {
6671                 logger.log(logger.HIGH, "Entering NeverNote.toggleIndexing");
6672                 indexDisabled = !indexDisabled;
6673                 if (!indexDisabled)
6674                         setMessage(tr("Indexing is now enabled."));
6675                 else
6676                         setMessage(tr("Indexing is now disabled."));
6677                 menuBar.disableIndexing.setChecked(indexDisabled);
6678         logger.log(logger.HIGH, "Leaving NeverNote.toggleIndexing");
6679     }
6680
6681         @SuppressWarnings("unused")
6682         private void threadMonitorCheck() {
6683                 int MAX=3;
6684
6685
6686                 boolean alive;
6687                 alive = listManager.threadCheck(Global.tagCounterThreadId);
6688                 if (!alive) {
6689                         tagDeadCount++;
6690                         if (tagDeadCount > MAX && !disableTagThreadCheck) {
6691                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the tag counter thread has died.  I recommend "+
6692                                 "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6693                                 disableTagThreadCheck = true;
6694                         }
6695                 } else
6696                         tagDeadCount=0;
6697
6698                 alive = listManager.threadCheck(Global.notebookCounterThreadId);
6699                 if (!alive) {
6700                         notebookThreadDeadCount++;
6701                         if (notebookThreadDeadCount > MAX && !disableNotebookThreadCheck) {
6702                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the notebook counter thread has died.  I recommend "+
6703                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6704                                 disableNotebookThreadCheck=true;
6705                         }
6706                 } else
6707                         notebookThreadDeadCount=0;
6708
6709                 alive = listManager.threadCheck(Global.trashCounterThreadId);
6710                 if (!alive) {
6711                         trashDeadCount++;
6712                         if (trashDeadCount > MAX && !disableTrashThreadCheck) {
6713                                 QMessageBox.information(this, tr("A thread has died."), ("It appears as the trash counter thread has died.  I recommend "+
6714                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6715                                 disableTrashThreadCheck = true;
6716                         }
6717                 } else
6718                         trashDeadCount = 0;
6719
6720                 alive = listManager.threadCheck(Global.saveThreadId);
6721                 if (!alive) {
6722                         saveThreadDeadCount++;
6723                         if (saveThreadDeadCount > MAX && !disableSaveThreadCheck) {
6724                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the note saver thread has died.  I recommend "+
6725                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6726                                 disableSaveThreadCheck = true;
6727                         }
6728                 } else
6729                         saveThreadDeadCount=0;
6730
6731                 if (!syncThread.isAlive()) {
6732                         syncThreadDeadCount++;
6733                         if (syncThreadDeadCount > MAX && !disableSyncThreadCheck) {
6734                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the synchronization thread has died.  I recommend "+
6735                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6736                                 disableSyncThreadCheck = true;
6737                         }
6738                 } else
6739                         syncThreadDeadCount=0;
6740
6741                 if (!indexThread.isAlive()) {
6742                         indexThreadDeadCount++;
6743                         if (indexThreadDeadCount > MAX && !disableIndexThreadCheck) {
6744                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the index thread has died.  I recommend "+
6745                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6746                                 disableIndexThreadCheck = true;
6747                         }
6748                 } else
6749                         indexThreadDeadCount=0;
6750
6751                 if (!rensoNoteList.getEnRelatedNotesThread().isAlive()) {
6752                         enRelatedNotesThreadDeadCount++;
6753                         if (enRelatedNotesThreadDeadCount > MAX && !disableENRelatedNotesThreadCheck) {
6754                                 QMessageBox.information(this, tr("A thread has died."), tr("It appears as the Evernote Related Notes thread has died.  I recommend "+
6755                                         "checking stopping NeighborNote, saving the logs for later viewing, and restarting.  Sorry."));
6756                                 disableENRelatedNotesThreadCheck = true;
6757                         }
6758                 } else
6759                         enRelatedNotesThreadDeadCount=0;
6760         }
6761
6762         private void thumbnailTimer() {
6763                 if (Global.enableThumbnails() && !syncRunning && indexRunner.idle) {
6764                         thumbnailRunner.addWork("SCAN");
6765                 }
6766         }
6767
6768         //**************************************************
6769         //* Backup & Restore
6770         //**************************************************
6771         @SuppressWarnings("unused")
6772         private void databaseBackup() {
6773                 QFileDialog fd = new QFileDialog(this);
6774                 fd.setFileMode(FileMode.AnyFile);
6775                 fd.setConfirmOverwrite(true);
6776                 fd.setWindowTitle(tr("Backup Database"));
6777                 fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
6778                 fd.setAcceptMode(AcceptMode.AcceptSave);
6779                 if (saveLastPath == null || saveLastPath.equals(""))
6780                         fd.setDirectory(System.getProperty("user.home"));
6781                 else
6782                         fd.setDirectory(saveLastPath);
6783                 if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
6784                         return;
6785                 }
6786
6787
6788         waitCursor(true);
6789         saveLastPath = fd.selectedFiles().get(0);
6790         saveLastPath = saveLastPath.substring(0,saveLastPath.lastIndexOf("/"));
6791         setMessage(tr("Backing up database"));
6792         saveNote();
6793 //      conn.backupDatabase(Global.getUpdateSequenceNumber(), Global.getSequenceDate());
6794
6795         ExportData noteWriter = new ExportData(conn, true);
6796         String fileName = fd.selectedFiles().get(0);
6797
6798         if (!fileName.endsWith(".nnex"))
6799                 fileName = fileName +".nnex";
6800         noteWriter.exportData(fileName);
6801         setMessage(tr("Database backup completed."));
6802
6803
6804         waitCursor(false);
6805         }
6806         @SuppressWarnings("unused")
6807         private void databaseRestore() {
6808                 if (QMessageBox.question(this, tr("Confirmation"),
6809                                 tr("This is used to restore a database from backups.\n" +
6810                                 "It is HIGHLY recommened that this only be used to populate\n" +
6811                                 "an empty database.  Restoring into a database that\n already has data" +
6812                                 " can cause problems.\n\nAre you sure you want to continue?"),
6813                                 QMessageBox.StandardButton.Yes,
6814                                 QMessageBox.StandardButton.No)==StandardButton.No.value()) {
6815                                         return;
6816                                 }
6817
6818
6819                 QFileDialog fd = new QFileDialog(this);
6820                 fd.setFileMode(FileMode.ExistingFile);
6821                 fd.setConfirmOverwrite(true);
6822                 fd.setWindowTitle(tr("Restore Database"));
6823                 fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
6824                 fd.setAcceptMode(AcceptMode.AcceptOpen);
6825                 if (saveLastPath == null || saveLastPath.equals(""))
6826                         fd.setDirectory(System.getProperty("user.home"));
6827                 else
6828                         fd.setDirectory(saveLastPath);
6829                 if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
6830                         return;
6831                 }
6832
6833
6834                 waitCursor(true);
6835         saveLastPath = fd.selectedFiles().get(0);
6836         saveLastPath = saveLastPath.substring(0,saveLastPath.lastIndexOf("/"));
6837
6838                 setMessage(tr("Restoring database"));
6839         ImportData noteReader = new ImportData(conn, true);
6840         noteReader.importData(fd.selectedFiles().get(0));
6841
6842         if (noteReader.lastError != 0) {
6843                 setMessage(noteReader.getErrorMessage());
6844                 logger.log(logger.LOW, "Restore problem: " +noteReader.lastError);
6845                 waitCursor(false);
6846                 return;
6847         }
6848
6849         listManager.loadNoteTitleColors();
6850         refreshLists();
6851         refreshEvernoteNote(true);
6852         setMessage(tr("Database has been restored."));
6853         waitCursor(false);
6854         }
6855         @SuppressWarnings("unused")
6856         private void exportNotes() {
6857                 QFileDialog fd = new QFileDialog(this);
6858                 fd.setFileMode(FileMode.AnyFile);
6859                 fd.setConfirmOverwrite(true);
6860                 fd.setWindowTitle(tr("Backup Database"));
6861                 fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
6862                 fd.setAcceptMode(AcceptMode.AcceptSave);
6863                 fd.setDirectory(System.getProperty("user.home"));
6864                 if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
6865                         return;
6866                 }
6867
6868
6869         waitCursor(true);
6870         setMessage(tr("Exporting Notes"));
6871         saveNote();
6872
6873                 if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
6874                         selectedNoteGUIDs.add(currentNoteGuid);
6875
6876         ExportData noteWriter = new ExportData(conn, false, selectedNoteGUIDs);
6877         String fileName = fd.selectedFiles().get(0);
6878
6879         if (!fileName.endsWith(".nnex"))
6880                 fileName = fileName +".nnex";
6881         noteWriter.exportData(fileName);
6882         setMessage(tr("Export completed."));
6883
6884
6885         waitCursor(false);
6886
6887         }
6888         @SuppressWarnings("unused")
6889         private void importNotes() {
6890                 QFileDialog fd = new QFileDialog(this);
6891                 fd.setFileMode(FileMode.ExistingFile);
6892                 fd.setConfirmOverwrite(true);
6893                 fd.setWindowTitle(tr("Import Notes"));
6894                 fd.setFilter(tr("NixNote Export (*.nnex);;Evernote Export (*.enex);;All Files (*.*)"));
6895                 fd.setAcceptMode(AcceptMode.AcceptOpen);
6896                 if (saveLastPath == null || saveLastPath.equals(""))
6897                         fd.setDirectory(System.getProperty("user.home"));
6898                 else
6899                         fd.setDirectory(saveLastPath);
6900                 if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
6901                         return;
6902                 }
6903
6904
6905         waitCursor(true);
6906         setMessage(tr("Importing Notes"));
6907         saveNote();
6908
6909                 if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
6910                         selectedNoteGUIDs.add(currentNoteGuid);
6911
6912         String fileName = fd.selectedFiles().get(0);
6913 //      saveLastPath.substring(0,fileName.lastIndexOf("/"));
6914
6915         if (fileName.endsWith(".nnex")) {
6916                 ImportData noteReader = new ImportData(conn, false);
6917                 if (selectedNotebookGUIDs != null && selectedNotebookGUIDs.size() > 0)
6918                         noteReader.setNotebookGuid(selectedNotebookGUIDs.get(0));
6919                 else
6920                         noteReader.setNotebookGuid(listManager.getNotebookIndex().get(0).getGuid());
6921
6922                 noteReader.importData(fileName);
6923
6924                 if (noteReader.lastError != 0) {
6925                         setMessage(noteReader.getErrorMessage());
6926                         logger.log(logger.LOW, "Import problem: " +noteReader.lastError);
6927                         waitCursor(false);
6928                         return;
6929                 }
6930         } else {
6931                 if (fileName.endsWith(".enex")) {
6932                 ImportEnex noteReader = new ImportEnex(conn, false);
6933                         if (selectedNotebookGUIDs != null && selectedNotebookGUIDs.size() > 0)
6934                                 noteReader.setNotebookGuid(selectedNotebookGUIDs.get(0));
6935                         else
6936                                 noteReader.setNotebookGuid(listManager.getNotebookIndex().get(0).getGuid());
6937
6938                         waitCursor(false);
6939                         if (QMessageBox.question(this, tr("Confirmation"),
6940                                         tr("Create new tags from import?"),
6941                                         QMessageBox.StandardButton.Yes,
6942                                         QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
6943                                                                 noteReader.createNewTags = true;
6944                         } else
6945                                 noteReader.createNewTags = false;
6946                         waitCursor(true);
6947                         noteReader.importData(fileName);
6948
6949                         if (noteReader.lastError != 0) {
6950                                 setMessage(noteReader.getErrorMessage());
6951                                 logger.log(logger.LOW, "Import problem: " +noteReader.lastError);
6952                                 waitCursor(false);
6953                                 return;
6954                         }
6955                 }
6956         }
6957
6958         listManager.loadNoteTitleColors();
6959         refreshLists();
6960         refreshEvernoteNote(false);
6961         setMessage(tr("Notes have been imported."));
6962         waitCursor(false);
6963
6964         setMessage(tr("Import completed."));
6965
6966
6967         waitCursor(false);
6968
6969         }
6970
6971         //**************************************************
6972         //* Duplicate a note
6973         //**************************************************
6974         @SuppressWarnings("unused")
6975         private void duplicateNote() {
6976                 saveNote();
6977                 duplicateNote(currentNoteGuid);
6978         }
6979
6980         //**************************************************
6981         //* Action from when a user clicks Copy As URL
6982         //**************************************************
6983         @SuppressWarnings("unused")
6984         private void copyAsUrlClicked() {
6985                 QClipboard clipboard = QApplication.clipboard();
6986                 QMimeData mime = new QMimeData();
6987                 String url;
6988                 mime.setText(currentNoteGuid);
6989                 List<QUrl> urls = new ArrayList<QUrl>();
6990
6991                 // Start building the URL
6992                 User user = Global.getUserInformation();
6993
6994                 // Check that we have everything we need
6995                 if ((user.getShardId().equals("") || user.getId() == 0) && !Global.bypassSynchronizationWarning()) {
6996                         SynchronizationRequiredWarning warning = new SynchronizationRequiredWarning(this);
6997                         warning.exec();
6998                         if (!warning.neverSynchronize())
6999                                 return;
7000                         else {
7001                                 Global.setBypassSynchronizationWarning(true);
7002                                 user.setShardId("s0");
7003                                 user.setId(0);
7004                         }
7005                 }
7006
7007
7008                 // Start building a list of URLs based upon the selected notes
7009         noteTableView.showColumn(Global.noteTableGuidPosition);
7010
7011         List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
7012         if (!Global.isColumnVisible("guid"))
7013                 noteTableView.hideColumn(Global.noteTableGuidPosition);
7014
7015                 // Check that the note is either synchronized, or in a local notebook
7016                 for (int i=0; i<selections.size(); i++) {
7017                         QModelIndex index;
7018                         int row = selections.get(i).row();
7019                 index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
7020                 SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
7021                 String selectedGuid = (String)ix.values().toArray()[0];
7022
7023                 Note n = conn.getNoteTable().getNote(selectedGuid, false, false, false, false, false);
7024                 if (n.getUpdateSequenceNum() == 0 && !conn.getNotebookTable().isNotebookLocal(n.getNotebookGuid())) {
7025                         QMessageBox.critical(this, tr("Please Synchronize") ,tr("Please either synchronize or move any " +
7026                                         "new notes to a local notebook."));
7027                         return;
7028                 }
7029                 }
7030
7031                 // Start building the URLs
7032         for (int i=0; i<selections.size(); i++) {
7033                 QModelIndex index;
7034                         int row = selections.get(i).row();
7035                 index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
7036                 SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
7037                 String selectedGuid = (String)ix.values().toArray()[0];
7038                 mime.setText(selectedGuid);
7039
7040                 String lid;
7041                 String gid;
7042                 Note selectedNote = conn.getNoteTable().getNote(selectedGuid, false, false, false, false, false);
7043                 if (selectedNote.getUpdateSequenceNum() > 0) {
7044                         gid = selectedGuid;
7045                         lid = selectedGuid;
7046                 } else {
7047                         gid = "00000000-0000-0000-0000-000000000000";
7048                         lid = selectedGuid;
7049                 }
7050                 url = new String("evernote://///view/") + new String(user.getId() + "/" +user.getShardId() +"/"
7051                                 +gid+"/"+lid +"/");
7052                 urls.add(new QUrl(url));
7053         }
7054                 mime.setUrls(urls);
7055                 clipboard.setMimeData(mime);
7056         }
7057
7058
7059         //**************************************************
7060         //* Folder Imports
7061         //**************************************************
7062         public void setupFolderImports() {
7063                 List<WatchFolderRecord> records = conn.getWatchFolderTable().getAll();
7064
7065                 if (importKeepWatcher == null)
7066                         importKeepWatcher = new QFileSystemWatcher();
7067                 if (importDeleteWatcher == null) {
7068                         importDeleteWatcher = new QFileSystemWatcher();
7069                         for (int i=0; i<records.size(); i++) {
7070                                 if (!records.get(i).keep)
7071                                         folderImportDelete(records.get(i).folder);
7072                         }
7073                 }
7074
7075
7076
7077 //              importKeepWatcher.addPath(records.get(i).folder.replace('\\', '/'));
7078                 for (int i=0; i<records.size(); i++) {
7079                         logger.log(logger.LOW, "Adding file monitor: " +records.get(i).folder);
7080                         if (records.get(i).keep)
7081                                 importKeepWatcher.addPath(records.get(i).folder);
7082                         else
7083                                 importDeleteWatcher.addPath(records.get(i).folder);
7084                 }
7085
7086                 logger.log(logger.EXTREME, "List of directories being watched (kept)...");
7087                 List<String> monitorDelete = importKeepWatcher.directories();
7088                 for (int i=0; i<monitorDelete.size(); i++) {
7089                         logger.log(logger.EXTREME, monitorDelete.get(i));
7090                 }
7091                 logger.log(logger.EXTREME, "<end of list>");
7092                 logger.log(logger.EXTREME, "List of directories being watched (delete)...");
7093                 monitorDelete = importDeleteWatcher.directories();
7094                 for (int i=0; i<monitorDelete.size(); i++) {
7095                         logger.log(logger.EXTREME, monitorDelete.get(i));
7096                 }
7097                 logger.log(logger.EXTREME, "<end of list>");
7098
7099                 importKeepWatcher.directoryChanged.connect(this, "folderImportKeep(String)");
7100                 importDeleteWatcher.directoryChanged.connect(this, "folderImportDelete(String)");
7101
7102                 // Look at the files already there so we don't import them again if a new file is created
7103                 if (importedFiles == null) {
7104                         importedFiles = new ArrayList<String>();
7105                         for (int j=0; j<records.size(); j++) {
7106                                 QDir dir = new QDir(records.get(j).folder);
7107                                 List<QFileInfo> list = dir.entryInfoList();
7108                                 for (int k=0; k<list.size(); k++) {
7109                                         if (list.get(k).isFile())
7110                                                 importedFiles.add(list.get(k).absoluteFilePath());
7111                                 }
7112                         }
7113                 }
7114         }
7115
7116         // Menu folderImport action triggered
7117         public void folderImport() {
7118                 List<WatchFolderRecord> recs = conn.getWatchFolderTable().getAll();
7119                 WatchFolder dialog = new WatchFolder(recs, listManager.getNotebookIndex());
7120                 dialog.exec();
7121                 if (!dialog.okClicked())
7122                         return;
7123
7124                 // We have some sort of update.
7125                 if (importKeepWatcher.directories().size() > 0)
7126                         importKeepWatcher.removePaths(importKeepWatcher.directories());
7127                 if (importDeleteWatcher.directories().size() > 0)
7128                         importDeleteWatcher.removePaths(importDeleteWatcher.directories());
7129
7130                 conn.getWatchFolderTable().expungeAll();
7131                 // Start building from the table
7132                 for (int i=0; i<dialog.table.rowCount(); i++) {
7133                         QTableWidgetItem item = dialog.table.item(i, 0);
7134                         String dir = item.text();
7135                         item = dialog.table.item(i, 1);
7136                         String notebook = item.text();
7137                         item = dialog.table.item(i, 2);
7138                         boolean keep;
7139                         if (item.text().equalsIgnoreCase("Keep"))
7140                                 keep = true;
7141                         else
7142                                 keep = false;
7143
7144                         String guid = conn.getNotebookTable().findNotebookByName(notebook);
7145                         conn.getWatchFolderTable().addWatchFolder(dir, guid, keep, 0);
7146                 }
7147                 setupFolderImports();
7148         }
7149
7150
7151         public void folderImportKeep(String dirName) throws NoSuchAlgorithmException {
7152                 logger.log(logger.LOW, "Inside folderImportKeep");
7153                 String whichOS = System.getProperty("os.name");
7154                 if (whichOS.contains("Windows"))
7155                         dirName = dirName.replace('/','\\');
7156
7157                 FileImporter importer = new FileImporter(logger, conn);
7158
7159                 QDir dir = new QDir(dirName);
7160                 List<QFileInfo> list = dir.entryInfoList();
7161                 String notebook = conn.getWatchFolderTable().getNotebook(dirName);
7162
7163                 for (int i=0; i<list.size(); i++){
7164                         logger.log(logger.LOW, "File found: " +list.get(i).fileName());
7165                         boolean redundant = false;
7166                         // Check if we've already imported this one or if it existed before
7167                         for (int j=0; j<importedFiles.size(); j++) {
7168                                 logger.log(logger.LOW, "redundant file list: " +list.get(i).absoluteFilePath());
7169                                 if (importedFiles.get(j).equals(list.get(i).absoluteFilePath()))
7170                                         redundant = true;
7171                         }
7172
7173                         logger.log(logger.LOW, "Checking if redundant: " +redundant);
7174                         if (!redundant) {
7175                                 importer.setFileInfo(list.get(i));
7176                                 importer.setFileName(list.get(i).absoluteFilePath());
7177
7178
7179                                 logger.log(logger.LOW, "File importing is a file: " +list.get(i).isFile());
7180                                 logger.log(logger.LOW, "File importing is a valid: " +importer.isValidType());
7181                                 if (list.get(i).isFile() && importer.isValidType()) {
7182
7183                                         if (!importer.importFile()) {
7184                                                 // If we can't get to the file, it is probably locked.  We'll try again later.
7185                                                 logger.log(logger.LOW, "Unable to save externally edited file.  Saving for later.");
7186                                                 importFilesKeep.add(list.get(i).absoluteFilePath());
7187                                         } else {
7188
7189                                                 Note newNote = importer.getNote();
7190                                                 newNote.setNotebookGuid(notebook);
7191                                                 newNote.setTitle(dir.at(i));
7192                                                 NoteMetadata metadata = new NoteMetadata();
7193                                                 metadata.setDirty(true);
7194                                                 metadata.setGuid(newNote.getGuid());
7195                                                 listManager.addNote(newNote, metadata);
7196                                                 conn.getNoteTable().addNote(newNote, true);
7197                                                 noteTableView.insertRow(newNote, metadata, true, -1);
7198                                                 listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
7199                                                 listManager.countNotebookResults(listManager.getNoteIndex());
7200                                                 importedFiles.add(list.get(i).absoluteFilePath());
7201                                         }
7202                                 }
7203                         }
7204                 }
7205
7206
7207         }
7208
7209         public void folderImportDelete(String dirName) {
7210                 logger.log(logger.LOW, "Inside folderImportDelete");
7211                 String whichOS = System.getProperty("os.name");
7212                 if (whichOS.contains("Windows"))
7213                         dirName = dirName.replace('/','\\');
7214
7215                 FileImporter importer = new FileImporter(logger, conn);
7216                 QDir dir = new QDir(dirName);
7217                 List<QFileInfo> list = dir.entryInfoList();
7218                 String notebook = conn.getWatchFolderTable().getNotebook(dirName);
7219
7220                 for (int i=0; i<list.size(); i++){
7221                         logger.log(logger.LOW, "File found: " +list.get(i).fileName());
7222                         importer.setFileInfo(list.get(i));
7223                         importer.setFileName(list.get(i).absoluteFilePath());
7224
7225                         logger.log(logger.LOW, "File importing is a file: " +list.get(i).isFile());
7226                         logger.log(logger.LOW, "File importing is a valid: " +importer.isValidType());
7227                         if (list.get(i).isFile() && importer.isValidType()) {
7228
7229                                 if (!importer.importFile()) {
7230                                         // If we can't get to the file, it is probably locked.  We'll try again later.
7231                                         logger.log(logger.LOW, "Unable to save externally edited file.  Saving for later.");
7232                                         importFilesKeep.add(list.get(i).absoluteFilePath());
7233                                 } else {
7234
7235                                         Note newNote = importer.getNote();
7236                                         newNote.setNotebookGuid(notebook);
7237                                         newNote.setTitle(dir.at(i));
7238                                         NoteMetadata metadata = new NoteMetadata();
7239                                         metadata.setDirty(true);
7240                                         metadata.setGuid(newNote.getGuid());
7241                                         listManager.addNote(newNote, metadata);
7242                                         conn.getNoteTable().addNote(newNote, true);
7243                                         noteTableView.insertRow(newNote, metadata, true, -1);
7244                                         listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
7245                                         listManager.countNotebookResults(listManager.getNoteIndex());
7246                                         dir.remove(dir.at(i));
7247                                 }
7248                         }
7249                 }
7250         }
7251
7252
7253         //**************************************************
7254         //* External events
7255         //**************************************************
7256         private void externalFileEdited(String fileName) throws NoSuchAlgorithmException {
7257                 logger.log(logger.HIGH, "Entering exernalFileEdited");
7258
7259                 // Strip URL prefix and base dir path
7260                 String dPath = FileUtils.toForwardSlashedPath(Global.getFileManager().getResDirPath());
7261                 String name = fileName.replace(dPath, "");
7262                 int pos = name.lastIndexOf('.');
7263                 String guid = name;
7264                 if (pos > -1) {
7265                         guid = guid.substring(0,pos);
7266                 }
7267                 pos = name.lastIndexOf(Global.attachmentNameDelimeter);
7268                 if (pos > -1) {
7269                         guid = name.substring(0, pos);
7270                 }
7271
7272                 QFile file = new QFile(fileName);
7273         if (!file.open(new QIODevice.OpenMode(QIODevice.OpenModeFlag.ReadOnly))) {
7274                 // If we can't get to the file, it is probably locked.  We'll try again later.
7275                 logger.log(logger.LOW, "Unable to save externally edited file.  Saving for later.");
7276                 externalFiles.add(fileName);
7277                 return;
7278                 }
7279                 QByteArray binData = file.readAll();
7280         file.close();
7281         if (binData.size() == 0) {
7282                 // If we can't get to the file, it is probably locked.  We'll try again later.
7283                 logger.log(logger.LOW, "Unable to save externally edited file.  Saving for later.");
7284                 externalFiles.add(fileName);
7285                 return;
7286         }
7287
7288         Resource r = conn.getNoteTable().noteResourceTable.getNoteResource(guid, true);
7289         if (r==null)
7290                 r = conn.getNoteTable().noteResourceTable.getNoteResource(Global.resourceMap.get(guid), true);
7291         if (r == null || r.getData() == null || r.getData().getBody() == null)
7292                 return;
7293         String oldHash = Global.byteArrayToHexString(r.getData().getBodyHash());
7294         MessageDigest md = MessageDigest.getInstance("MD5");
7295                 md.update(binData.toByteArray());
7296                 byte[] hash = md.digest();
7297         String newHash = Global.byteArrayToHexString(hash);
7298         if (r.getNoteGuid().equalsIgnoreCase(currentNoteGuid)) {
7299                 updateResourceContentHash(browserWindow, r.getGuid(), oldHash, newHash);
7300         }
7301         if (externalWindows.containsKey(r.getNoteGuid())) {
7302                 updateResourceContentHash(externalWindows.get(r.getNoteGuid()).getBrowserWindow(),
7303                                 r.getGuid(), oldHash, newHash);
7304         }
7305         conn.getNoteTable().updateResourceContentHash(r.getNoteGuid(), oldHash, newHash);
7306         Data data = r.getData();
7307         data.setBody(binData.toByteArray());
7308         data.setBodyHash(hash);
7309         logger.log(logger.LOW, "externalFileEdited: " +data.getSize() +" bytes");
7310         r.setData(data);
7311         conn.getNoteTable().noteResourceTable.updateNoteResource(r,true);
7312
7313         if (r.getNoteGuid().equals(currentNoteGuid)) {
7314                         QWebSettings.setMaximumPagesInCache(0);
7315                         QWebSettings.setObjectCacheCapacities(0, 0, 0);
7316                         refreshEvernoteNote(true);
7317                         browserWindow.getBrowser().triggerPageAction(WebAction.Reload);
7318         }
7319
7320         if (externalWindows.containsKey(r.getNoteGuid())) {
7321                 QWebSettings.setMaximumPagesInCache(0);
7322                         QWebSettings.setObjectCacheCapacities(0, 0, 0);
7323                         externalWindows.get(r.getNoteGuid()).getBrowserWindow().getBrowser().triggerPageAction(WebAction.Reload);
7324
7325         }
7326
7327                 logger.log(logger.HIGH, "Exiting externalFielEdited");
7328         }
7329         // This is a timer event that tries to save any external files that were edited.  This
7330         // is only needed if we couldn't save a file earlier.
7331         public void externalFileEditedSaver() {
7332                 for (int i=externalFiles.size()-1; i>=0; i--) {
7333                         try {
7334                                 logger.log(logger.MEDIUM, "Trying to save " +externalFiles.get(i));
7335                                 externalFileEdited(externalFiles.get(i));
7336                                 externalFiles.remove(i);
7337                         } catch (NoSuchAlgorithmException e) {e.printStackTrace();}
7338                 }
7339                 for (int i=0; i<importFilesKeep.size(); i++) {
7340                         try {
7341                                 logger.log(logger.MEDIUM, "Trying to save " +importFilesKeep.get(i));
7342                                 folderImportKeep(importFilesKeep.get(i));
7343                                 importFilesKeep.remove(i);
7344                         } catch (NoSuchAlgorithmException e) {e.printStackTrace();}
7345                 }
7346                 for (int i=0; i<importFilesDelete.size(); i++) {
7347                         logger.log(logger.MEDIUM, "Trying to save " +importFilesDelete.get(i));
7348                         folderImportDelete(importFilesDelete.get(i));
7349                         importFilesDelete.remove(i);
7350                 }
7351         }
7352
7353
7354
7355
7356         // If an attachment on the current note was edited, we need to update the current notes's hash
7357         // Update a note content's hash.  This happens if a resource is edited outside of NN
7358         public void updateResourceContentHash(BrowserWindow browser, String guid, String oldHash, String newHash) {
7359                 int position = browserWindow.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=");
7360                 int endPos;
7361                 for (;position>-1;) {
7362                         endPos = browser.getContent().indexOf(">", position+1);
7363                         String oldSegment = browser.getContent().substring(position,endPos);
7364                         int hashPos = oldSegment.indexOf("hash=\"");
7365                         int hashEnd = oldSegment.indexOf("\"", hashPos+7);
7366                         String hash = oldSegment.substring(hashPos+6, hashEnd);
7367                         if (hash.equalsIgnoreCase(oldHash)) {
7368                                 String newSegment = oldSegment.replace(oldHash, newHash);
7369                                 String content = browser.getContent().substring(0,position) +
7370                                                  newSegment +
7371                                                  browser.getContent().substring(endPos);
7372                                 browser.setContent(new QByteArray(content));;
7373                         }
7374
7375                         position = browser.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=", position+1);
7376                 }
7377         }
7378
7379
7380         //*************************************************
7381         //* Minimize to tray
7382         //*************************************************
7383         @Override
7384         public void changeEvent(QEvent e) {
7385                 if (e.type() == QEvent.Type.WindowStateChange) {
7386                         if (QSystemTrayIcon.isSystemTrayAvailable()) {
7387                                 if (isMinimized() && (Global.showTrayIcon() || Global.showTrayIcon())) {
7388                                         e.accept();
7389                                         QTimer.singleShot(10, this, "hide()");
7390                                         return;
7391                                 }
7392                                 if (isMaximized())
7393                                         windowMaximized = true;
7394                                 else
7395                                         windowMaximized = false;
7396                         }
7397                 }
7398         }
7399
7400         //*************************************************
7401         //* Check database userid & passwords
7402         //*************************************************
7403         private static boolean databaseCheck(String url,String userid, String userPassword, String cypherPassword) {
7404                         Connection connection;
7405
7406                         try {
7407                                 Class.forName("org.h2.Driver");
7408                         } catch (ClassNotFoundException e1) {
7409                                 e1.printStackTrace();
7410                                 System.exit(16);
7411                         }
7412
7413                         try {
7414                                 String passwordString = null;
7415                                 if (cypherPassword==null || cypherPassword.trim().equals(""))
7416                                         passwordString = userPassword;
7417                                 else
7418                                         passwordString = cypherPassword+" "+userPassword;
7419                                 connection = DriverManager.getConnection(url,userid,passwordString);
7420                         } catch (SQLException e) {
7421                                 return false;
7422                         }
7423                         try {
7424                                 connection.close();
7425                         } catch (SQLException e) {
7426                                 e.printStackTrace();
7427                         }
7428                         return true;
7429         }
7430
7431         //*************************************************
7432         //* View / Hide source HTML for a note
7433         //*************************************************
7434         public void viewSource() {
7435                 // ICHANGED すべてのタブに対して
7436         for(int i = 0; i < tabBrowser.count(); i++){
7437                 BrowserWindow browser = ((TabBrowse) tabBrowser.widget(i)).getBrowserWindow();
7438                 browser.showSource(menuBar.viewSource.isChecked());
7439         }
7440         }
7441         //*************************************************
7442         // Block the program.  This is used for things
7443         // like async web calls.
7444         //*************************************************
7445         @SuppressWarnings("unused")
7446         private void blockApplication(BrowserWindow b) {
7447                 // Block all signals
7448                 waitCursor(true);
7449                 blockSignals(true);
7450
7451                 blockTimer = new QTimer();
7452                 blockTimer.setSingleShot(true);
7453                 blockTimer.setInterval(15000);
7454                 blockTimer.timeout.connect(this, "unblockApplication()");
7455                 blockingWindow  = b;
7456                 blockTimer.start();
7457         }
7458
7459         @SuppressWarnings("unused")
7460         private void unblockApplication() {
7461                 waitCursor(false);
7462                 if (blockingWindow != null && new GregorianCalendar().getTimeInMillis() > blockingWindow.unblockTime && blockingWindow.unblockTime != -1) {
7463                         QMessageBox.critical(null, tr("No Response from CodeCogs") ,tr("Unable to contact CodeCogs for LaTeX formula."));
7464                         blockingWindow.unblockTime = -1;
7465                         blockingWindow.awaitingHttpResponse = false;
7466                 }
7467                 blockingWindow = null;
7468                 blockSignals(false);
7469         }
7470
7471         // ICHANGED
7472         // タブが変更された
7473         private void tabWindowChanged(int index) {
7474                 if (index < 0 || index >= tabBrowser.count()) {
7475                         return;
7476                 }
7477
7478                 saveNote();
7479
7480                 TabBrowse tab = (TabBrowse) tabBrowser.widget(index);
7481                 if (tab.getBrowserWindow().getNote() != null) {
7482                         currentNoteGuid = tab.getBrowserWindow().getNote().getGuid();
7483                         currentNote = tab.getBrowserWindow().getNote();
7484                 } else {
7485                         currentNoteGuid = "";
7486                         currentNote = null;
7487                 }
7488
7489                 // 選択ノートを更新
7490                 selectedNoteGUIDs.clear();
7491                 if (currentNoteGuid != null && !currentNoteGuid.equals("")) {
7492                         selectedNoteGUIDs.add(currentNoteGuid);
7493                 }
7494
7495                 // browserWindowを更新
7496                 browserWindow.noteSignal.noteChanged.disconnect(this,"setNoteDirty()");
7497                 browserWindow.focusLost.disconnect(this, "saveNote()");
7498                 browserWindow = tab.getBrowserWindow();
7499                 browserWindow.noteSignal.noteChanged.connect(this, "setNoteDirty()");
7500                 browserWindow.focusLost.connect(this, "saveNote()");
7501                 // メニューバーのボタンを新しいbrowserWindowに合わせる
7502                 menuBar.refreshTargetWindow();
7503
7504                 // 現在ゴミ箱かつ移るタブがアクティブなら通常テーブルに、現在通常テーブルかつこれから非アクティブのタブに移るならゴミ箱を表示させる
7505                 boolean nextIsActive;
7506                 if (tab.getBrowserWindow().getNote() != null) {
7507                         nextIsActive = tab.getBrowserWindow().getNote().isActive();
7508                 } else {
7509                         nextIsActive = true;
7510                 }
7511                 if (Global.showDeleted && nextIsActive) {
7512                         switchNoteTable(false);
7513                 } else if (!Global.showDeleted && !nextIsActive) {
7514                         switchNoteTable(true);
7515                 }
7516
7517                 // noteTableViewの選択を変更するとselectionChangedが発生してしまうので一度切断
7518                 noteTableView.selectionModel().selectionChanged.disconnect(this,"noteTableSelection()");
7519                 scrollToGuid(currentNoteGuid);
7520                 // 再接続
7521                 noteTableView.selectionModel().selectionChanged.connect(this,"noteTableSelection()");
7522
7523                 menuBar.noteDuplicateAction.setEnabled(true);
7524                 menuBar.noteOnlineHistoryAction.setEnabled(true);
7525                 menuBar.noteMergeAction.setEnabled(true);
7526
7527                 if (Global.showDeleted) {
7528                         menuBar.noteDuplicateAction.setEnabled(false);
7529                 }
7530                 if (!Global.isConnected) {
7531                         menuBar.noteOnlineHistoryAction.setEnabled(false);
7532                 }
7533                 menuBar.noteMergeAction.setEnabled(false);
7534                 try {
7535                         int row = noteTableView.selectionModel().selectedRows().get(0).row();
7536                         if (row == 0)
7537                                 upButton.setEnabled(false);
7538                         else
7539                                 upButton.setEnabled(true);
7540                         if (row < listManager.getNoteTableModel().rowCount() - 1)
7541                                 downButton.setEnabled(true);
7542                         else
7543                                 downButton.setEnabled(false);
7544                 } catch (Exception e) {
7545                         upButton.setEnabled(false);
7546                         downButton.setEnabled(false);
7547                 }
7548
7549                 int currentIndex = tabBrowser.currentIndex();
7550                 ArrayList<String> histGuids = historyGuids.get(currentIndex);
7551                 int histPosition = historyPosition.get(currentIndex);
7552
7553                 // prev, nextボタンの有効・無効化
7554                 nextButton.setEnabled(true);
7555                 prevButton.setEnabled(true);
7556
7557                 if (histPosition <= 1){
7558                         prevButton.setEnabled(false);
7559                 }
7560                 if (histPosition == histGuids.size()){
7561                         nextButton.setEnabled(false);
7562                 }
7563
7564                 refreshEvernoteNote(true);
7565
7566                 // 連想ノートリストを更新
7567                 rensoNoteList.refreshRensoNoteList(currentNoteGuid);
7568         }
7569
7570         // ICHANGD
7571         // 生存ノートテーブル→ゴミ箱（またはその逆）に切り替える
7572         private void switchNoteTable(boolean toDeleted) {
7573         clearNotebookFilter();
7574         clearTagFilter();
7575         clearAttributeFilter();
7576         clearSavedSearchFilter();
7577
7578         listManager.getSelectedNotebooks().clear();
7579         listManager.getSelectedTags().clear();
7580         listManager.setSelectedSavedSearch("");
7581
7582         // toggle the add buttons
7583         newButton.setEnabled(!newButton.isEnabled());
7584         menuBar.noteAdd.setEnabled(newButton.isEnabled());
7585         menuBar.noteAddNewTab.setEnabled(newButton.isEnabled());
7586                 if (currentNoteGuid == null || currentNoteGuid.equals("")) {
7587                         menuBar.noteAddNewTab.setEnabled(false);
7588                 }
7589         menuBar.noteAdd.setVisible(true);
7590
7591         if (!toDeleted) {       // 生存ノートテーブルへ
7592                 trashTree.itemSelectionChanged.disconnect(this, "trashTreeSelection()");
7593                 trashTree.clearSelection();
7594                 trashTree.itemSelectionChanged.connect(this, "trashTreeSelection()");
7595                 Global.showDeleted = false;
7596                 menuBar.noteRestoreAction.setEnabled(false);
7597                 menuBar.noteRestoreAction.setVisible(false);
7598                 // ICHANGED ゴミ箱から元の画面に戻す。連想ノートリストをONに。
7599                 rensoNoteListDock.setEnabled(true);
7600         } else {        // ゴミ箱へ
7601                 trashTree.itemSelectionChanged.disconnect(this, "trashTreeSelection()");
7602                 trashTree.setCurrentItem(trashTree.getTrashItem());
7603                 trashTree.itemSelectionChanged.connect(this, "trashTreeSelection()");
7604                 Global.showDeleted = true;
7605                 menuBar.noteRestoreAction.setEnabled(true);
7606                 menuBar.noteRestoreAction.setVisible(true);
7607                 // ICHANGED ゴミ箱を開く。連想ノートリストをOFFに。
7608                 rensoNoteListDock.setEnabled(false);
7609         }
7610
7611         listManager.loadNotesIndex();
7612         // noteTableViewの選択を変更するとselectionChangedが発生してしまうので一度切断
7613         noteTableView.selectionModel().selectionChanged.disconnect(this,"noteTableSelection()");
7614         noteIndexUpdated(false);
7615         // 再接続
7616         noteTableView.selectionModel().selectionChanged.connect(this,"noteTableSelection()");
7617
7618         browserWindow.setReadOnly(!newButton.isEnabled());
7619         }
7620
7621         // ICHANGED
7622         // ユーザが連想ノートリストのアイテムを選択した時の処理
7623         @SuppressWarnings("unused")
7624         private void rensoNoteItemPressed(QListWidgetItem current) {
7625                 logger.log(logger.HIGH, "Nevernote.rensoNoteSelectionChangeに入った");
7626
7627                 rensoNotePressedItemGuid = rensoNoteList.getNoteGuid(current);
7628
7629                 // 右クリックだったら終了
7630                 if (QApplication.mouseButtons().isSet(MouseButton.RightButton)) {
7631                         return;
7632                 }
7633
7634                 saveNote();
7635
7636                 String prevCurrentNoteGuid = new String(currentNoteGuid);
7637
7638                 for (int i = 0; i < noteTableView.model().rowCount(); i++) {
7639                         QModelIndex modelIndex = noteTableView.model().index(i,
7640                                         Global.noteTableGuidPosition);
7641                         if (modelIndex != null) {
7642                                 SortedMap<Integer, Object> ix = noteTableView.model().itemData(
7643                                                 modelIndex);
7644                                 String tableGuid = (String) ix.values().toArray()[0];
7645                                 if (tableGuid.equals(rensoNotePressedItemGuid)) {
7646                                         noteTableView.selectRow(i);
7647                                         break;
7648                                 }
7649                         }
7650                 }
7651
7652                 // 連想ノートリストアイテムクリック操作を記録
7653                 conn.getHistoryTable().addHistory("rensoItemClick", prevCurrentNoteGuid, currentNoteGuid);
7654
7655                 logger.log(logger.HIGH, "Nevernote.rensoNoteSelectionChangeを出た");
7656         }
7657
7658         // ICHANGED
7659         // 関連ノートリストからノートを除外する
7660         @SuppressWarnings("unused")
7661         private void excludeNote() {
7662                 if (rensoNotePressedItemGuid != null) {
7663                         saveNote();
7664                         excludeNote(rensoNotePressedItemGuid);
7665                 }
7666         }
7667
7668         // ICHANGED
7669         // 関連ノートリストからノートを除外する
7670         private void excludeNote(String guid) {
7671                 if (Global.verifyExclude()) {
7672                         String msg;
7673                         Note note = conn.getNoteTable().getNote(guid, false, false, false, false, false);
7674                         String title = note.getTitle();
7675                         if (title != null) {
7676                                 msg = new String(tr("Exclude note \"") +title +"\"?");
7677                         } else {
7678                                 msg = new String(tr("Exclude note selected note?"));
7679                         }
7680
7681                         if (QMessageBox.question(this, tr("Confirmation"), msg,
7682                                         QMessageBox.StandardButton.Yes,
7683                                         QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
7684                                         return;
7685                         }
7686                 }
7687
7688                 // Historyデータベースから除外するノートのデータを削除
7689                 conn.getHistoryTable().expungeHistory(guid, currentNoteGuid);
7690
7691                 // 除外ノートテーブルに追加
7692                 conn.getExcludedTable().addExclusion(guid, currentNoteGuid);
7693
7694                 rensoNoteList.refreshRensoNoteList(currentNoteGuid);
7695         }
7696
7697         // ICHANGED
7698         // 関連ノートリストのノートにスターを付ける
7699         @SuppressWarnings("unused")
7700         private void starNote() {
7701                 if (rensoNotePressedItemGuid != null) {
7702                         saveNote();
7703                         starNote(rensoNotePressedItemGuid);
7704                 }
7705         }
7706
7707         // ICHANGED
7708         // 関連ノートリストのノートにスターを付ける
7709         private void starNote(String guid) {
7710                 // スター付きノートテーブルに追加
7711                 conn.getStaredTable().addStaredItem(currentNoteGuid, guid);
7712
7713                 rensoNoteList.refreshRensoNoteList(currentNoteGuid);
7714         }
7715
7716         // ICHANGED
7717         // 関連ノートリストのノートからスターを外す
7718         @SuppressWarnings("unused")
7719         private void unstarNote() {
7720                 if (rensoNotePressedItemGuid != null) {
7721                         saveNote();
7722                         unstarNote(rensoNotePressedItemGuid);
7723                 }
7724         }
7725
7726         // ICHANGED
7727         // 関連ノートリストのノートからスターを外す
7728         private void unstarNote(String guid) {
7729                 // スター付きノートテーブルから削除
7730                 conn.getStaredTable().removeStaredItem(currentNoteGuid, guid);
7731
7732                 rensoNoteList.refreshRensoNoteList(currentNoteGuid);
7733         }
7734
7735         // ICHANGED
7736         // currentNoteGuidを返す
7737         public String getCurrentNoteGuid() {
7738                 return currentNoteGuid;
7739         }
7740
7741         @SuppressWarnings("unused")
7742         // タブ入れ替えによってタブインデックスが変わったので、インデックスで管理しているハッシュマップ達も入れ替える
7743         private void tabIndexChanged(int from, int to) {
7744                 // tabWindows
7745                 TabBrowse tab = tabWindows.get(from);
7746                 tabWindows.put(from, tabWindows.get(to));
7747                 tabWindows.put(to, tab);
7748                 // noteDirty
7749                 boolean isNoteDirty = noteDirty.get(from);
7750                 noteDirty.put(from, noteDirty.get(to));
7751                 noteDirty.put(to, isNoteDirty);
7752                 // inkNote
7753                 boolean isInkNote = inkNote.get(from);
7754                 inkNote.put(from, inkNote.get(to));
7755                 inkNote.put(to, isInkNote);
7756                 // readOnly
7757                 boolean isReadOnly = readOnly.get(from);
7758                 readOnly.put(from, readOnly.get(to));
7759                 readOnly.put(to, isReadOnly);
7760                 // historyGuids
7761                 ArrayList<String> histGuids = historyGuids.get(from);
7762                 historyGuids.put(from, historyGuids.get(to));
7763                 historyGuids.put(to, histGuids);
7764                 // historyPosition
7765                 int histPosition = historyPosition.get(from);
7766                 historyPosition.put(from, historyPosition.get(to));
7767                 historyPosition.put(to, histPosition);
7768                 // fromHistory
7769                 boolean fromHist = fromHistory.get(from);
7770                 fromHistory.put(from,  fromHistory.get(to));
7771                 fromHistory.put(to, fromHist);
7772         }
7773
7774         // 連想ノートリストのgetter
7775         public RensoNoteList getRensoNoteList() {
7776                 return rensoNoteList;
7777         }
7778 }