src/cx/fbn/nevernote/NeverNote.java

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