src/cx/fbn/nevernote/NeverNote.java

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