import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
+import java.net.Authenticator;
+import java.net.PasswordAuthentication;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
+import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
+import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
+import java.util.Iterator;
import java.util.List;
import java.util.SortedMap;
import java.util.Vector;
import org.apache.thrift.TException;
+import org.h2.tools.ChangeFileEncryption;
import com.evernote.edam.error.EDAMNotFoundException;
import com.evernote.edam.error.EDAMSystemException;
import com.evernote.edam.type.User;
import com.trolltech.qt.QThread;
import com.trolltech.qt.core.QByteArray;
-import com.trolltech.qt.core.QDataStream;
import com.trolltech.qt.core.QDateTime;
import com.trolltech.qt.core.QDir;
+import com.trolltech.qt.core.QEvent;
import com.trolltech.qt.core.QFile;
import com.trolltech.qt.core.QFileInfo;
import com.trolltech.qt.core.QFileSystemWatcher;
import com.trolltech.qt.core.QIODevice;
+import com.trolltech.qt.core.QIODevice.OpenModeFlag;
+import com.trolltech.qt.core.QLocale;
import com.trolltech.qt.core.QModelIndex;
import com.trolltech.qt.core.QSize;
import com.trolltech.qt.core.QTemporaryFile;
import com.trolltech.qt.core.QTextCodec;
import com.trolltech.qt.core.QThreadPool;
import com.trolltech.qt.core.QTimer;
+import com.trolltech.qt.core.QTranslator;
import com.trolltech.qt.core.QUrl;
import com.trolltech.qt.core.Qt;
-import com.trolltech.qt.core.QIODevice.OpenModeFlag;
+import com.trolltech.qt.core.Qt.BGMode;
+import com.trolltech.qt.core.Qt.ItemDataRole;
import com.trolltech.qt.core.Qt.SortOrder;
import com.trolltech.qt.core.Qt.WidgetAttribute;
import com.trolltech.qt.gui.QAbstractItemView;
+import com.trolltech.qt.gui.QAbstractItemView.ScrollHint;
import com.trolltech.qt.gui.QAction;
import com.trolltech.qt.gui.QApplication;
import com.trolltech.qt.gui.QCloseEvent;
import com.trolltech.qt.gui.QColor;
import com.trolltech.qt.gui.QComboBox;
-import com.trolltech.qt.gui.QCursor;
+import com.trolltech.qt.gui.QComboBox.InsertPolicy;
import com.trolltech.qt.gui.QDesktopServices;
import com.trolltech.qt.gui.QDialog;
import com.trolltech.qt.gui.QFileDialog;
+import com.trolltech.qt.gui.QFileDialog.AcceptMode;
+import com.trolltech.qt.gui.QFileDialog.FileMode;
import com.trolltech.qt.gui.QGridLayout;
import com.trolltech.qt.gui.QHBoxLayout;
import com.trolltech.qt.gui.QIcon;
import com.trolltech.qt.gui.QMainWindow;
import com.trolltech.qt.gui.QMenu;
import com.trolltech.qt.gui.QMessageBox;
+import com.trolltech.qt.gui.QMessageBox.StandardButton;
+import com.trolltech.qt.gui.QPainter;
+import com.trolltech.qt.gui.QPalette.ColorRole;
import com.trolltech.qt.gui.QPixmap;
import com.trolltech.qt.gui.QPrintDialog;
import com.trolltech.qt.gui.QPrinter;
-import com.trolltech.qt.gui.QProgressBar;
import com.trolltech.qt.gui.QSizePolicy;
+import com.trolltech.qt.gui.QSizePolicy.Policy;
import com.trolltech.qt.gui.QSpinBox;
import com.trolltech.qt.gui.QSplashScreen;
import com.trolltech.qt.gui.QSplitter;
import com.trolltech.qt.gui.QTextEdit;
import com.trolltech.qt.gui.QToolBar;
import com.trolltech.qt.gui.QTreeWidgetItem;
-import com.trolltech.qt.gui.QAbstractItemView.ScrollHint;
-import com.trolltech.qt.gui.QComboBox.InsertPolicy;
-import com.trolltech.qt.gui.QFileDialog.AcceptMode;
-import com.trolltech.qt.gui.QFileDialog.FileMode;
-import com.trolltech.qt.gui.QMessageBox.StandardButton;
-import com.trolltech.qt.gui.QSizePolicy.Policy;
-import com.trolltech.qt.webkit.QWebSettings;
import com.trolltech.qt.webkit.QWebPage.WebAction;
-import com.trolltech.qt.xml.QDomAttr;
-import com.trolltech.qt.xml.QDomDocument;
-import com.trolltech.qt.xml.QDomElement;
-import com.trolltech.qt.xml.QDomNodeList;
+import com.trolltech.qt.webkit.QWebSettings;
import cx.fbn.nevernote.config.InitializationException;
import cx.fbn.nevernote.config.StartupConfig;
import cx.fbn.nevernote.dialog.AccountDialog;
import cx.fbn.nevernote.dialog.ConfigDialog;
+import cx.fbn.nevernote.dialog.DBEncryptDialog;
import cx.fbn.nevernote.dialog.DatabaseLoginDialog;
import cx.fbn.nevernote.dialog.DatabaseStatus;
import cx.fbn.nevernote.dialog.FindDialog;
import cx.fbn.nevernote.dialog.NotebookEdit;
import cx.fbn.nevernote.dialog.OnlineNoteHistory;
import cx.fbn.nevernote.dialog.SavedSearchEdit;
+import cx.fbn.nevernote.dialog.SetIcon;
import cx.fbn.nevernote.dialog.TagEdit;
import cx.fbn.nevernote.dialog.ThumbnailViewer;
import cx.fbn.nevernote.dialog.WatchFolder;
-import cx.fbn.nevernote.filters.EnSearch;
import cx.fbn.nevernote.gui.AttributeTreeWidget;
import cx.fbn.nevernote.gui.BrowserWindow;
import cx.fbn.nevernote.gui.DateAttributeFilterTable;
+import cx.fbn.nevernote.gui.ExternalBrowse;
import cx.fbn.nevernote.gui.MainMenuBar;
import cx.fbn.nevernote.gui.NotebookTreeWidget;
-import cx.fbn.nevernote.gui.PDFPreview;
import cx.fbn.nevernote.gui.SavedSearchTreeWidget;
import cx.fbn.nevernote.gui.TableView;
import cx.fbn.nevernote.gui.TagTreeWidget;
import cx.fbn.nevernote.gui.Thumbnailer;
import cx.fbn.nevernote.gui.TrashTreeWidget;
-import cx.fbn.nevernote.signals.DBRunnerSignal;
+import cx.fbn.nevernote.gui.controls.QuotaProgressBar;
import cx.fbn.nevernote.sql.DatabaseConnection;
-import cx.fbn.nevernote.sql.runners.WatchFolderRecord;
-import cx.fbn.nevernote.threads.DBRunner;
+import cx.fbn.nevernote.sql.WatchFolderRecord;
import cx.fbn.nevernote.threads.IndexRunner;
import cx.fbn.nevernote.threads.SyncRunner;
+import cx.fbn.nevernote.threads.ThumbnailRunner;
import cx.fbn.nevernote.utilities.AESEncrypter;
import cx.fbn.nevernote.utilities.ApplicationLogger;
import cx.fbn.nevernote.utilities.FileImporter;
+import cx.fbn.nevernote.utilities.FileUtils;
import cx.fbn.nevernote.utilities.ListManager;
import cx.fbn.nevernote.utilities.SyncTimes;
import cx.fbn.nevernote.xml.ExportData;
import cx.fbn.nevernote.xml.ImportData;
-import cx.fbn.nevernote.xml.XMLInsertHilight;
+import cx.fbn.nevernote.xml.NoteFormatter;
public class NeverNote extends QMainWindow{
TableView noteTableView; // List of notes (the widget).
public BrowserWindow browserWindow; // Window containing browser & labels
- QToolBar toolBar; // The tool bar under the menu
-// QLineEdit searchField; // The search filter bar on the toolbar
+ public QToolBar toolBar; // The tool bar under the menu
QComboBox searchField; // search filter bar on the toolbar;
boolean searchPerformed = false; // Search was done?
- QProgressBar quotaBar; // The current quota usage
+ QuotaProgressBar quotaBar; // The current quota usage
ApplicationLogger logger;
List<String> selectedNotebookGUIDs; // List of notebook GUIDs
List<String> selectedTagGUIDs; // List of selected tag GUIDs
+ String previousSelectedTag; // Tag that was selected last time
List<String> selectedNoteGUIDs; // List of selected notes
+ String previousSelectedNotebook; // Notebook selected last time
String selectedSavedSearchGUID; // Currently selected saved searches
+ private final HashMap<String, ExternalBrowse> externalWindows; // Notes being edited by an external window;
NoteFilter filter; // Note filter
String currentNoteGuid; // GUID of the current note
boolean noteDirty; // Has the note been changed?
boolean inkNote; // if this is an ink note, it is read only
- QThread dbThread; // Thread to handle DB communication
ListManager listManager; // DB runnable task
List<QTemporaryFile> tempFiles; // Array of temporary files;
QTimer syncTimer; // Sync on an interval
QTimer syncDelayTimer; // Sync delay to free up database
SyncRunner syncRunner; // thread to do a sync.
- QThread syncThread;
+ QThread syncThread; // Thread which talks to evernote
+ ThumbnailRunner thumbnailRunner; // Runner for thumbnail thread
+ QThread thumbnailThread; // Thread that generates pretty pictures
QTimer saveTimer; // Timer to save note contents
QTimer authTimer; // Refresh authentication
QTimer externalFileSaveTimer; // Save files altered externally
+ QTimer thumbnailTimer; // Wakeup & scan for thumbnails
List<String> externalFiles; // External files to save later
List<String> importFilesKeep; // Auto-import files to save later
List<String> importFilesDelete; // Auto-import files to save later
QAction downButton; // Go to the next item in the list
QAction upButton; // Go to the prev. item in the list;
QAction synchronizeButton; // Synchronize with Evernote
- List<QIcon> synchronizeAnimation; // Synchronize movie
+ QAction allNotesButton; // Reset & view all notes
QTimer synchronizeAnimationTimer; // Timer to change animation button
- int synchronizeFrame; // Current frame being viewed
+ double synchronizeIconAngle; // Used to rotate sync icon
QAction printButton; // Print Button
QAction tagButton; // Tag edit button
QAction attributeButton; // Attribute information button
int historyPosition; // Position within the viewed items
boolean fromHistory; // Is this from the history queue?
String trashNoteGuid; // Guid to restore / set into or out of trash to save position
- Thumbnailer preview; // generate preview image
+ List<Thumbnailer> thumbGenerators; // generate preview image
ThumbnailViewer thumbnailViewer; // View preview thumbnail;
+ boolean encryptOnShutdown; // should I encrypt when I close?
+ boolean decryptOnShutdown; // should I decrypt on shutdown;
+ String encryptCipher; // What cipher should I use?
+ Signal0 minimizeToTray;
+ boolean windowMaximized = false; // Keep track of the window state for restores
+ List<String> pdfReadyQueue; // Queue of PDFs that are ready to be rendered.
+
String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
//***************************************************************
//***************************************************************
// Application Constructor
- public NeverNote() {
-
- if (!lockApplication()) {
- System.exit(0);
+ public NeverNote(DatabaseConnection dbConn) {
+ conn = dbConn;
+ if (conn.getConnection() == null) {
+ String msg = "Unable to connect to the database.\n\nThe most probable reason is that some other process\n" +
+ "is accessing the database or NeverNote is already running.\n\n" +
+ "Please end any other process or shutdown the other NeverNote before starting.\n\nExiting program.";
+
+ QMessageBox.critical(null, "Database Connection Error",msg);
+ System.exit(16);
}
+
thread().setPriority(Thread.MAX_PRIORITY);
logger = new ApplicationLogger("nevernote.log");
- logger.log(logger.HIGH, tr("Starting Application"));
- conn = new DatabaseConnection(logger, Global.mainThreadId);
- conn.dbSetup();
-
- logger.log(logger.EXTREME, tr("Creating index connection"));
- logger.log(logger.EXTREME, tr("Building DB thread"));
- Global.dbRunnerSignal = new DBRunnerSignal();
- if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") > -1) {
- boolean goodCheck = false;
- while (!goodCheck) {
- DatabaseLoginDialog dialog = new DatabaseLoginDialog();
- dialog.exec();
- if (!dialog.okPressed())
- System.exit(0);
- Global.cipherPassword = dialog.getPassword();
- goodCheck = databaseCheck(Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
- }
- }
- Global.dbRunner = new DBRunner(Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
- logger.log(logger.EXTREME, tr("Starting DB thread"));
- dbThread = new QThread(Global.dbRunner, "Database Thread");
- dbThread.start();
- logger.log(logger.EXTREME, tr("DB Thread has started"));
- Global.dbRunnerSignal.start.emit();
- logger.log(logger.EXTREME, tr("Setting main thread DB connection"));
- logger.log(logger.EXTREME, tr("main DB thread setup complete."));
+ logger.log(logger.HIGH, "Starting Application");
+
+ decryptOnShutdown = false;
+ encryptOnShutdown = false;
conn.checkDatabaseVersion();
+
+
// Start building the invalid XML tables
Global.invalidElements = conn.getInvalidXMLTable().getInvalidElements();
List<String> elements = conn.getInvalidXMLTable().getInvalidAttributeElements();
Global.invalidAttributes.put(elements.get(i), conn.getInvalidXMLTable().getInvalidAttributes(elements.get(i)));
}
- logger.log(logger.EXTREME, tr("Starting GUI build"));
+ logger.log(logger.EXTREME, "Starting GUI build");
+
+ QTranslator nevernoteTranslator = new QTranslator();
+ nevernoteTranslator.load(Global.getFileManager().getTranslateFilePath("nevernote_" + QLocale.system().name() + ".qm"));
+ QApplication.instance().installTranslator(nevernoteTranslator);
+
Global.originalPalette = QApplication.palette();
QApplication.setStyle(Global.getStyle());
if (Global.useStandardPalette())
QApplication.setPalette(QApplication.style().standardPalette());
setWindowTitle("NeverNote");
-
+
mainLeftRightSplitter = new QSplitter();
setCentralWidget(mainLeftRightSplitter);
leftSplitter1 = new QSplitter();
indexRunnerCount = 1;
QThreadPool.globalInstance().setMaxThreadCount(indexRunnerCount+5); // increase max thread count
- logger.log(logger.EXTREME, tr("Building list manager"));
- listManager = new ListManager(conn, logger, Global.mainThreadId);
+ logger.log(logger.EXTREME, "Building list manager");
+ listManager = new ListManager(conn, logger);
- logger.log(logger.EXTREME, tr("Building index runners & timers"));
- indexRunner = new IndexRunner("indexRunner.log");
+ logger.log(logger.EXTREME, "Building index runners & timers");
+ indexRunner = new IndexRunner("indexRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
indexThread = new QThread(indexRunner, "Index Thread");
indexThread.start();
synchronizeAnimationTimer.timeout.connect(this, "updateSyncButton()");
indexTimer = new QTimer();
- indexTime = 1000*60*5; // look for unindexed every 5 minutes
-// indexTime = 1000*5;
+ indexTime = 1000*Global.getIndexThreadSleepInterval();
indexTimer.start(indexTime); // Start indexing timer
indexTimer.timeout.connect(this, "indexTimer()");
indexDisabled = false;
indexRunning = false;
- logger.log(logger.EXTREME, tr("Setting sync thread & timers"));
+ logger.log(logger.EXTREME, "Setting sync thread & timers");
syncThreadsReady=1;
- syncRunner = new SyncRunner("syncRunner.log");
+ syncRunner = new SyncRunner("syncRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
syncTime = new SyncTimes().timeValue(Global.getSyncInterval());
syncTimer = new QTimer();
syncTimer.timeout.connect(this, "syncTimer()");
syncThread.start();
- logger.log(logger.EXTREME, tr("Starting authentication timer"));
+ logger.log(logger.EXTREME, "Starting thumnail thread");
+ pdfReadyQueue = new ArrayList<String>();
+ thumbnailRunner = new ThumbnailRunner("thumbnailRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ thumbnailThread = new QThread(thumbnailRunner, "Thumbnail Thread");
+ thumbnailRunner.noteSignal.thumbnailPageReady.connect(this, "thumbnailHTMLReady(String,QByteArray,Integer)");
+ thumbnailThread.start();
+ thumbGenerators = new ArrayList<Thumbnailer>();
+ thumbnailTimer = new QTimer();
+ thumbnailTimer.timeout.connect(this, "thumbnailTimer()");
+ thumbnailTimer();
+ thumbnailTimer.setInterval(60*1000); // Thumbnail every minute
+ thumbnailTimer.start();
+
+ logger.log(logger.EXTREME, "Starting authentication timer");
authTimer = new QTimer();
authTimer.timeout.connect(this, "authTimer()");
authTimer.start(1000*60*15);
syncRunner.syncSignal.authRefreshComplete.connect(this, "authRefreshComplete(boolean)");
- logger.log(logger.EXTREME, tr("Setting save note timer"));
+ logger.log(logger.EXTREME, "Setting save note timer");
saveTimer = new QTimer();
saveTimer.timeout.connect(this, "saveNote()");
if (Global.getAutoSaveInterval() > 0) {
saveTimer.setInterval(1000*60*Global.getAutoSaveInterval());
-// saveTimer.setInterval(1000*10); // auto save every 20 seconds;
saveTimer.start();
}
+ listManager.saveRunner.noteSignals.noteSaveRunnerError.connect(this, "saveRunnerError(String, String)");
-// Global.trace();
- logger.log(logger.EXTREME, tr("Starting external file monitor timer"));
+ logger.log(logger.EXTREME, "Starting external file monitor timer");
externalFileSaveTimer = new QTimer();
externalFileSaveTimer.timeout.connect(this, "externalFileEditedSaver()");
externalFileSaveTimer.setInterval(1000*5); // save every 5 seconds;
tagTree = new TagTreeWidget(conn);
savedSearchTree = new SavedSearchTreeWidget();
trashTree = new TrashTreeWidget();
- noteTableView = new TableView(logger);
+ noteTableView = new TableView(logger, listManager);
QGridLayout leftGrid = new QGridLayout();
leftSplitter1.setLayout(leftGrid);
noteCache = new HashMap<String,String>();
browserWindow = new BrowserWindow(conn);
- browserIndexSplitter.addWidget(noteTableView);
- browserIndexSplitter.addWidget(browserWindow);
-
mainLeftRightSplitter.addWidget(leftSplitter1);
mainLeftRightSplitter.addWidget(browserIndexSplitter);
-
+
+ if (Global.getListView() == Global.View_List_Wide) {
+ browserIndexSplitter.addWidget(noteTableView);
+ browserIndexSplitter.addWidget(browserWindow);
+ } else {
+ mainLeftRightSplitter.addWidget(noteTableView);
+ mainLeftRightSplitter.addWidget(browserWindow);
+ }
+
searchField = new QComboBox();
searchField.setEditable(true);
searchField.activatedIndex.connect(this, "searchFieldChanged()");
searchField.setDuplicatesEnabled(false);
searchField.editTextChanged.connect(this,"searchFieldTextChanged(String)");
- quotaBar = new QProgressBar();
+ quotaBar = new QuotaProgressBar();
// Setup the thumbnail viewer
thumbnailViewer = new ThumbnailViewer();
thumbnailViewer.downArrow.connect(this, "downAction()");
thumbnailViewer.leftArrow.connect(this, "nextViewedAction()");
thumbnailViewer.rightArrow.connect(this, "previousViewedAction()");
+
+ //Setup external browser manager
+ externalWindows = new HashMap<String, ExternalBrowse>();
listManager.loadNotesIndex();
initializeNotebookTree();
notebookTree.setDeleteAction(menuBar.notebookDeleteAction);
notebookTree.setEditAction(menuBar.notebookEditAction);
notebookTree.setAddAction(menuBar.notebookAddAction);
+ notebookTree.setIconAction(menuBar.notebookIconAction);
notebookTree.setVisible(Global.isWindowVisible("notebookTree"));
notebookTree.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
menuBar.hideNotebooks.setChecked(Global.isWindowVisible("notebookTree"));
noteTableView.resetViewport.connect(this, "scrollToCurrentGuid()");
noteTableView.doubleClicked.connect(this, "listDoubleClick()");
listManager.trashSignal.countChanged.connect(trashTree, "updateCounts(Integer)");
+
+ quotaBar.setMouseClickAction(menuBar.accountAction);
+
trashTree.load();
trashTree.itemSelectionChanged.connect(this, "trashTreeSelection()");
trashTree.setEmptyAction(menuBar.emptyTrashAction);
trashTree.setVisible(Global.isWindowVisible("trashTree"));
menuBar.hideTrash.setChecked(Global.isWindowVisible("trashTree"));
trashTree.updateCounts(listManager.getTrashCount());
-
attributeTree.setVisible(Global.isWindowVisible("attributeTree"));
menuBar.hideAttributes.setChecked(Global.isWindowVisible("attributeTree"));
toggleEditorButtonBar();
if (!Global.isWindowVisible("leftPanel"))
menuBar.hideLeftSide.setChecked(true);
+ if (Global.isWindowVisible("noteInformation"))
+ toggleNoteInformation();
setMenuBar(menuBar);
setupToolBar();
showColumns();
menuBar.showEditorBar.setChecked(Global.isWindowVisible("editorButtonBar"));
if (menuBar.showEditorBar.isChecked())
- showEditorButtons();
+ showEditorButtons(browserWindow);
tagIndexUpdated(true);
savedSearchIndexUpdated();
notebookIndexUpdated();
setupFolderImports();
loadStyleSheet();
- restoreWindowState();
+ restoreWindowState(true);
if (Global.mimicEvernoteInterface) {
notebookTree.selectGuid("");
historyGuids.add(currentNoteGuid);
historyPosition = 1;
+ if (Global.getListView() == Global.View_List_Narrow) {
+ menuBar.narrowListView.setChecked(true);
+// narrowListView();
+ }
+ else{
+ menuBar.wideListView.setChecked(true);
+// wideListView();
+ }
+
+ if (Global.getListView() == Global.View_List_Wide) {
+ browserIndexSplitter.addWidget(noteTableView);
+ browserIndexSplitter.addWidget(browserWindow);
+ } else {
+ mainLeftRightSplitter.addWidget(noteTableView);
+ mainLeftRightSplitter.addWidget(browserWindow);
+ }
+
int sortCol = Global.getSortColumn();
int sortOrder = Global.getSortOrder();
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+
}
QApplication.initialize(args);
QPixmap pixmap = new QPixmap("classpath:cx/fbn/nevernote/icons/splash_logo.png");
QSplashScreen splash = new QSplashScreen(pixmap);
+ boolean showSplash;
+
+ DatabaseConnection dbConn;
- try {
- initializeGlobalSettings(args);
- } catch (InitializationException e) {
- QMessageBox.critical(null, "Startup error", "Aborting: " + e.getMessage());
- return;
- }
+ try {
+ initializeGlobalSettings(args);
+
+ showSplash = Global.isWindowVisible("SplashScreen");
+ if (showSplash)
+ splash.show();
+
+ dbConn = setupDatabaseConnection();
+
+ // Must be last stage of setup - only safe once DB is open hence we know we are the only instance running
+ Global.getFileManager().purgeResDirectory();
+
+ } catch (InitializationException e) {
+ // Fatal
+ e.printStackTrace();
+ QMessageBox.critical(null, "Startup error", "Aborting: " + e.getMessage());
+ return;
+ }
+
+ NeverNote application = new NeverNote(dbConn);
- boolean showSplash = Global.isWindowVisible("SplashScreen");
- if (showSplash)
- splash.show();
- NeverNote application = new NeverNote();
application.setAttribute(WidgetAttribute.WA_DeleteOnClose, true);
- if (Global.wasWindowMaximized())
- application.showMaximized();
- else
- application.show();
+ if (Global.startMinimized())
+ application.showMinimized();
+ else {
+ if (Global.wasWindowMaximized())
+ application.showMaximized();
+ else
+ application.show();
+ }
+
if (showSplash)
splash.finish(application);
QApplication.exec();
QApplication.exit();
}
- private static void initializeGlobalSettings(String[] args) throws InitializationException {
- StartupConfig startupConfig = new StartupConfig();
+ /**
+ * Open the internal database, or create if not present
+ *
+ * @throws InitializationException when opening the database fails, e.g. because another process has it locked
+ */
+ private static DatabaseConnection setupDatabaseConnection() throws InitializationException {
+ ApplicationLogger logger = new ApplicationLogger("nevernote-database.log");
+
+ File f = Global.getFileManager().getDbDirFile(Global.databaseName + ".h2.db");
+ boolean dbExists = f.exists();
+ if (!dbExists)
+ Global.setDatabaseUrl("");
+
+ if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") > -1) {
+ boolean goodCheck = false;
+ while (!goodCheck) {
+ DatabaseLoginDialog dialog = new DatabaseLoginDialog();
+ dialog.exec();
+ if (!dialog.okPressed())
+ System.exit(0);
+ Global.cipherPassword = dialog.getPassword();
+ goodCheck = databaseCheck(Global.getDatabaseUrl(), Global.getDatabaseUserid(),
+ Global.getDatabaseUserPassword(), Global.cipherPassword);
+ }
+ }
+ DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ return dbConn;
+ }
+
+ // Encrypt the database upon shutdown
+ private void encryptOnShutdown() {
+ String dbPath= Global.getFileManager().getDbDirPath("");
+ String dbName = "NeverNote";
+ try {
+ Statement st = conn.getConnection().createStatement();
+ st.execute("shutdown");
+ if (QMessageBox.question(this, "Are you sure",
+ "Are you sure you wish to encrypt the database?",
+ QMessageBox.StandardButton.Yes,
+ QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
+ ChangeFileEncryption.execute(dbPath, dbName, encryptCipher, null, Global.cipherPassword.toCharArray(), true);
+ Global.setDatabaseUrl(Global.getDatabaseUrl() + ";CIPHER="+encryptCipher);
+ QMessageBox.information(this, "Encryption Complete", "Encryption is complete");
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+
+ // Decrypt the database upon shutdown
+ private void decryptOnShutdown() {
+ String dbPath= Global.getFileManager().getDbDirPath("");
+ String dbName = "NeverNote";
+ try {
+ Statement st = conn.getConnection().createStatement();
+ st.execute("shutdown");
+ if (Global.getDatabaseUrl().toUpperCase().indexOf(";CIPHER=AES") > -1)
+ encryptCipher = "AES";
+ else
+ encryptCipher = "XTEA";
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Are you sure",
+ "Are you sure you wish to decrypt the database?"),
+ QMessageBox.StandardButton.Yes,
+ QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
+
+ ChangeFileEncryption.execute(dbPath, dbName, encryptCipher, Global.cipherPassword.toCharArray(), null, true);
+ Global.setDatabaseUrl("");
+ QMessageBox.information(this, tr("Decryption Complete"), tr("Decryption is complete"));
+ }
+ } catch (SQLException e) {
+ e.printStackTrace();
+ }
+ }
+ /**
+ * Encrypt/Decrypt the local database
+ **/
+ public void doDatabaseEncrypt() {
+ // The database is not currently encrypted
+ if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") == -1) {
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Encrypting the database is used" +
+ "to enhance security and is performed\nupon shutdown, but please be aware that if"+
+ " you lose the password your\nis lost forever.\n\nIt is highly recommended you " +
+ "perform a backup and/or fully synchronize\n prior to executing this funtction.\n\n" +
+ "Do you wish to proceed?"),
+ QMessageBox.StandardButton.Yes,
+ QMessageBox.StandardButton.No)==StandardButton.No.value()) {
+ return;
+ }
+ DBEncryptDialog dialog = new DBEncryptDialog();
+ dialog.exec();
+ if (dialog.okPressed()) {
+ Global.cipherPassword = dialog.getPassword();
+ encryptOnShutdown = true;
+ encryptCipher = dialog.getEncryptionMethod();
+ }
+ } else {
+ DBEncryptDialog dialog = new DBEncryptDialog();
+ dialog.setWindowTitle("Database Decryption");
+ dialog.hideEncryption();
+ dialog.exec();
+ if (dialog.okPressed()) {
+ if (!dialog.getPassword().equals(Global.cipherPassword)) {
+ QMessageBox.critical(null, tr("Incorrect Password"), tr("Incorrect Password"));
+ return;
+ }
+ decryptOnShutdown = true;
+ encryptCipher = "";
+ }
+ }
+ return;
+ }
- for (String arg : args) {
- String lower = arg.toLowerCase();
- if (lower.startsWith("--name="))
- startupConfig.setName(arg.substring(arg.indexOf('=') + 1));
- if (lower.startsWith("--home="))
- startupConfig.setHomeDirPath(arg.substring(arg.indexOf('=') + 1));
- if (lower.startsWith("--disable-viewing"))
- startupConfig.setDisableViewing(true);
- }
+ private static void initializeGlobalSettings(String[] args) throws InitializationException {
+ StartupConfig startupConfig = new StartupConfig();
- Global.setup(startupConfig);
+ for (String arg : args) {
+ String lower = arg.toLowerCase();
+ if (lower.startsWith("--name="))
+ startupConfig.setName(arg.substring(arg.indexOf('=') + 1));
+ if (lower.startsWith("--home="))
+ startupConfig.setHomeDirPath(arg.substring(arg.indexOf('=') + 1));
+ if (lower.startsWith("--disable-viewing"))
+ startupConfig.setDisableViewing(true);
}
+ Global.setup(startupConfig);
+ }
// Exit point
@Override
conn.getNoteTable().updateNoteTitle(currentNote.getGuid(), browserWindow.getTitle());
}
saveNote();
- setMessage("Beginning shutdown.");
-
+ setMessage(tr("Beginning shutdown."));
+
+ // Close down external windows
+ Collection<ExternalBrowse> windows = externalWindows.values();
+ Iterator<ExternalBrowse> iterator = windows.iterator();
+ while (iterator.hasNext()) {
+ ExternalBrowse browser = iterator.next();
+ browser.windowClosing.disconnect();
+ browser.close();
+ }
+
+
externalFileEditedSaver();
if (Global.isConnected && Global.synchronizeOnClose()) {
- setMessage("Performing synchronization before closing.");
+ setMessage(tr("Performing synchronization before closing."));
syncRunner.addWork("SYNC");
}
setMessage("Closing Program.");
threadMonitorTimer.stop();
syncRunner.addWork("STOP");
+ syncRunner.keepRunning = false;
+ thumbnailRunner.addWork("STOP");
+ syncRunner.keepRunning = false;
indexRunner.addWork("STOP");
+ syncRunner.keepRunning = false;
saveNote();
listManager.stop();
saveWindowState();
syncRunner.notebookSignal.listChanged.disconnect();
syncRunner.noteIndexSignal.listChanged.disconnect();
-
- int position = noteTableView.header.visualIndex(Global.noteTableCreationPosition);
- Global.setColumnPosition("noteTableCreationPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableTagPosition);
- Global.setColumnPosition("noteTableTagPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableNotebookPosition);
- Global.setColumnPosition("noteTableNotebookPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableChangedPosition);
- Global.setColumnPosition("noteTableChangedPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableAuthorPosition);
- Global.setColumnPosition("noteTableAuthorPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableSourceUrlPosition);
- Global.setColumnPosition("noteTableSourceUrlPosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableSubjectDatePosition);
- Global.setColumnPosition("noteTableSubjectDatePosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableTitlePosition);
- Global.setColumnPosition("noteTableTitlePosition", position);
- position = noteTableView.header.visualIndex(Global.noteTableSynchronizedPosition);
- Global.setColumnPosition("noteTableSynchronizedPosition", position);
-
+ if (isVisible())
+ Global.saveWindowVisible("toolBar", toolBar.isVisible());
+ saveNoteColumnPositions();
saveNoteIndexWidth();
int width = notebookTree.columnWidth(0);
}
}
- logger.log(logger.EXTREME, "Shutting down database");
- conn.dbShutdown();
- logger.log(logger.EXTREME, "Waiting for DB thread to terminate");
- try {
- dbThread.join();
- } catch (InterruptedException e) {
- e.printStackTrace();
+ if (encryptOnShutdown) {
+ encryptOnShutdown();
+ }
+ if (decryptOnShutdown) {
+ decryptOnShutdown();
}
- logger.log(logger.EXTREME, "DB Thread has terminated");
- unlockApplication();
logger.log(logger.HIGH, "Leaving NeverNote.closeEvent");
}
}
private void waitCursor(boolean wait) {
- if (wait)
- QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.WaitCursor));
- else
- QApplication.restoreOverrideCursor();
+// if (wait)
+// QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.WaitCursor));
+// else
+// QApplication.restoreOverrideCursor();
}
private void setupIndexListeners() {
syncRunner.noteIndexSignal.listChanged.connect(this, "noteIndexUpdated(boolean)");
syncRunner.noteSignal.quotaChanged.connect(this, "updateQuotaBar()");
-// syncRunner.syncSignal.setSequenceDate.connect(this,"setSequenceDate(long)");
syncRunner.syncSignal.saveUploadAmount.connect(this,"saveUploadAmount(long)");
-// syncRunner.syncSignal.setUpdateSequenceNumber.connect(this,"setUpdateSequenceNumber(int)");
syncRunner.syncSignal.saveUserInformation.connect(this,"saveUserInformation(User)");
syncRunner.syncSignal.saveEvernoteUpdateCount.connect(this,"saveEvernoteUpdateCount(int)");
syncRunner.noteSignal.guidChanged.connect(this, "noteGuidChanged(String, String)");
syncRunner.noteSignal.noteChanged.connect(this, "invalidateNoteCache(String, String)");
syncRunner.resourceSignal.resourceGuidChanged.connect(this, "noteResourceGuidChanged(String,String,String)");
+ syncRunner.noteSignal.noteDownloaded.connect(listManager, "noteDownloaded(Note)");
syncRunner.syncSignal.refreshLists.connect(this, "refreshLists()");
}
private void setupBrowserSignalListeners() {
-
- browserWindow.fileWatcher.fileChanged.connect(this, "externalFileEdited(String)");
- browserWindow.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
- browserWindow.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
- browserWindow.noteSignal.noteChanged.connect(this, "invalidateNoteCache(String, String)");
- browserWindow.noteSignal.noteChanged.connect(this, "setNoteDirty()");
- browserWindow.noteSignal.titleChanged.connect(listManager, "updateNoteTitle(String, String)");
- browserWindow.noteSignal.titleChanged.connect(this, "updateListTitle(String, String)");
- browserWindow.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
- browserWindow.noteSignal.createdDateChanged.connect(listManager, "updateNoteCreatedDate(String, QDateTime)");
- browserWindow.noteSignal.createdDateChanged.connect(this, "updateListDateCreated(String, QDateTime)");
- browserWindow.noteSignal.alteredDateChanged.connect(listManager, "updateNoteAlteredDate(String, QDateTime)");
- browserWindow.noteSignal.alteredDateChanged.connect(this, "updateListDateChanged(String, QDateTime)");
- browserWindow.noteSignal.subjectDateChanged.connect(listManager, "updateNoteSubjectDate(String, QDateTime)");
- browserWindow.noteSignal.subjectDateChanged.connect(this, "updateListDateSubject(String, QDateTime)");
- browserWindow.noteSignal.authorChanged.connect(listManager, "updateNoteAuthor(String, String)");
- browserWindow.noteSignal.authorChanged.connect(this, "updateListAuthor(String, String)");
- browserWindow.noteSignal.sourceUrlChanged.connect(listManager, "updateNoteSourceUrl(String, String)");
- browserWindow.noteSignal.sourceUrlChanged.connect(this, "updateListSourceUrl(String, String)");
- browserWindow.focusLost.connect(this, "saveNote()");
- browserWindow.resourceSignal.contentChanged.connect(this, "externalFileEdited(String)");
-// browserWindow.resourceSignal.externalFileEdit.connect(this, "saveResourceLater(String, String)");
+ setupBrowserWindowListeners(browserWindow, true);
}
- private boolean lockApplication() {
-
- // NFC TODO: who creates this - H2? should it be parameterized with databaseName like in RDatabaseConnection?
- String fileName = Global.getFileManager().getDbDirPath("NeverNote.lock.db");
-// QFile.remove(fileName);
- if (QFile.exists(fileName)) {
- QMessageBox.question(this, "Lock File Detected",
- "While starting I've found a database lock file.\n" +
- "to prevent multiple instances from accessing the database \n"+
- "at the same time. Please stop any other program, or (if you\n" +
- "are sure nothing else is using the database) remove the file\n" +
- fileName +".");
- return false;
-
- }
- return true;
-/* String fileName = Global.currentDir +"nevernote.lock";
-
- if (QFile.exists(fileName)) {
- if (QMessageBox.question(this, "Confirmation",
- "While starting I've found a lock file. This file is used to prevent multiple "+
- "instances of this program running at once. If NeverNote has crashed this " +
- "is just a file that wasn't cleaned up and you can safely, "+
- "continue, but if there is another instance of this running you are " +
- "running the risk of creating problems.\n\n" +
- "Are you sure you want to continue?",
- QMessageBox.StandardButton.Yes,
- QMessageBox.StandardButton.No)==StandardButton.No.value()) {
- return false;
- }
- }
-
- QFile file = new QFile(fileName);
- file.open(OpenModeFlag.WriteOnly);
- file.write(new QByteArray("This file is used to prevent multiple instances " +
- "of NeverNote running more than once. " +
- "It should be deleted when NeverNote ends"));
- file.close();
- return true;
-*/
+ private void setupBrowserWindowListeners(BrowserWindow browser, boolean master) {
+ browser.fileWatcher.fileChanged.connect(this, "externalFileEdited(String)");
+ browser.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
+ browser.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
+ if (master) browser.noteSignal.noteChanged.connect(this, "setNoteDirty()");
+ browser.noteSignal.titleChanged.connect(listManager, "updateNoteTitle(String, String)");
+ browser.noteSignal.titleChanged.connect(this, "updateNoteTitle(String, String)");
+ browser.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
+ browser.noteSignal.createdDateChanged.connect(listManager, "updateNoteCreatedDate(String, QDateTime)");
+ browser.noteSignal.alteredDateChanged.connect(listManager, "updateNoteAlteredDate(String, QDateTime)");
+ browser.noteSignal.subjectDateChanged.connect(listManager, "updateNoteSubjectDate(String, QDateTime)");
+ browser.noteSignal.authorChanged.connect(listManager, "updateNoteAuthor(String, String)");
+ browser.noteSignal.geoChanged.connect(listManager, "updateNoteGeoTag(String, Double,Double,Double)");
+ browser.noteSignal.geoChanged.connect(this, "setNoteDirty()");
+ browser.noteSignal.sourceUrlChanged.connect(listManager, "updateNoteSourceUrl(String, String)");
+ if (master) browser.focusLost.connect(this, "saveNote()");
+ browser.resourceSignal.contentChanged.connect(this, "externalFileEdited(String)");
}
- private void unlockApplication() {
- // NFC TODO: should this be removed? Looks like H2 now handles the locking, which it will clean up itself. See #lockApplication.
- String fileName = Global.getFileManager().getHomeDirPath("nevernote.lock");
- if (QFile.exists(fileName)) {
- QFile.remove(fileName);
- }
- }
-
//***************************************************************
//***************************************************************
@SuppressWarnings("unused")
private void settings() {
logger.log(logger.HIGH, "Entering NeverNote.settings");
+ saveNoteColumnPositions();
+ saveNoteIndexWidth();
+ showColumns();
ConfigDialog settings = new ConfigDialog(this);
String dateFormat = Global.getDateFormat();
String timeFormat = Global.getTimeFormat();
+ indexTime = 1000*Global.getIndexThreadSleepInterval();
+ indexTimer.start(indexTime); // reset indexing timer
+
settings.exec();
if (Global.showTrayIcon())
trayIcon.show();
trayIcon.hide();
showColumns();
if (menuBar.showEditorBar.isChecked())
- showEditorButtons();
+ showEditorButtons(browserWindow);
// Reset the save timer
if (Global.getAutoSaveInterval() > 0)
logger.log(logger.HIGH, "Leaving NeverNote.settings");
}
// Restore things to the way they were
- private void restoreWindowState() {
+ private void restoreWindowState(boolean mainWindow) {
// We need to name things or this doesn't work.
setObjectName("NeverNote");
mainLeftRightSplitter.setObjectName("mainLeftRightSplitter");
leftSplitter1.setObjectName("leftSplitter1");
// Restore the actual positions.
- restoreGeometry(Global.restoreGeometry(objectName()));
+ if (mainWindow)
+ restoreGeometry(Global.restoreGeometry(objectName()));
mainLeftRightSplitter.restoreState(Global.restoreState(mainLeftRightSplitter.objectName()));
browserIndexSplitter.restoreState(Global.restoreState(browserIndexSplitter.objectName()));
leftSplitter1.restoreState(Global.restoreState(leftSplitter1.objectName()));
}
// Load the style sheet
private void loadStyleSheet() {
- String fileName = Global.currentDir +"qss"+System.getProperty("file.separator")+ "default.qss";
+ String fileName = Global.getFileManager().getQssDirPath("default.qss");
QFile file = new QFile(fileName);
file.open(OpenModeFlag.ReadOnly);
String styleSheet = file.readAll().toString();
file.close();
setStyleSheet(styleSheet);
}
+ // Save column positions for the next time
+ private void saveNoteColumnPositions() {
+ int position = noteTableView.header.visualIndex(Global.noteTableCreationPosition);
+ Global.setColumnPosition("noteTableCreationPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableTagPosition);
+ Global.setColumnPosition("noteTableTagPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableNotebookPosition);
+ Global.setColumnPosition("noteTableNotebookPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableChangedPosition);
+ Global.setColumnPosition("noteTableChangedPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableAuthorPosition);
+ Global.setColumnPosition("noteTableAuthorPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableSourceUrlPosition);
+ Global.setColumnPosition("noteTableSourceUrlPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableSubjectDatePosition);
+ Global.setColumnPosition("noteTableSubjectDatePosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableTitlePosition);
+ Global.setColumnPosition("noteTableTitlePosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableSynchronizedPosition);
+ Global.setColumnPosition("noteTableSynchronizedPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableGuidPosition);
+ Global.setColumnPosition("noteTableGuidPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTableThumbnailPosition);
+ Global.setColumnPosition("noteTableThumbnailPosition", position);
+
+ }
// Save column widths for the next time
private void saveNoteIndexWidth() {
int width;
Global.setColumnWidth("noteTableSubjectDatePosition", width);
width = noteTableView.getColumnWidth(Global.noteTableSynchronizedPosition);
Global.setColumnWidth("noteTableSynchronizedPosition", width);
+ width = noteTableView.getColumnWidth(Global.noteTableThumbnailPosition);
+ Global.setColumnWidth("noteTableThumbnailPosition", width);
+ width = noteTableView.getColumnWidth(Global.noteTableGuidPosition);
+ Global.setColumnWidth("noteTableGuidPosition", width);
}
// Setup the tree containing the user's notebooks.
private void initializeNotebookTree() {
logger.log(logger.HIGH, "Entering NeverNote.initializeNotebookTree");
- notebookTree.itemSelectionChanged.connect(this, "notebookTreeSelection()");
+ // notebookTree.itemSelectionChanged.connect(this, "notebookTreeSelection()");
+ notebookTree.itemClicked.connect(this, "notebookTreeSelection()");
listManager.notebookSignal.refreshNotebookTreeCounts.connect(notebookTree, "updateCounts(List, List)");
// notebookTree.resize(Global.getSize("notebookTree"));
logger.log(logger.HIGH, "Leaving NeverNote.initializeNotebookTree");
}
// Listener when a notebook is selected
- @SuppressWarnings("unused")
private void notebookTreeSelection() {
logger.log(logger.HIGH, "Entering NeverNote.notebookTreeSelection");
clearTagFilter();
searchField.clear();
}
-
menuBar.noteRestoreAction.setVisible(false);
menuBar.notebookEditAction.setEnabled(true);
menuBar.notebookDeleteAction.setEnabled(true);
+ menuBar.notebookIconAction.setEnabled(true);
List<QTreeWidgetItem> selections = notebookTree.selectedItems();
QTreeWidgetItem currentSelection;
selectedNotebookGUIDs.clear();
selectedNotebookGUIDs.clear();
menuBar.notebookEditAction.setEnabled(false);
menuBar.notebookDeleteAction.setEnabled(false);
+ menuBar.notebookIconAction.setEnabled(false);
}
+ if (selectedNotebookGUIDs.size() == 1 && selectedNotebookGUIDs.get(0).equals(previousSelectedNotebook)) {
+ previousSelectedNotebook = selectedNotebookGUIDs.get(0);
+ previousSelectedNotebook = "";
+ notebookTree.clearSelection();
+ notebookTreeSelection();
+ return;
+ }
+ if (selectedNotebookGUIDs.size() == 1)
+ previousSelectedNotebook = selectedNotebookGUIDs.get(0);
+ if (selectedNotebookGUIDs.size() > 1)
+ previousSelectedNotebook = "";
} else {
String guid = "";
if (selections.size() > 0)
guid = (selections.get(0).text(2));
- if (!guid.equals(""))
+ if (!guid.equals("")) {
selectedNotebookGUIDs.add(guid);
+ menuBar.notebookIconAction.setEnabled(true);
+ }
+ else {
+ menuBar.notebookIconAction.setEnabled(false);
+ }
}
listManager.setSelectedNotebooks(selectedNotebookGUIDs);
listManager.loadNotesIndex();
// Triggered when the notebook DB has been updated
private void notebookIndexUpdated() {
logger.log(logger.HIGH, "Entering NeverNote.notebookIndexUpdated");
- if (selectedNotebookGUIDs == null)
+
+ // Get the possible icons
+ HashMap<String, QIcon> icons = conn.getNotebookTable().getAllIcons();
+ notebookTree.setIcons(icons);
+
+ if (selectedNotebookGUIDs == null)
selectedNotebookGUIDs = new ArrayList<String>();
List<Notebook> books = conn.getNotebookTable().getAll();
for (int i=books.size()-1; i>=0; i--) {
private void editNotebook() {
logger.log(logger.HIGH, "Entering NeverNote.editNotebook");
NotebookEdit edit = new NotebookEdit();
- edit.setTitle("Edit Notebook");
+ edit.setTitle(tr("Edit Notebook"));
edit.setLocalCheckboxEnabled(false);
List<QTreeWidgetItem> selections = notebookTree.selectedItems();
QTreeWidgetItem currentSelection;
currentSelection = selections.get(0);
edit.setNotebook(currentSelection.text(0));
edit.setNotebooks(listManager.getNotebookIndex());
+
+ String guid = currentSelection.text(2);
+ for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
+ if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
+ edit.setDefaultNotebook(listManager.getNotebookIndex().get(i).isDefaultNotebook());
+ i=listManager.getNotebookIndex().size();
+ }
+ }
edit.exec();
if (!edit.okPressed())
return;
- String guid = currentSelection.text(2);
updateListNotebookName(currentSelection.text(0), edit.getNotebook());
currentSelection.setText(0, edit.getNotebook());
for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
listManager.getNotebookIndex().get(i).setName(edit.getNotebook());
+ if (!listManager.getNotebookIndex().get(i).isDefaultNotebook() && edit.isDefaultNotebook()) {
+ for (int j=0; j<listManager.getNotebookIndex().size(); j++)
+ listManager.getNotebookIndex().get(j).setDefaultNotebook(false);
+ listManager.getNotebookIndex().get(i).setDefaultNotebook(true);
+ conn.getNotebookTable().setDefaultNotebook(listManager.getNotebookIndex().get(i).getGuid());
+ }
conn.getNotebookTable().updateNotebook(listManager.getNotebookIndex().get(i), true);
i=listManager.getNotebookIndex().size();
}
}
}
if (assigned) {
- QMessageBox.information(this, "Unable to Delete", "Some of the selected notebook(s) contain notes.\n"+
- "Please delete the notes or move them to another notebook before deleting any notebooks.");
+ QMessageBox.information(this, tr("Unable to Delete"), tr("Some of the selected notebook(s) contain notes.\n"+
+ "Please delete the notes or move them to another notebook before deleting any notebooks."));
return;
}
if (conn.getNotebookTable().getAll().size() == 1) {
- QMessageBox.information(this, "Unable to Delete", "You must have at least one notebook.");
+ QMessageBox.information(this, tr("Unable to Delete"), tr("You must have at least one notebook."));
return;
}
// If all notebooks are clear, verify the delete
- if (QMessageBox.question(this, "Confirmation", "Delete the selected notebooks?",
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected notebooks?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
// for (int i=<dbRunner.getLocalNotebooks().size()-1; i>=0; i--) {
// if (dbRunner.getLocalNotebooks().get(i).equals(arg0))
// }
+ notebookTreeSelection();
notebookTree.load(listManager.getNotebookIndex(), listManager.getLocalNotebooks());
listManager.countNotebookResults(listManager.getNoteIndex());
// notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
if (listManager.getNotebookIndex().get(i).getGuid().equals(notebookGuid)) {
notebookName = listManager.getNotebookIndex().get(i).getName();
- i=listManager.getNotebookIndex().size();
+ break;
}
}
}
}
}
-
+ notebookTreeSelection();
listManager.loadNotesIndex();
notebookIndexUpdated();
- noteIndexUpdated(true);
+ noteIndexUpdated(false);
// noteIndexUpdated(false);
// Build a list of non-closed notebooks
waitCursor(false);
browserWindow.setNotebookList(nbooks);
}
+ // Change the notebook's icon
+ private void setNotebookIcon() {
+ QTreeWidgetItem currentSelection;
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ if (selections.size() == 0)
+ return;
+
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+ if (guid.equalsIgnoreCase(""))
+ return;
+ QIcon currentIcon = currentSelection.icon(0);
+ QIcon icon = conn.getNotebookTable().getIcon(guid);
+ SetIcon dialog;
+ if (icon == null) {
+ dialog = new SetIcon(currentIcon);
+ dialog.setUseDefaultIcon(true);
+ } else {
+ dialog = new SetIcon(icon);
+ dialog.setUseDefaultIcon(false);
+ }
+ dialog.exec();
+ if (dialog.okPressed()) {
+ QIcon newIcon = dialog.getIcon();
+ conn.getNotebookTable().setIcon(guid, newIcon, dialog.getFileType());
+ if (newIcon == null) {
+ boolean isPublished = false;;
+ boolean found = false;
+ for (int i=0; i<listManager.getNotebookIndex().size() && !found; i++) {
+ if (listManager.getNotebookIndex().get(i).getGuid().equals(guid)) {
+ isPublished = listManager.getNotebookIndex().get(i).isPublished();
+ found = true;
+ }
+ }
+ newIcon = notebookTree.findDefaultIcon(guid, currentSelection.text(1), listManager.getLocalNotebooks(), isPublished);
+ }
+ currentSelection.setIcon(0, newIcon);
+ }
-
+ }
//***************************************************************
newTag.setName(edit.getTag());
conn.getTagTable().addTag(newTag, true);
listManager.getTagIndex().add(newTag);
- reloadTagTree();
+ reloadTagTree(true);
logger.log(logger.HIGH, "Leaving NeverNote.addTag");
}
private void reloadTagTree() {
+ reloadTagTree(false);
+ }
+ private void reloadTagTree(boolean reload) {
logger.log(logger.HIGH, "Entering NeverNote.reloadTagTree");
- tagIndexUpdated(false);
+ tagIndexUpdated(reload);
boolean filter = false;
listManager.countTagResults(listManager.getNoteIndex());
if (notebookTree.selectedItems().size() > 0
private void deleteTag() {
logger.log(logger.HIGH, "Entering NeverNote.deleteTag");
- if (QMessageBox.question(this, "Confirmation", "Delete the selected tags?",
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected tags?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
removeTagItem(currentSelection.text(2));
}
tagIndexUpdated(true);
+ tagTreeSelection();
listManager.countTagResults(listManager.getNoteIndex());
// tagTree.updateCounts(listManager.getTagCounter());
logger.log(logger.HIGH, "Leaving NeverNote.deleteTag");
// Setup the tree containing the user's tags
private void initializeTagTree() {
logger.log(logger.HIGH, "Entering NeverNote.initializeTagTree");
- tagTree.itemSelectionChanged.connect(this, "tagTreeSelection()");
+// tagTree.itemSelectionChanged.connect(this, "tagTreeSelection()");
+ tagTree.itemClicked.connect(this, "tagTreeSelection()");
listManager.tagSignal.refreshTagTreeCounts.connect(tagTree, "updateCounts(List)");
logger.log(logger.HIGH, "Leaving NeverNote.initializeTagTree");
}
// Listener when a tag is selected
- @SuppressWarnings("unused")
private void tagTreeSelection() {
logger.log(logger.HIGH, "Entering NeverNote.tagTreeSelection");
-
- List<QTreeWidgetItem> x = tagTree.selectedItems();
- for (int i=0; i<x.size(); i++) {
- }
-
+
clearTrashFilter();
clearAttributeFilter();
clearSavedSearchFilter();
menuBar.tagEditAction.setEnabled(false);
menuBar.tagDeleteAction.setEnabled(false);
}
+ if (selectedTagGUIDs.size() == 1 && selectedTagGUIDs.get(0).equals(previousSelectedTag)) {
+ previousSelectedTag = selectedTagGUIDs.get(0);
+ previousSelectedTag = "";
+ tagTree.clearSelection();
+ tagTreeSelection();
+ return;
+ }
+ if (selectedTagGUIDs.size() == 1)
+ previousSelectedTag = selectedTagGUIDs.get(0);
+ if (selectedTagGUIDs.size() > 1)
+ previousSelectedTag = "";
listManager.setSelectedTags(selectedTagGUIDs);
listManager.loadNotesIndex();
noteIndexUpdated(false);
// A note's tags have been updated
@SuppressWarnings("unused")
private void updateNoteTags(String guid, List<String> tags) {
+ // Save any new tags. We'll need them later.
+ List<String> newTags = new ArrayList<String>();
+ for (int i=0; i<tags.size(); i++) {
+ if (conn.getTagTable().findTagByName(tags.get(i))==null)
+ newTags.add(tags.get(i));
+ }
+
listManager.saveNoteTags(guid, tags);
listManager.countTagResults(listManager.getNoteIndex());
StringBuffer names = new StringBuffer("");
}
browserWindow.setTag(names.toString());
noteDirty = true;
-// tagTree.updateCounts(listManager.getTagCounter());
+
+ // Now, we need to add any new tags to the tag tree
+ for (int i=0; i<newTags.size(); i++)
+ tagTree.insertTag(newTags.get(i), conn.getTagTable().findTagByName(newTags.get(i)));
}
// Get a string containing all tag names for a note
private String getTagNamesForNote(Note n) {
if (tagName == null)
return;
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
- String titleGuid = (String)ix.values().toArray()[0];
- if (titleGuid.equals(noteGuid)) {
- String text = (String)noteTableView.model.data(i, Global.noteTableTagPosition);
- if (!text.trim().equals(""))
- text = text + Global.tagDelimeter + " " +tagName;
- else
- text = tagName;
- noteTableView.model.setData(i, Global.noteTableTagPosition, text);
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- if (noteGuid.equals(currentNoteGuid))
- browserWindow.setTag(text);
- i=noteTableView.model.rowCount();
+ for (int i=0; i<listManager.getMasterNoteIndex().size(); i++) {
+ if (listManager.getMasterNoteIndex().get(i).getGuid().equals(noteGuid)) {
+ List<String> tagNames = new ArrayList<String>();
+ tagNames.add(new String(tagName));
+ Note n = listManager.getMasterNoteIndex().get(i);
+ for (int j=0; j<n.getTagNames().size(); j++) {
+ tagNames.add(new String(n.getTagNames().get(j)));
}
+ listManager.getNoteTableModel().updateNoteTags(noteGuid, n.getTagGuids(), tagNames);
+ if (n.getGuid().equals(currentNoteGuid)) {
+ Collections.sort(tagNames);
+ String display = "";
+ for (int j=0; j<tagNames.size(); j++) {
+ display = display+tagNames.get(j);
+ if (j+2<tagNames.size())
+ display = display+Global.tagDelimeter+" ";
+ }
+ browserWindow.setTag(display);
+ }
+ i=listManager.getMasterNoteIndex().size();
}
}
+
+
+ listManager.getNoteTableModel().updateNoteSyncStatus(noteGuid, false);
}
private void clearTagFilter() {
tagTree.blockSignals(true);
private void editSavedSearch() {
logger.log(logger.HIGH, "Entering NeverNote.editSavedSearch");
SavedSearchEdit edit = new SavedSearchEdit();
- edit.setTitle("Edit Search");
+ edit.setTitle(tr("Edit Search"));
List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
QTreeWidgetItem currentSelection;
currentSelection = selections.get(0);
@SuppressWarnings("unused")
private void compactDatabase() {
logger.log(logger.HIGH, "Entering NeverNote.compactDatabase");
- if (QMessageBox.question(this, "Confirmation", "This will free unused space in the database, "+
+ if (QMessageBox.question(this, tr("Confirmation"), tr("This will free unused space in the database, "+
"but please be aware that depending upon the size of your database this can be time consuming " +
- "and NeverNote will be unresponsive until it is complete. Do you wish to continue?",
+ "and NeverNote will be unresponsive until it is complete. Do you wish to continue?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
return;
return;
textBox.setText(file.readAll().toString());
file.close();
- dialog.setWindowTitle("Release Notes");
+ dialog.setWindowTitle(tr("Release Notes"));
dialog.setLayout(layout);
dialog.show();
logger.log(logger.HIGH, "Leaving NeverNote.releaseNotes");
textBox.addItems(emitLog);
dialog.setLayout(layout);
- dialog.setWindowTitle("Mesasge Log");
+ dialog.setWindowTitle(tr("Mesasge Log"));
dialog.show();
logger.log(logger.HIGH, "Leaving NeverNote.logger");
}
logger.log(logger.HIGH, "Entering NeverNote.about");
QMessageBox.about(this,
tr("About NeverNote"),
- tr("<h4><center><b>NeverNote</b></center></h4><hr><center>Version "+Global.version+"<hr></center>Evernote"
- +" Generic client.<br><br>"
+ tr("<h4><center><b>NeverNote</b></center></h4><hr><center>Version ")
+ +Global.version
+ +tr("<hr></center>Evernote"
+ +"An Open Source Evernote Client.<br><br>"
+"Licensed under GPL v2. <br><hr><br>"
+"Evernote is copyright 2001-2010 by Evernote Corporation<br>"
+"Jambi and QT are the licensed trademark of Nokia Corporation<br>"
+"PDFRenderer is licened under the LGPL<br>"
+ +"JTidy is copyrighted under the World Wide Web Consortium<br>"
+ +"Apache Common Utilities licensed under the Apache License Version 2.0<br>"
+"Jazzy is licened under the LGPL<br>"
- +"Java is a registered trademark of Sun Microsystems.<br><hr>"));
+ +"Java is a registered trademark of Oracle Corporation.<br><hr>"));
logger.log(logger.HIGH, "Leaving NeverNote.about");
}
// Hide the entire left hand side
// Text in the search bar has been cleared
private void searchFieldCleared() {
searchField.setEditText("");
+ saveNoteColumnPositions();
saveNoteIndexWidth();
}
// text in the search bar changed. We only use this to tell if it was cleared,
private void searchFieldChanged() {
logger.log(logger.HIGH, "Entering NeverNote.searchFieldChanged");
noteCache.clear();
+ saveNoteColumnPositions();
saveNoteIndexWidth();
String text = searchField.currentText();
listManager.setEnSearch(text.trim());
searchPerformed = true;
logger.log(logger.HIGH, "Leaving NeverNote.searchFieldChanged");
}
+
// Build the window tool bar
private void setupToolBar() {
logger.log(logger.HIGH, "Entering NeverNote.setupToolBar");
- toolBar = addToolBar(tr("toolBar"));
+ toolBar = addToolBar(tr("Tool Bar"));
+ menuBar.setupToolBarVisible();
+ if (!Global.isWindowVisible("toolBar"))
+ toolBar.setVisible(false);
+ else
+ toolBar.setVisible(true);
prevButton = toolBar.addAction("Previous");
QIcon prevIcon = new QIcon(iconPath+"back.png");
prevButton.setIcon(prevIcon);
prevButton.triggered.connect(this, "previousViewedAction()");
+ togglePrevArrowButton(Global.isToolbarButtonVisible("prevArrow"));
nextButton = toolBar.addAction("Next");
QIcon nextIcon = new QIcon(iconPath+"forward.png");
nextButton.setIcon(nextIcon);
nextButton.triggered.connect(this, "nextViewedAction()");
+ toggleNextArrowButton(Global.isToolbarButtonVisible("nextArrow"));
upButton = toolBar.addAction("Up");
QIcon upIcon = new QIcon(iconPath+"up.png");
upButton.setIcon(upIcon);
upButton.triggered.connect(this, "upAction()");
+ toggleUpArrowButton(Global.isToolbarButtonVisible("upArrow"));
+
downButton = toolBar.addAction("Down");
QIcon downIcon = new QIcon(iconPath+"down.png");
downButton.setIcon(downIcon);
downButton.triggered.connect(this, "downAction()");
+ toggleDownArrowButton(Global.isToolbarButtonVisible("downArrow"));
synchronizeButton = toolBar.addAction("Synchronize");
- synchronizeAnimation = new ArrayList<QIcon>();
- synchronizeAnimation.add(new QIcon(iconPath+"synchronize-0.png"));
- synchronizeAnimation.add(new QIcon(iconPath+"synchronize-1.png"));
- synchronizeAnimation.add(new QIcon(iconPath+"synchronize-2.png"));
- synchronizeAnimation.add(new QIcon(iconPath+"synchronize-3.png"));
- synchronizeButton.setIcon(synchronizeAnimation.get(0));
- synchronizeFrame = 0;
+ synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
+ synchronizeIconAngle = 0;
synchronizeButton.triggered.connect(this, "evernoteSync()");
+ toggleSynchronizeButton(Global.isToolbarButtonVisible("synchronize"));
printButton = toolBar.addAction("Print");
QIcon printIcon = new QIcon(iconPath+"print.png");
printButton.setIcon(printIcon);
printButton.triggered.connect(this, "printNote()");
-
+ togglePrintButton(Global.isToolbarButtonVisible("print"));
+
tagButton = toolBar.addAction("Tag");
QIcon tagIcon = new QIcon(iconPath+"tag.png");
tagButton.setIcon(tagIcon);
tagButton.triggered.connect(browserWindow, "modifyTags()");
-
+ toggleTagButton(Global.isToolbarButtonVisible("tag"));
+
attributeButton = toolBar.addAction("Attributes");
QIcon attributeIcon = new QIcon(iconPath+"attribute.png");
attributeButton.setIcon(attributeIcon);
attributeButton.triggered.connect(this, "toggleNoteInformation()");
+ toggleAttributeButton(Global.isToolbarButtonVisible("attribute"));
emailButton = toolBar.addAction("Email");
QIcon emailIcon = new QIcon(iconPath+"email.png");
emailButton.setIcon(emailIcon);
emailButton.triggered.connect(this, "emailNote()");
-
+ toggleEmailButton(Global.isToolbarButtonVisible("email"));
+
deleteButton = toolBar.addAction("Delete");
QIcon deleteIcon = new QIcon(iconPath+"delete.png");
deleteButton.setIcon(deleteIcon);
deleteButton.triggered.connect(this, "deleteNote()");
-
+ toggleDeleteButton(Global.isToolbarButtonVisible("delete"));
+
newButton = toolBar.addAction("New");
QIcon newIcon = new QIcon(iconPath+"new.png");
newButton.triggered.connect(this, "addNote()");
newButton.setIcon(newIcon);
+ toggleNewButton(Global.isToolbarButtonVisible("new"));
+
+ allNotesButton = toolBar.addAction("All Notes");
+ QIcon allIcon = new QIcon(iconPath+"books.png");
+ allNotesButton.triggered.connect(this, "allNotes()");
+ allNotesButton.setIcon(allIcon);
+ toggleAllNotesButton(Global.isToolbarButtonVisible("allNotes"));
+
toolBar.addSeparator();
- toolBar.addWidget(new QLabel("Quota:"));
+ toolBar.addWidget(new QLabel(tr("Quota:")));
toolBar.addWidget(quotaBar);
//quotaBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
updateQuotaBar();
+ toolBar.addSeparator();
// Setup the zoom
zoomSpinner = new QSpinBox();
zoomSpinner.setSingleStep(10);
zoomSpinner.setValue(100);
zoomSpinner.valueChanged.connect(this, "zoomChanged()");
- toolBar.addWidget(new QLabel("Zoom"));
+ toolBar.addWidget(new QLabel(tr("Zoom")));
toolBar.addWidget(zoomSpinner);
//toolBar.addWidget(new QLabel(" "));
toolBar.addSeparator();
- toolBar.addWidget(new QLabel(" Search:"));
+ toolBar.addWidget(new QLabel(tr(" Search:")));
toolBar.addWidget(searchField);
QSizePolicy sizePolicy = new QSizePolicy();
sizePolicy.setHorizontalPolicy(Policy.MinimumExpanding);
QIcon searchClearIcon = new QIcon(iconPath+"searchclear.png");
searchClearButton.setIcon(searchClearIcon);
searchClearButton.triggered.connect(this, "searchFieldCleared()");
-
+ toggleSearchClearButton(Global.isToolbarButtonVisible("searchClear"));
+
logger.log(logger.HIGH, "Leaving NeverNote.setupToolBar");
}
// Update the sychronize button picture
+ @Override
+ public QMenu createPopupMenu() {
+ QMenu contextMenu = super.createPopupMenu();
+
+ contextMenu.addSeparator();
+ QAction prevAction = addContextAction("prevArrow", tr("Previous Arrow"));
+ contextMenu.addAction(prevAction);
+ prevAction.triggered.connect(this, "togglePrevArrowButton(Boolean)");
+
+ QAction nextAction = addContextAction("nextArrow", tr("Next Arrow"));
+ contextMenu.addAction(nextAction);
+ nextAction.triggered.connect(this, "toggleNextArrowButton(Boolean)");
+
+ QAction upAction = addContextAction("upArrow", tr("Up Arrow"));
+ contextMenu.addAction(upAction);
+ upAction.triggered.connect(this, "toggleUpArrowButton(Boolean)");
+
+ QAction downAction = addContextAction("downArrow", tr("Down Arrow"));
+ contextMenu.addAction(downAction);
+ downAction.triggered.connect(this, "toggleDownArrowButton(Boolean)");
+
+ QAction synchronizeAction = addContextAction("synchronize", tr("Synchronize"));
+ contextMenu.addAction(synchronizeAction);
+ synchronizeAction.triggered.connect(this, "toggleSynchronizeButton(Boolean)");
+
+ QAction printAction = addContextAction("print", tr("Print"));
+ contextMenu.addAction(printAction);
+ printAction.triggered.connect(this, "togglePrintButton(Boolean)");
+
+ QAction tagAction = addContextAction("tag", tr("Tag"));
+ contextMenu.addAction(tagAction);
+ tagAction.triggered.connect(this, "toggleTagButton(Boolean)");
+
+ QAction attributeAction = addContextAction("attribute", tr("Attribute"));
+ contextMenu.addAction(attributeAction);
+ attributeAction.triggered.connect(this, "toggleAttributeButton(Boolean)");
+
+ QAction emailAction = addContextAction("email", tr("Email"));
+ contextMenu.addAction(emailAction);
+ emailAction.triggered.connect(this, "toggleEmailButton(Boolean)");
+
+ QAction deleteAction = addContextAction("delete", tr("Delete"));
+ contextMenu.addAction(deleteAction);
+ deleteAction.triggered.connect(this, "toggleDeleteButton(Boolean)");
+
+ QAction newAction = addContextAction("new", tr("Add"));
+ contextMenu.addAction(newAction);
+ newAction.triggered.connect(this, "toggleNewButton(Boolean)");
+
+ QAction allNotesAction = addContextAction("allNotes", tr("All Notes"));
+ contextMenu.addAction(allNotesAction);
+ allNotesAction.triggered.connect(this, "toggleAllNotesButton(Boolean)");
+
+ QAction searchClearAction = addContextAction("searchClear", tr("Search Clear"));
+ contextMenu.addAction(searchClearAction);
+ searchClearAction.triggered.connect(this, "toggleSearchClearButton(Boolean)");
+
+ return contextMenu;
+
+ }
+ private QAction addContextAction(String config, String name) {
+ QAction newAction = new QAction(this);
+ newAction.setText(name);
+ newAction.setCheckable(true);
+ newAction.setChecked(Global.isToolbarButtonVisible(config));
+ return newAction;
+ }
+ private void togglePrevArrowButton(Boolean toggle) {
+ prevButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("prevArrow", toggle);
+ }
+ private void toggleNextArrowButton(Boolean toggle) {
+ nextButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("nextArrow", toggle);
+ }
+ private void toggleUpArrowButton(Boolean toggle) {
+ upButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("upArrow", toggle);
+ }
+ private void toggleDownArrowButton(Boolean toggle) {
+ downButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("downArrow", toggle);
+ }
+ private void toggleSynchronizeButton(Boolean toggle) {
+ synchronizeButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("synchronize", toggle);
+ }
+ private void togglePrintButton(Boolean toggle) {
+ printButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("print", toggle);
+ }
+ private void toggleTagButton(Boolean toggle) {
+ tagButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("tag", toggle);
+ }
+ private void toggleAttributeButton(Boolean toggle) {
+ attributeButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("attribute", toggle);
+ }
+ private void toggleEmailButton(Boolean toggle) {
+ emailButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("email", toggle);
+ }
+ private void toggleDeleteButton(Boolean toggle) {
+ deleteButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("delete", toggle);
+ }
+ private void toggleNewButton(Boolean toggle) {
+ newButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("new", toggle);
+ }
+ private void toggleAllNotesButton(Boolean toggle) {
+ allNotesButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("allNotes", toggle);
+ }
+ private void toggleSearchClearButton(Boolean toggle) {
+ searchClearButton.setVisible(toggle);
+ Global.saveToolbarButtonsVisible("searchClear", toggle);
+ }
+
+
+
+
+
@SuppressWarnings("unused")
private void updateSyncButton() {
- synchronizeFrame++;
+ /* synchronizeFrame++;
if (synchronizeFrame == 4)
synchronizeFrame = 0;
synchronizeButton.setIcon(synchronizeAnimation.get(synchronizeFrame));
+ */
+/*
+ QPixmap pix = new QPixmap(iconPath+"synchronize.png");
+ QMatrix matrix = new QMatrix();
+ synchronizeIconAngle = synchronizeIconAngle + 1.0;
+ if (synchronizeIconAngle >= 365.0)
+ synchronizeIconAngle = 0.0;
+ matrix.translate(pix.size().width()/2, pix.size().height()/2);
+ matrix.rotate( synchronizeIconAngle );
+ matrix.translate(-pix.size().width()/2, -pix.size().height()/2);
+ pix = pix.transformed(matrix, TransformationMode.SmoothTransformation);
+ synchronizeButton.setIcon(pix);
+*/
+
+
+ QPixmap pix = new QPixmap(iconPath+"synchronize.png");
+ QPixmap rotatedPix = new QPixmap(pix.size());
+ QPainter p = new QPainter(rotatedPix);
+
+ rotatedPix.fill(toolBar.palette().color(ColorRole.Button));
+ QSize size = pix.size();
+ p.translate(size.width()/2, size.height()/2);
+ synchronizeIconAngle = synchronizeIconAngle+1.0;
+ if (synchronizeIconAngle >= 359.0)
+ synchronizeIconAngle = 0.0;
+ p.rotate(synchronizeIconAngle);
+ p.setBackgroundMode(BGMode.OpaqueMode);
+ p.translate(-size.width()/2, -size.height()/2);
+ p.drawPixmap(0,0, pix);
+ p.end();
+ synchronizeButton.setIcon(rotatedPix);
+
}
// Synchronize with Evernote
@SuppressWarnings("unused")
if (!Global.isConnected)
remoteConnect();
if (Global.isConnected)
- synchronizeAnimationTimer.start(200);
+ synchronizeAnimationTimer.start(10);
+// synchronizeAnimationTimer.start(200);
syncTimer();
logger.log(logger.HIGH, "Leaving NeverNote.evernoteSync");
}
hide();
} else {
show();
+ if (windowMaximized)
+ showMaximized();
+ else
+ showNormal();
raise();
}
}
// SyncRunner had a problem and things are disconnected
@SuppressWarnings("unused")
private void remoteErrorDisconnect() {
- menuBar.connectAction.setText("Connect");
- menuBar.connectAction.setToolTip("Connect to Evernote");
+ menuBar.connectAction.setText(tr("Connect"));
+ menuBar.connectAction.setToolTip(tr("Connect to Evernote"));
menuBar.synchronizeAction.setEnabled(false);
synchronizeAnimationTimer.stop();
return;
syncRunner.userStoreUrl = Global.userStoreUrl;
syncRunner.noteStoreUrl = Global.noteStoreUrl;
syncRunner.noteStoreUrlBase = Global.noteStoreUrlBase;
+
+ if (Global.getProxyValue("url").equals("")) {
+ System.setProperty("http.proxyHost","") ;
+ System.setProperty("http.proxyPort", "") ;
+ System.setProperty("https.proxyHost","") ;
+ System.setProperty("https.proxyPort", "") ;
+ } else {
+ // PROXY
+ System.setProperty("http.proxyHost",Global.getProxyValue("url")) ;
+ System.setProperty("http.proxyPort", Global.getProxyValue("port")) ;
+ System.setProperty("https.proxyHost",Global.getProxyValue("url")) ;
+ System.setProperty("https.proxyPort", Global.getProxyValue("port")) ;
+
+ if (Global.getProxyValue("userid").equals("")) {
+ Authenticator.setDefault(new Authenticator() {
+ @Override
+ protected PasswordAuthentication getPasswordAuthentication() {
+ return new
+ PasswordAuthentication(Global.getProxyValue("userid"),Global.getProxyValue("password").toCharArray());
+ }});
+ }
+ }
+
+
syncRunner.enConnect();
Global.isConnected = syncRunner.isConnected;
setupOnlineMenu();
private void setupConnectMenuOptions() {
logger.log(logger.HIGH, "entering NeverNote.setupConnectMenuOptions");
if (!Global.isConnected) {
- menuBar.connectAction.setText("Connect");
- menuBar.connectAction.setToolTip("Connect to Evernote");
+ menuBar.connectAction.setText(tr("Connect"));
+ menuBar.connectAction.setToolTip(tr("Connect to Evernote"));
menuBar.synchronizeAction.setEnabled(false);
} else {
- menuBar.connectAction.setText("Disconnect");
- menuBar.connectAction.setToolTip("Disconnect from Evernote");
+ menuBar.connectAction.setText(tr("Disconnect"));
+ menuBar.connectAction.setToolTip(tr("Disconnect from Evernote"));
menuBar.synchronizeAction.setEnabled(true);
}
logger.log(logger.HIGH, "Leaving NeverNote.setupConnectionMenuOptions");
DateAttributeFilterTable f = null;
f = findDateAttributeFilterTable(item.parent());
if (f!=null)
- f.select(item.text(0));
+ f.select(item.parent().indexOfChild(item));
else {
- String text = item.text(0);
- Global.containsFilter.select(text);
+ Global.containsFilter.select(item.parent().indexOfChild(item));
}
}
listManager.loadNotesIndex();
private DateAttributeFilterTable findDateAttributeFilterTable(QTreeWidgetItem w) {
if (w.parent() != null && w.childCount() > 0) {
QTreeWidgetItem parent = w.parent();
- if (parent.text(0).equalsIgnoreCase("created") &&
- w.text(0).equalsIgnoreCase("since"))
+ if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Created &&
+ w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Since)
return Global.createdSinceFilter;
- if (parent.text(0).equalsIgnoreCase("created") &&
- w.text(0).equalsIgnoreCase("before"))
+ if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Created &&
+ w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Before)
return Global.createdBeforeFilter;
- if (parent.text(0).equalsIgnoreCase("last modified") &&
- w.text(0).equalsIgnoreCase("since"))
+ if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.LastModified &&
+ w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Since)
return Global.changedSinceFilter;
- if (parent.text(0).equalsIgnoreCase("last modified") &&
- w.text(0).equalsIgnoreCase("before"))
+ if (parent.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.LastModified &&
+ w.data(0,ItemDataRole.UserRole)==AttributeTreeWidget.Attributes.Before)
return Global.changedBeforeFilter;
}
return null;
}
+
// Show/Hide attribute search window
private void toggleAttributesWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleAttributesWindow");
noteTableView.showColumn(Global.noteTableGuidPosition);
List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
- noteTableView.hideColumn(Global.noteTableGuidPosition);
+ if (!Global.isColumnVisible("guid"))
+ noteTableView.hideColumn(Global.noteTableGuidPosition);
if (selections.size() > 0) {
QModelIndex index;
upButton.setEnabled(false);
else
upButton.setEnabled(true);
- if (row < noteTableView.model.rowCount()-1)
+ if (row < listManager.getNoteTableModel().rowCount()-1)
downButton.setEnabled(true);
else
downButton.setEnabled(false);
// Trigger a refresh when the note db has been updated
private void noteIndexUpdated(boolean reload) {
logger.log(logger.HIGH, "Entering NeverNote.noteIndexUpdated");
- Global.traceReset();
saveNote();
refreshEvernoteNoteList();
logger.log(logger.HIGH, "Calling note table reload in NeverNote.noteIndexUpdated() - "+reload);
- noteTableView.load(listManager, reload);
+ noteTableView.load(reload);
scrollToGuid(currentNoteGuid);
logger.log(logger.HIGH, "Leaving NeverNote.noteIndexUpdated");
}
if (currentNoteGuid == null)
currentNoteGuid = new String();
+ //determine current note guid
for (Note note : listManager.getNoteIndex()) {
tempNoteGuid = note.getGuid();
if (currentNoteGuid.equals(tempNoteGuid)) {
- saveCurrentNoteGuid = new String(tempNoteGuid);
+ saveCurrentNoteGuid = tempNoteGuid;
}
}
browserWindow.setDisabled(true);
}
- if (saveCurrentNoteGuid.equals("") && listManager.getNoteIndex().size() >0) {
- currentNoteGuid = listManager.getNoteIndex().get(listManager.getNoteIndex().size()-1).getGuid();
+ if (saveCurrentNoteGuid.equals("") && listManager.getNoteIndex().size() > 0) {
currentNote = listManager.getNoteIndex().get(listManager.getNoteIndex().size()-1);
+ currentNoteGuid = currentNote.getGuid();
refreshEvernoteNote(true);
} else {
- refreshEvernoteNote(false);
+ //we can reload if note not dirty
+ refreshEvernoteNote(!noteDirty);
}
- reloadTagTree();
+ reloadTagTree(false);
logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNoteList");
}
private void downAction() {
List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
int row = selections.get(0).row();
- int max = noteTableView.model.rowCount();
+ int max = listManager.getNoteTableModel().rowCount();
if (row < max-1) {
noteTableView.selectRow(row+1);
}
tagBuffer.append(", ");
}
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableTagPosition,tagBuffer.toString());
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition,tagBuffer.toString());
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ noteTableView.proxyModel.invalidate();
return;
}
}
}
// Update a title for a specific note in the list
@SuppressWarnings("unused")
- private void updateListTitle(String guid, String title) {
- logger.log(logger.HIGH, "Entering NeverNote.updateListTitle");
-
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- //QModelIndex modelIndex = noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
-// SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(modelIndex);
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
- String tableGuid = (String)ix.values().toArray()[0];
- if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableTitlePosition,title);
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- return;
- }
- }
- }
- logger.log(logger.HIGH, "Leaving NeverNote.updateListTitle");
- }
- // Update a title for a specific note in the list
- @SuppressWarnings("unused")
private void updateListAuthor(String guid, String author) {
logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
//QModelIndex modelIndex = noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
-// SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(modelIndex);
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableAuthorPosition,author);
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableAuthorPosition,author);
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ noteTableView.proxyModel.invalidate();
return;
}
}
}
+
logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
}
private void updateListNoteNotebook(String guid, String notebook) {
- logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
-
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- //QModelIndex modelIndex = noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
-// SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(modelIndex);
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
- String tableGuid = (String)ix.values().toArray()[0];
- if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableNotebookPosition,notebook);
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- return;
- }
- }
- }
- logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
+ logger.log(logger.HIGH, "Entering NeverNote.updateListNoteNotebook");
+ listManager.getNoteTableModel().updateNoteSyncStatus(guid, false);
+ logger.log(logger.HIGH, "Leaving NeverNote.updateListNoteNotebook");
}
// Update a title for a specific note in the list
@SuppressWarnings("unused")
private void updateListSourceUrl(String guid, String url) {
logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
//QModelIndex modelIndex = noteTableView.proxyModel.index(i, Global.noteTableGuidPosition);
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
// SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(modelIndex);
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- noteTableView.model.setData(i, Global.noteTableSourceUrlPosition,url);
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableSourceUrlPosition,url);
+ noteTableView.proxyModel.invalidate();
return;
}
}
private void updateListGuid(String oldGuid, String newGuid) {
logger.log(logger.HIGH, "Entering NeverNote.updateListTitle");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(oldGuid)) {
- noteTableView.model.setData(i, Global.noteTableGuidPosition,newGuid);
- //noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableGuidPosition,newGuid);
+ //listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
return;
}
}
if (listManager.getNoteIndex().get(j).getTagGuids().contains(guid)) {
String newName = listManager.getTagNamesForNote(listManager.getNoteIndex().get(j));
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String noteGuid = (String)ix.values().toArray()[0];
if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
- noteTableView.model.setData(i, Global.noteTableTagPosition, newName);
- //noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- i=noteTableView.model.rowCount();
+ listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
+ i=listManager.getNoteTableModel().rowCount();
}
}
}
}
String newName = listManager.getTagNamesForNote(listManager.getNoteIndex().get(j));
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String noteGuid = (String)ix.values().toArray()[0];
if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
- noteTableView.model.setData(i, Global.noteTableTagPosition, newName);
-// noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- i=noteTableView.model.rowCount();
+ listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
+ i=listManager.getNoteTableModel().rowCount();
}
}
}
private void updateListNotebookName(String oldName, String newName) {
logger.log(logger.HIGH, "Entering NeverNote.updateListNotebookName");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableNotebookPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableNotebookPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableName = (String)ix.values().toArray()[0];
if (tableName.equalsIgnoreCase(oldName)) {
-// noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- noteTableView.model.setData(i, Global.noteTableNotebookPosition, newName);
+ listManager.getNoteTableModel().setData(i, Global.noteTableNotebookPosition, newName);
}
}
}
private void updateListDateCreated(String guid, QDateTime date) {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateCreated");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableCreationPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ listManager.getNoteTableModel().setData(i, Global.noteTableCreationPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ noteTableView.proxyModel.invalidate();
return;
}
}
private void updateListDateSubject(String guid, QDateTime date) {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateSubject");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- noteTableView.model.setData(i, Global.noteTableSubjectDatePosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableSubjectDatePosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ noteTableView.proxyModel.invalidate();
return;
}
}
private void updateListDateChanged(String guid, QDateTime date) {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- noteTableView.model.setData(i, Global.noteTableChangedPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableChangedPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
return;
}
}
}
private void updateListDateChanged() {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
- QDateTime date = new QDateTime(QDateTime.currentDateTime());
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
- String tableGuid = (String)ix.values().toArray()[0];
- if (tableGuid.equals(currentNoteGuid)) {
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
- noteTableView.model.setData(i, Global.noteTableChangedPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
- return;
- }
- }
- }
+ QDateTime date = new QDateTime(QDateTime.currentDateTime());
+ updateListDateChanged(currentNoteGuid, date);
logger.log(logger.HIGH, "Leaving NeverNote.updateListDateChanged");
}
// Redo scroll
// noteTableView.setCurrentIndex(index);
noteTableView.selectRow(i);
noteTableView.scrollTo(index, ScrollHint.EnsureVisible); // This should work, but it doesn't
- i=noteTableView.model.rowCount();
+ i=listManager.getNoteTableModel().rowCount();
}
}
+ noteTableView.repaint();
}
// Show/Hide columns
private void showColumns() {
noteTableView.setColumnHidden(Global.noteTableTagPosition, !Global.isColumnVisible("tags"));
noteTableView.setColumnHidden(Global.noteTableNotebookPosition, !Global.isColumnVisible("notebook"));
noteTableView.setColumnHidden(Global.noteTableSynchronizedPosition, !Global.isColumnVisible("synchronized"));
- }
- // Open a separate window
- @SuppressWarnings("unused")
- private void listDoubleClick() {
-
+ noteTableView.setColumnHidden(Global.noteTableGuidPosition, !Global.isColumnVisible("guid"));
+ noteTableView.setColumnHidden(Global.noteTableThumbnailPosition, !Global.isColumnVisible("thumbnail"));
+ noteTableView.setColumnHidden(Global.noteTableTitlePosition, !Global.isColumnVisible("title"));
}
// Title color has changed
@SuppressWarnings("unused")
selectedNoteGUIDs.add(currentNoteGuid);
for (int j=0; j<selectedNoteGUIDs.size(); j++) {
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(selectedNoteGUIDs.get(j))) {
for (int k=0; k<Global.noteTableColumnCount; k++) {
- noteTableView.model.setData(i, k, backgroundColor, Qt.ItemDataRole.BackgroundRole);
- noteTableView.model.setData(i, k, foregroundColor, Qt.ItemDataRole.ForegroundRole);
+ listManager.getNoteTableModel().setData(i, k, backgroundColor, Qt.ItemDataRole.BackgroundRole);
+ listManager.getNoteTableModel().setData(i, k, foregroundColor, Qt.ItemDataRole.ForegroundRole);
listManager.updateNoteTitleColor(selectedNoteGUIDs.get(j), backgroundColor.rgb());
}
- i=noteTableView.model.rowCount();
+ i=listManager.getNoteTableModel().rowCount();
}
}
}
}
logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
}
+ // Wide list was chosen
+ public void narrowListView() {
+ saveNoteColumnPositions();
+ saveNoteIndexWidth();
+ saveWindowState();
+ Global.setListView(Global.View_List_Narrow);
+
+ menuBar.wideListView.blockSignals(true);
+ menuBar.narrowListView.blockSignals(true);
+
+ menuBar.wideListView.setChecked(false);
+ menuBar.narrowListView.setChecked(true);
+
+ menuBar.wideListView.blockSignals(false);
+ menuBar.narrowListView.blockSignals(false);
+
+ mainLeftRightSplitter.addWidget(noteTableView);
+ mainLeftRightSplitter.addWidget(browserWindow);
+ restoreWindowState(false);
+ noteTableView.repositionColumns();
+ noteTableView.resizeColumnWidths();
+ noteTableView.resizeRowHeights();
+ showColumns();
+ noteTableView.load(false);
+ scrollToCurrentGuid();
+ }
+ public void wideListView() {
+ saveWindowState();
+ saveNoteColumnPositions();
+ saveNoteIndexWidth();
+ Global.setListView(Global.View_List_Wide);
+
+ menuBar.wideListView.blockSignals(true);
+ menuBar.narrowListView.blockSignals(true);
+
+ menuBar.wideListView.setChecked(true);
+ menuBar.narrowListView.setChecked(false);
+
+ menuBar.wideListView.blockSignals(false);
+ menuBar.narrowListView.blockSignals(false);
+ browserIndexSplitter.setVisible(true);
+ browserIndexSplitter.addWidget(noteTableView);
+ browserIndexSplitter.addWidget(browserWindow);
+ restoreWindowState(false);
+ noteTableView.repositionColumns();
+ noteTableView.resizeColumnWidths();
+ noteTableView.resizeRowHeights();
+ showColumns();
+ noteTableView.load(false);
+ scrollToCurrentGuid();
+ }
+
+
+ //***************************************************************
+ //***************************************************************
+ //** External editor window functions
+ //***************************************************************
+ //***************************************************************
+ @SuppressWarnings("unused")
+ private void listDoubleClick() {
+ saveNote();
+ if (externalWindows.containsKey(currentNoteGuid)) {
+ externalWindows.get(currentNoteGuid).raise();
+ return;
+ }
+ // We have a new external editor to create
+ QIcon appIcon = new QIcon(iconPath+"nevernote.png");
+ ExternalBrowse newBrowser = new ExternalBrowse(conn);
+ newBrowser.setWindowIcon(appIcon);
+ externalWindows.put(currentNoteGuid, newBrowser);
+ showEditorButtons(newBrowser.getBrowserWindow());
+ loadNoteBrowserInformation(newBrowser.getBrowserWindow());
+ setupBrowserWindowListeners(newBrowser.getBrowserWindow(), false);
+ newBrowser.windowClosing.connect(this, "externalWindowClosing(String)");
+ newBrowser.getBrowserWindow().noteSignal.titleChanged.connect(this, "externalWindowTitleEdited(String, String)");
+ newBrowser.getBrowserWindow().noteSignal.tagsChanged.connect(this, "externalWindowTagsEdited(String, List)");
+ newBrowser.contentsChanged.connect(this, "saveNoteExternalBrowser(String, String, Boolean, BrowserWindow)");
+
+ browserWindow.noteSignal.tagsChanged.connect(newBrowser, "updateTags(String, List)");
+ browserWindow.noteSignal.titleChanged.connect(newBrowser, "updateTitle(String, String)");
+ browserWindow.noteSignal.notebookChanged.connect(newBrowser, "updateNotebook(String, String)");
+
+ newBrowser.show();
+ }
+ @SuppressWarnings("unused")
+ private void externalWindowTitleEdited(String guid, String text) {
+ if (guid.equals(currentNoteGuid)) {
+ browserWindow.setTitle(text);
+ }
+ }
+ @SuppressWarnings("unused")
+ private void externalWindowTagsEdited(String guid, List values) {
+ StringBuffer line = new StringBuffer(100);
+ for (int i=0; i<values.size(); i++) {
+ if (i>0)
+ line.append(Global.tagDelimeter+" ");
+ line.append(values.get(i));
+ }
+ if (guid.equals(currentNoteGuid)) {
+ browserWindow.setTag(line.toString());
+ }
+ }
+ @SuppressWarnings("unused")
+ private void externalWindowClosing(String guid) {
+ externalWindows.remove(guid);
+ }
+
//***************************************************************
@SuppressWarnings("unused")
private void setNoteDirty() {
logger.log(logger.EXTREME, "Entering NeverNote.setNoteDirty()");
- noteDirty = true;
-
- listManager.getUnsynchronizedNotes().add(currentNoteGuid);
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
+ // Find if the note is being edited externally. If it is, update it.
+ if (externalWindows.containsKey(currentNoteGuid)) {
+ QTextCodec codec = QTextCodec.codecForName("UTF-8");
+ QByteArray unicode = codec.fromUnicode(browserWindow.getContent());
+ ExternalBrowse window = externalWindows.get(currentNoteGuid);
+ window.getBrowserWindow().getBrowser().setContent(unicode);
+ }
+
+ // If the note is dirty, then it is unsynchronized by default.
+ if (noteDirty)
+ return;
+
+ // Set the note as dirty and check if its status is synchronized in the display table
+ noteDirty = true;
+ for (int i=0; i<listManager.getUnsynchronizedNotes().size(); i++) {
+ if (listManager.getUnsynchronizedNotes().get(i).equals(currentNoteGuid))
+ return;
+ }
+
+ // If this wasn't already marked as unsynchronized, then we need to update the table
+ listManager.getNoteTableModel().updateNoteSyncStatus(currentNoteGuid, false);
+/* listManager.getUnsynchronizedNotes().add(currentNoteGuid);
+ for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(currentNoteGuid)) {
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
return;
}
}
}
+ */
logger.log(logger.EXTREME, "Leaving NeverNote.setNoteDirty()");
}
+ @SuppressWarnings("unused")
+ private void saveNoteExternalBrowser(String guid, String content, Boolean save, BrowserWindow browser) {
+ QTextCodec codec = QTextCodec.codecForName("UTF-8");
+ QByteArray unicode = codec.fromUnicode(content);
+ noteCache.remove(guid);
+ noteCache.put(guid, unicode.toString());
+ if (guid.equals(currentNoteGuid)) {
+ noteDirty = true;
+ browserWindow.getBrowser().setContent(unicode);
+ }
+ if (save) {
+ thumbnailRunner.addWork("GENERATE "+ guid);
+ saveNote(guid, browser);
+ }
+
+ }
private void saveNote() {
- logger.log(logger.EXTREME, "Inside NeverNote.saveNote()");
if (noteDirty) {
- logger.log(logger.EXTREME, "Note is dirty.");
- waitCursor(true);
-
- preview = new Thumbnailer(currentNoteGuid, new QSize(1024,768));
- preview.finished.connect(this, "saveThumbnail(String)");
- preview.setContent(browserWindow.getContent());
+ saveNote(currentNoteGuid, browserWindow);
+ thumbnailRunner.addWork("GENERATE "+ currentNoteGuid);
+ noteDirty = false;
+ }
+ }
+ private void saveNote(String guid, BrowserWindow window) {
+ logger.log(logger.EXTREME, "Inside NeverNote.saveNote()");
+ logger.log(logger.EXTREME, "Note is dirty.");
+ waitCursor(true);
- logger.log(logger.EXTREME, "Saving to cache");
- QTextCodec codec = QTextCodec.codecForLocale();
+ logger.log(logger.EXTREME, "Saving to cache");
+ QTextCodec codec = QTextCodec.codecForLocale();
// QTextDecoder decoder = codec.makeDecoder();
- codec = QTextCodec.codecForName("UTF-8");
- QByteArray unicode = codec.fromUnicode(browserWindow.getContent());
- noteCache.put(currentNoteGuid, unicode.toString());
+ codec = QTextCodec.codecForName("UTF-8");
+ QByteArray unicode = codec.fromUnicode(window.getContent());
+ noteCache.put(guid, unicode.toString());
- logger.log(logger.EXTREME, "updating list manager");
- listManager.updateNoteContent(currentNoteGuid, browserWindow.getContent());
- logger.log(logger.EXTREME, "Updating title");
- listManager.updateNoteTitle(currentNoteGuid, browserWindow.getTitle());
- updateListDateChanged();
+ logger.log(logger.EXTREME, "updating list manager");
+ listManager.updateNoteContent(guid, window.getContent());
+ logger.log(logger.EXTREME, "Updating title");
+ listManager.updateNoteTitle(guid, window.getTitle());
+ updateListDateChanged();
- logger.log(logger.EXTREME, "Looking through note index for refreshed note");
- for (int i=0; i<listManager.getNoteIndex().size(); i++) {
- if (listManager.getNoteIndex().get(i).getGuid().equals(currentNoteGuid)) {
- currentNote = listManager.getNoteIndex().get(i);
- i = listManager.getNoteIndex().size();
- }
+ logger.log(logger.EXTREME, "Looking through note index for refreshed note");
+ for (int i=0; i<listManager.getNoteIndex().size(); i++) {
+ if (listManager.getNoteIndex().get(i).getGuid().equals(guid)) {
+ currentNote = listManager.getNoteIndex().get(i);
+ i = listManager.getNoteIndex().size();
}
- noteDirty = false;
- waitCursor(false);
}
+ waitCursor(false);
}
// Get a note from Evernote (and put it in the browser)
private void refreshEvernoteNote(boolean reload) {
logger.log(logger.HIGH, "Entering NeverNote.refreshEvernoteNote");
- if (Global.getDisableViewing()) {
+ if (Global.disableViewing) {
browserWindow.setEnabled(false);
return;
}
browserWindow.setReadOnly(true);
return;
}
+
if (!reload)
return;
currentNote = conn.getNoteTable().getNote(currentNoteGuid, true,true,false,false,true);
if (currentNote == null)
return;
+
+ loadNoteBrowserInformation(browserWindow);
+ }
+ private void loadNoteBrowserInformation(BrowserWindow browser) {
+ NoteFormatter formatter = new NoteFormatter(logger, conn, tempFiles);
+ formatter.setNote(currentNote, Global.pdfPreview());
+ formatter.setHighlight(listManager.getEnSearch());
+ QByteArray js;
if (!noteCache.containsKey(currentNoteGuid) || conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
- QByteArray js = new QByteArray();
+ js = new QByteArray();
// We need to prepend the note with <HEAD></HEAD> or encoded characters are ugly
js.append("<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=UTF-8\">");
- js.append("<style type=\"text/css\">en-crypt-temp { border-style:solid; border-color:blue; padding:0.5mm 0.5mm 0.5mm 0.5mm; }</style>");
+ 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>");
js.append("<style type=\"text/css\">en-hilight { background-color: rgb(255,255,0) }</style>");
+ js.append("<style> img { max-width:100%; }</style>");
js.append("<style type=\"text/css\">en-spell { text-decoration: none; border-bottom: dotted 1px #cc0000; }</style>");
js.append("</head>");
- js.append(rebuildNoteHTML(currentNoteGuid, currentNote.getContent()));
+ formatter.setNote(currentNote, Global.pdfPreview());
+ js.append(formatter.rebuildNoteHTML());
js.append("</HTML>");
js.replace("<!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml.dtd'>", "");
js.replace("<!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml2.dtd'>", "");
js.replace("<?xml version='1.0' encoding='UTF-8'?>", "");
- browserWindow.getBrowser().setContent(js);
+ browser.getBrowser().setContent(js);
noteCache.put(currentNoteGuid, js.toString());
- if (conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
- preview = new Thumbnailer(currentNoteGuid, new QSize(1024,768));
- preview.finished.connect(this, "saveThumbnail(String)");
- preview.setContent(js.toString());
- }
} else {
logger.log(logger.HIGH, "Note content is being pulled from the cache");
- String cachedContent = modifyCachedTodoTags(noteCache.get(currentNoteGuid));
- browserWindow.getBrowser().setContent(new QByteArray(cachedContent));
+ String cachedContent = formatter.modifyCachedTodoTags(noteCache.get(currentNoteGuid));
+ js = new QByteArray(cachedContent);
+ browser.getBrowser().setContent(js);
+ }
+ if (conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
+ thumbnailHTMLReady(currentNoteGuid, js, Global.calculateThumbnailZoom(js.toString()));
}
+
+ if (formatter.resourceError)
+ resourceErrorMessage();
+ inkNote = formatter.readOnly;
- browserWindow.getBrowser().page().setContentEditable(!inkNote); // We don't allow editing of ink notes
- browserWindow.setNote(currentNote);
+ browser.getBrowser().page().setContentEditable(!inkNote); // We don't allow editing of ink notes
+ browser.setNote(currentNote);
// Build a list of non-closed notebooks
List<Notebook> nbooks = new ArrayList<Notebook>();
nbooks.add(listManager.getNotebookIndex().get(i));
}
- browserWindow.setNotebookList(nbooks);
- browserWindow.setTitle(currentNote.getTitle());
- browserWindow.setTag(getTagNamesForNote(currentNote));
- browserWindow.setAuthor(currentNote.getAttributes().getAuthor());
+ browser.setNotebookList(nbooks);
+ browser.setTitle(currentNote.getTitle());
+ browser.setTag(getTagNamesForNote(currentNote));
+ browser.setAuthor(currentNote.getAttributes().getAuthor());
- browserWindow.setAltered(currentNote.getUpdated());
- browserWindow.setCreation(currentNote.getCreated());
+ browser.setAltered(currentNote.getUpdated());
+ browser.setCreation(currentNote.getCreated());
if (currentNote.getAttributes().getSubjectDate() > 0)
- browserWindow.setSubjectDate(currentNote.getAttributes().getSubjectDate());
+ browser.setSubjectDate(currentNote.getAttributes().getSubjectDate());
else
- browserWindow.setSubjectDate(currentNote.getCreated());
- browserWindow.setUrl(currentNote.getAttributes().getSourceURL());
- browserWindow.setAllTags(listManager.getTagIndex());
- browserWindow.setCurrentTags(currentNote.getTagNames());
+ browser.setSubjectDate(currentNote.getCreated());
+ browser.setUrl(currentNote.getAttributes().getSourceURL());
+ browser.setAllTags(listManager.getTagIndex());
+ browser.setCurrentTags(currentNote.getTagNames());
noteDirty = false;
scrollToGuid(currentNoteGuid);
- browserWindow.loadingData(false);
+ browser.loadingData(false);
if (thumbnailViewer.isActiveWindow())
thumbnailView();
waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNote");
}
// Save a generated thumbnail
- @SuppressWarnings("unused")
- private void saveThumbnail(String guid) {
- QFile tFile = new QFile(Global.currentDir+"res/thumbnail-"+guid+".png");
- tFile.open(OpenModeFlag.ReadOnly);
- QByteArray imgBytes = tFile.readAll();
- tFile.close();
- conn.getNoteTable().setThumbnail(guid, imgBytes);
- conn.getNoteTable().setThumbnailNeeded(guid, false);
- thumbnailViewer.setThumbnail(QImage.fromData(imgBytes));
- if (thumbnailViewer.isVisible())
- thumbnailViewer.showFullScreen();
-
- /*
- QByteArray img2 = new QByteArray(conn.getNoteTable().getThumbnail(guid));
- QFile file = new QFile(Global.currentDir+"res/aaaa.png");
- file.open(OpenModeFlag.WriteOnly);
- file.write(img2);
- file.close();
- */
- }
- // Show/Hide note information
- @SuppressWarnings("unused")
private void toggleNoteInformation() {
logger.log(logger.HIGH, "Entering NeverNote.toggleNoteInformation");
browserWindow.toggleInformation();
menuBar.noteAttributes.setChecked(browserWindow.isExtended());
+ Global.saveWindowVisible("noteInformation", browserWindow.isExtended());
logger.log(logger.HIGH, "Leaving NeverNote.toggleNoteInformation");
}
// Listener triggered when a print button is pressed
String text2 = browserWindow.getContentsToEmail();
QUrl url = new QUrl("mailto:");
url.addQueryItem("subject", currentNote.getTitle());
- url.addQueryItem("body", QUrl.toPercentEncoding(text2).toString());
+// url.addQueryItem("body", QUrl.toPercentEncoding(text2).toString());
+ url.addQueryItem("body", text2);
QDesktopServices.openUrl(url);
}
/*
private void fullReindex() {
logger.log(logger.HIGH, "Entering NeverNote.fullReindex");
// If we are deleting non-trash notes
+ if (currentNote == null) return;
if (currentNote.getDeleted() == 0) {
- if (QMessageBox.question(this, "Confirmation", "This will cause all notes & attachments to be reindexed, "+
+ if (QMessageBox.question(this, tr("Confirmation"), tr("This will cause all notes & attachments to be reindexed, "+
"but please be aware that depending upon the size of your database updating all these records " +
- "can be time consuming and NeverNote will be unresponsive until it is complete. Do you wish to continue?",
+ "can be time consuming and NeverNote will be unresponsive until it is complete. Do you wish to continue?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
return;
}
}
waitCursor(true);
- setMessage("Marking notes for reindex.");
+ setMessage(tr("Marking notes for reindex."));
conn.getNoteTable().reindexAllNotes();
conn.getNoteTable().noteResourceTable.reindexAll();
- setMessage("Database will be reindexed.");
+ setMessage(tr("Database will be reindexed."));
waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.fullRefresh");
}
conn.getNoteTable().setIndexNeeded(selectedNoteGUIDs.get(i), true);
}
if (selectedNotebookGUIDs.size() > 1)
- setMessage("Notes will be reindexed.");
+ setMessage(tr("Notes will be reindexed."));
else
- setMessage("Note will be reindexed.");
+ setMessage(tr("Note will be reindexed."));
logger.log(logger.HIGH, "Leaving NeverNote.reindexNote");
}
// Delete the note
// If we are deleting non-trash notes
if (currentNote.isActive()) {
if (Global.verifyDelete()) {
- if (QMessageBox.question(this, "Confirmation", "Delete selected note(s)?",
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Delete selected note(s)?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
return;
if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
selectedNoteGUIDs.add(currentNoteGuid);
for (int i=selectedNoteGUIDs.size()-1; i>=0; i--) {
- for (int j=noteTableView.model.rowCount()-1; j>=0; j--) {
- QModelIndex modelIndex = noteTableView.model.index(j, Global.noteTableGuidPosition);
+ for (int j=listManager.getNoteTableModel().rowCount()-1; j>=0; j--) {
+ QModelIndex modelIndex = listManager.getNoteTableModel().index(j, Global.noteTableGuidPosition);
if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
+ SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(selectedNoteGUIDs.get(i))) {
- noteTableView.model.removeRow(j);
+ listManager.getNoteTableModel().removeRow(j);
j=-1;
}
}
browserWindow.setReadOnly(false);
saveNote();
Calendar currentTime = new GregorianCalendar();
- String noteString = new String("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
+ StringBuffer noteString = new StringBuffer(100);
+ noteString.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
"<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">\n" +
- "<en-note>\n<br clear=\"none\" /></en-note>");
+ "<en-note>\n");
+
+ if (Global.overrideDefaultFont()) {
+ noteString.append("<font face=\"" +Global.getDefaultFont() +"\" >");
+ noteString.append("<span style=\"font-size:" +Global.getDefaultFontSize() +"pt;\">");
+ noteString.append("<br clear=\"none\" />\n");
+ noteString.append("</span>\n</font>\n");
+ } else
+ noteString.append("<br clear=\"none\" />\n");
+ noteString.append("</en-note>");
Long l = new Long(currentTime.getTimeInMillis());
- String randint = new String(Long.toString(l));
+ String randint = new String(Long.toString(l));
// Find a notebook. We first look for a selected notebook (the "All Notebooks" one doesn't count).
// Then we look
newNote.setGuid(randint);
newNote.setNotebookGuid(notebook);
newNote.setTitle("");
- newNote.setContent(noteString);
+ newNote.setContent(noteString.toString());
newNote.setDeleted(0);
newNote.setCreated(System.currentTimeMillis());
newNote.setUpdated(System.currentTimeMillis());
na.setLongitude(0.0);
na.setAltitude(0.0);
newNote.setAttributes(new NoteAttributes());
+ newNote.setTagGuids(new ArrayList<String>());
+ newNote.setTagNames(new ArrayList<String>());
+
+ // If new notes are to be created based upon the selected tags, then we need to assign the tags
+ if (Global.newNoteWithSelectedTags()) {
+ List<QTreeWidgetItem> selections = tagTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ for (int i=0; i<selections.size(); i++) {
+ currentSelection = selections.get(i);
+ newNote.getTagGuids().add(currentSelection.text(2));
+ newNote.getTagNames().add(currentSelection.text(0));
+ }
+ }
+
conn.getNoteTable().addNote(newNote, true);
listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(listManager, newNote, true, -1);
+ listManager.addNote(newNote);
+// noteTableView.insertRow(newNote, true, -1);
currentNote = newNote;
currentNoteGuid = currentNote.getGuid();
- listManager.addNote(newNote);
refreshEvernoteNote(true);
listManager.countNotebookResults(listManager.getNoteIndex());
browserWindow.titleLabel.setFocus();
browserWindow.titleLabel.selectAll();
-// notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
+// notebookTree.updateCounts(listManager.getNotebookIndex(), listManager.getNotebookCounter());
+
+ // If the window is hidden, then we want to popup this in an external window &
+ if (!isVisible())
+ listDoubleClick();
logger.log(logger.HIGH, "Leaving NeverNote.addNote");
}
// Restore a note from the trash;
browserWindow.getBrowser().page().findText(find.getText(), find.getFlags());
find.setFocus();
}
+ private void updateNoteTitle(String guid, String title) {
+ listManager.setNoteSynchronized(guid, false);
+ }
// Signal received that note content has changed. Normally we just need the guid to remove
// it from the cache.
@SuppressWarnings("unused")
private void invalidateNoteCache(String guid, String content) {
String v = noteCache.remove(guid);
if (content != null) {
- v = noteCache.put(guid, content);
+ //noteCache.put(guid, content);
}
}
// Signal received that a note guid has changed
currentNote.setGuid(newGuid);
currentNoteGuid = newGuid;
}
+ if (externalWindows.containsKey(oldGuid)) {
+ ExternalBrowse b = externalWindows.get(oldGuid);
+ externalWindows.remove(oldGuid);
+ b.getBrowserWindow().getNote().setGuid(newGuid);
+ externalWindows.put(newGuid, b);
+ }
for (int i=0; i<listManager.getNoteIndex().size(); i++) {
if (listManager.getNoteIndex().get(i).getGuid().equals(newGuid)) {
noteTableView.proxyModel.addGuid(newGuid);
i=listManager.getNoteIndex().size();
}
}
- updateListGuid(oldGuid, newGuid);
+ if (listManager.getNoteTableModel().titleColors.containsKey(oldGuid)) {
+ int color = listManager.getNoteTableModel().titleColors.get(oldGuid);
+ listManager.getNoteTableModel().titleColors.put(newGuid, color);
+ listManager.getNoteTableModel().titleColors.remove(oldGuid);
+ }
+
}
// Toggle the note editor button bar
private void toggleEditorButtonBar() {
// Global.saveWindowVisible("editorButtonBar", browserWindow.buttonsVisible);
} else {
browserWindow.buttonsVisible = true;
- showEditorButtons();
+ showEditorButtons(browserWindow);
}
Global.saveWindowVisible("editorButtonBar", browserWindow.buttonsVisible);
}
// Show editor buttons
- private void showEditorButtons() {
- browserWindow.undoButton.setVisible(false);
- browserWindow.redoButton.setVisible(false);
- browserWindow.cutButton.setVisible(false);
- browserWindow.copyButton.setVisible(false);
- browserWindow.pasteButton.setVisible(false);
- browserWindow.strikethroughButton.setVisible(false);
- browserWindow.underlineButton.setVisible(false);
- browserWindow.boldButton.setVisible(false);
- browserWindow.italicButton.setVisible(false);
- browserWindow.hlineButton.setVisible(false);
- browserWindow.indentButton.setVisible(false);
- browserWindow.outdentButton.setVisible(false);
- browserWindow.fontList.setVisible(false);
- browserWindow.fontSize.setVisible(false);
- browserWindow.fontColor.setVisible(false);
- browserWindow.fontHilight.setVisible(false);
- browserWindow.leftAlignButton.setVisible(false);
- browserWindow.centerAlignButton.setVisible(false);
- browserWindow.rightAlignButton.setVisible(false);
- browserWindow.indentButton.setVisible(false);
- browserWindow.outdentButton.setVisible(false);
+ private void showEditorButtons(BrowserWindow browser) {
+ browser.buttonLayout.setVisible(true);
+ browser.undoAction.setVisible(false);
+
+ browser.undoButton.setVisible(false);
- browserWindow.undoButton.setVisible(Global.isEditorButtonVisible("undo"));
- browserWindow.redoButton.setVisible(Global.isEditorButtonVisible("redo"));
- browserWindow.cutButton.setVisible(Global.isEditorButtonVisible("cut"));
- browserWindow.copyButton.setVisible(Global.isEditorButtonVisible("copy"));
- browserWindow.pasteButton.setVisible(Global.isEditorButtonVisible("paste"));
- browserWindow.strikethroughButton.setVisible(Global.isEditorButtonVisible("strikethrough"));
- browserWindow.underlineButton.setVisible(Global.isEditorButtonVisible("underline"));
- browserWindow.boldButton.setVisible(Global.isEditorButtonVisible("bold"));
- browserWindow.italicButton.setVisible(Global.isEditorButtonVisible("italic"));
- browserWindow.hlineButton.setVisible(Global.isEditorButtonVisible("hline"));
- browserWindow.indentButton.setVisible(Global.isEditorButtonVisible("indent"));
- browserWindow.outdentButton.setVisible(Global.isEditorButtonVisible("outdent"));
- browserWindow.bulletListButton.setVisible(Global.isEditorButtonVisible("bulletList"));
- browserWindow.numberListButton.setVisible(Global.isEditorButtonVisible("numberList"));
- browserWindow.fontList.setVisible(Global.isEditorButtonVisible("font"));
- browserWindow.fontSize.setVisible(Global.isEditorButtonVisible("fontSize"));
- browserWindow.fontColor.setVisible(Global.isEditorButtonVisible("fontColor"));
- browserWindow.fontHilight.setVisible(Global.isEditorButtonVisible("fontHilight"));
- browserWindow.leftAlignButton.setVisible(Global.isEditorButtonVisible("alignLeft"));
- browserWindow.centerAlignButton.setVisible(Global.isEditorButtonVisible("alignCenter"));
- browserWindow.rightAlignButton.setVisible(Global.isEditorButtonVisible("alignRight"));
+ browser.undoAction.setVisible(Global.isEditorButtonVisible("undo"));
+ browser.redoAction.setVisible(Global.isEditorButtonVisible("redo"));
+ browser.cutAction.setVisible(Global.isEditorButtonVisible("cut"));
+ browser.copyAction.setVisible(Global.isEditorButtonVisible("copy"));
+ browser.pasteAction.setVisible(Global.isEditorButtonVisible("paste"));
+ browser.strikethroughAction.setVisible(Global.isEditorButtonVisible("strikethrough"));
+ browser.underlineAction.setVisible(Global.isEditorButtonVisible("underline"));
+ browser.boldAction.setVisible(Global.isEditorButtonVisible("bold"));
+ browser.italicAction.setVisible(Global.isEditorButtonVisible("italic"));
+ browser.hlineAction.setVisible(Global.isEditorButtonVisible("hline"));
+ browser.indentAction.setVisible(Global.isEditorButtonVisible("indent"));
+ browser.outdentAction.setVisible(Global.isEditorButtonVisible("outdent"));
+ browser.bulletListAction.setVisible(Global.isEditorButtonVisible("bulletList"));
+ browser.numberListAction.setVisible(Global.isEditorButtonVisible("numberList"));
+ browser.fontListAction.setVisible(Global.isEditorButtonVisible("font"));
+ browser.fontSizeAction.setVisible(Global.isEditorButtonVisible("fontSize"));
+ browser.fontColorAction.setVisible(Global.isEditorButtonVisible("fontColor"));
+ browser.fontHilightAction.setVisible(Global.isEditorButtonVisible("fontHilight"));
+ browser.leftAlignAction.setVisible(Global.isEditorButtonVisible("alignLeft"));
+ browser.centerAlignAction.setVisible(Global.isEditorButtonVisible("alignCenter"));
+ browser.rightAlignAction.setVisible(Global.isEditorButtonVisible("alignRight"));
+ browser.spellCheckAction.setVisible(Global.isEditorButtonVisible("spellCheck"));
+ browser.todoAction.setVisible(Global.isEditorButtonVisible("todo"));
}
private void duplicateNote(String guid) {
- Calendar currentTime = new GregorianCalendar();
- Long l = new Long(currentTime.getTimeInMillis());
- String newGuid = new String(Long.toString(l));
-
Note oldNote = conn.getNoteTable().getNote(guid, true, true, false, false, false);
- Note newNote = oldNote.deepCopy();
- newNote.setGuid(newGuid);
List<Resource> resList = conn.getNoteTable().noteResourceTable.getNoteResources(guid, true);
+ oldNote.setContent(conn.getNoteTable().getNoteContentBinary(guid));
oldNote.setResources(resList);
duplicateNote(oldNote);
}
listManager.addNote(newNote);
conn.getNoteTable().addNote(newNote, true);
listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(listManager, newNote, true, -1);
+ noteTableView.insertRow(newNote, true, -1);
listManager.countNotebookResults(listManager.getNoteIndex());
waitCursor(false);
}
+ // View all notes
+ private void allNotes() {
+ clearAttributeFilter();
+ clearNotebookFilter();
+ clearSavedSearchFilter();
+ clearTrashFilter();
+ clearTagFilter();
+ searchField.clear();
+ if (Global.mimicEvernoteInterface) {
+ notebookTree.selectGuid("");
+ }
+ notebookTreeSelection();
+ }
// Merge notes
@SuppressWarnings("unused")
private void mergeNotes() {
// View a thumbnail of the note
public void thumbnailView() {
- String thumbnailName = Global.currentDir+"res/thumbnail-"+currentNoteGuid+".png";
+ String thumbnailName = Global.getFileManager().getResDirPath("thumbnail-" + currentNoteGuid + ".png");
QFile thumbnail = new QFile(thumbnailName);
if (!thumbnail.exists()) {
if (!thumbnailViewer.isVisible())
thumbnailViewer.showFullScreen();
}
+ // An error happened while saving a note. Inform the user
+ @SuppressWarnings("unused")
+ private void saveRunnerError(String guid, String msg) {
+ if (msg == null) {
+ String title = "*Unknown*";
+ for (int i=0; i<listManager.getMasterNoteIndex().size(); i++) {
+ if (listManager.getMasterNoteIndex().get(i).getGuid().equals(guid)) {
+ title = listManager.getMasterNoteIndex().get(i).getTitle();
+ i=listManager.getMasterNoteIndex().size();
+ }
+ }
+ msg = "An error has happened while saving the note \"" +title+
+ "\".\n\nThis is probably due to a document that is too complex for Nevernote to process. "+
+ "As a result, changes to the note may not be saved properly in the database."+
+ "\n\nA cached copy is being preserved so you can recover any data, but data may" +
+ "\nbe lost. Please review the note to recover any critical data before restarting.";
+
+ QMessageBox.information(this, tr("Error Saving Note"), tr(msg));
+ }
+ }
+ private void thumbnailHTMLReady(String guid, QByteArray html, Integer zoom) {
+ logger.log(logger.HIGH, "Entering thumnailHTMLReady()");
+ logger.log(logger.HIGH, "Thumbnail ready for " +guid);
+ // Find an idle preview object
+ for (int i=0; i<thumbGenerators.size(); i++) {
+ if (thumbGenerators.get(i).mutex.tryLock()) {
+ logger.log(logger.EXTREME, "Idle generator found - loading thumbnail for " +guid);
+ thumbGenerators.get(i).loadContent(guid, html, zoom);
+ return;
+ }
+ }
+ if (thumbGenerators.size() >= 1) {
+ logger.log(logger.EXTREME, "No available thumbnail generators. Aborting " +guid);
+ return;
+ }
+
+ logger.log(logger.EXTREME, "Creating new thumbnail generator " +guid);
+ Thumbnailer preview = new Thumbnailer(logger, conn, listManager, thumbnailRunner);
+ thumbGenerators.add(preview);
+ if (preview.mutex.tryLock()) {
+ logger.log(logger.EXTREME, "Loading thumbnail for " +guid);
+ preview.loadContent(guid, html, zoom);
+ }
+ logger.log(logger.HIGH, "Exiting thumnailHTMLReady()");
+ }
+
+
+
//**********************************************************
//**********************************************************
//* Online user actions
if (currentNoteGuid == null || currentNoteGuid.equals(""))
return;
if (currentNote.getUpdateSequenceNum() == 0) {
- setMessage("Note has never been synchronized.");
- QMessageBox.information(this, "Error", "This note has never been sent to Evernote, so there is no history.");
+ setMessage(tr("Note has never been synchronized."));
+ QMessageBox.information(this, tr("Error"), tr("This note has never been sent to Evernote, so there is no history."));
return;
}
- setMessage("Getting Note History");
+ setMessage(tr("Getting Note History"));
waitCursor(true);
Note currentOnlineNote = null;
versions = null;
setMessage("EDAMSystemException: " +e.getMessage());
return;
} catch (EDAMNotFoundException e) {
- setMessage("Note not found on server.");
+ setMessage(tr("Note not found on server."));
QMessageBox.information(this, "Error", "This note could not be found on Evernote's servers.");
return;
} catch (TException e) {
// If we've gotten this far, we have a good note.
if (historyWindow == null) {
- historyWindow = new OnlineNoteHistory(conn);
+ historyWindow = new OnlineNoteHistory(logger, conn);
historyWindow.historyCombo.activated.connect(this, "reloadHistoryWindow(String)");
historyWindow.restoreAsNew.clicked.connect(this, "restoreHistoryNoteAsNew()");
historyWindow.restore.clicked.connect(this, "restoreHistoryNote()");
loadHistoryWindowContent(currentOnlineNote);
historyWindow.load(versions);
- setMessage("History retrieved");
+ setMessage(tr("History retrieved"));
waitCursor(false);
historyWindow.exec();
}
int usn = 0;
for (int i=0; i<versions.size(); i++) {
- StringBuilder versionDate = new StringBuilder(simple.format(versions.get(i).getServiceUpdated()));
+ StringBuilder versionDate = new StringBuilder(simple.format(versions.get(i).getSaved()));
if (versionDate.toString().equals(selection))
index = i;
}
}
@SuppressWarnings("unused")
private void restoreHistoryNoteAsNew() {
- setMessage("Restoring as new note.");
+ setMessage(tr("Restoring as new note."));
duplicateNote(reloadHistoryWindow(historyWindow.historyCombo.currentText()));
- setMessage("Note has been restored as a new note.");
+ setMessage(tr("Note has been restored as a new note."));
}
@SuppressWarnings("unused")
private void restoreHistoryNote() {
- setMessage("Restoring note.");
+ setMessage(tr("Restoring note."));
Note n = reloadHistoryWindow(historyWindow.historyCombo.currentText());
conn.getNoteTable().expungeNote(n.getGuid(), true, false);
n.setActive(true);
listManager.addNote(n);
conn.getNoteTable().addNote(n, true);
refreshEvernoteNote(true);
- setMessage("Note has been restored.");
+ setMessage(tr("Note has been restored."));
}
//* XML Modifying methods
//**********************************************************
//**********************************************************
- // find the appropriate icon for an attachment
- private String findIcon(String appl) {
- logger.log(logger.HIGH, "Entering NeverNote.findIcon");
- appl = appl.toLowerCase();
- File f = new File(Global.getDirectoryPath()+"images"+File.separator +appl +".png");
- if (f.exists())
- return appl+".png";
- logger.log(logger.HIGH, "Leaving NeverNote.findIcon");
- return "attachment.png";
- }
- // Modify the en-media tag into an attachment
- private void modifyApplicationTags(QDomDocument doc, QDomElement docElem, QDomElement enmedia, QDomAttr hash, String appl) {
- logger.log(logger.HIGH, "Entering NeverNote.modifyApplicationTags");
- if (appl.equalsIgnoreCase("vnd.evernote.ink"))
- inkNote = true;
- String resGuid = conn.getNoteTable().noteResourceTable.getNoteResourceGuidByHashHex(currentNote.getGuid(), hash.value());
- Resource r = conn.getNoteTable().noteResourceTable.getNoteResource(resGuid, false);
- if (r == null || r.getData() == null)
- resourceErrorMessage();
- if (r!= null) {
- if (r.getData()!=null) {
- // Did we get a generic applicaiton? Then look at the file name to
- // try and find a good application type for the icon
- if (appl.equalsIgnoreCase("octet-stream")) {
- if (r.getAttributes() != null && r.getAttributes().getFileName() != null) {
- String fn = r.getAttributes().getFileName();
- int pos = fn.lastIndexOf(".");
- if (pos > -1) {
- appl = fn.substring(pos+1);
- }
- }
- }
-
- String fileDetails = null;
- if (r.getAttributes() != null && r.getAttributes().getFileName() != null && !r.getAttributes().getFileName().equals(""))
- fileDetails = r.getAttributes().getFileName();
- String contextFileName;
- String pathPrefix = Global.currentDir;
- pathPrefix = Global.getDirectoryPath()+"res/";
- if (fileDetails != null && !fileDetails.equals("")) {
- enmedia.setAttribute("href", "nnres://" +r.getGuid() +Global.attachmentNameDelimeter +fileDetails);
- contextFileName = Global.currentDir +"res/" +r.getGuid() +Global.attachmentNameDelimeter +fileDetails;
- } else {
- enmedia.setAttribute("href", "nnres://" +r.getGuid() +Global.attachmentNameDelimeter +appl);
- contextFileName = pathPrefix+r.getGuid() +Global.attachmentNameDelimeter +appl;
- }
- contextFileName = contextFileName.replace("\\", "/");
- enmedia.setAttribute("onContextMenu", "window.jambi.resourceContextMenu('" +contextFileName +"');");
- if (fileDetails == null || fileDetails.equals(""))
- fileDetails = "";
- enmedia.setAttribute("en-tag", "en-media");
- enmedia.setAttribute("guid", r.getGuid());
- enmedia.setTagName("a");
- QDomElement newText = doc.createElement("img");
- boolean goodPreview = false;
- String filePath = "";
- if (appl.equalsIgnoreCase("pdf") && Global.pdfPreview()) {
- String fileName;
- Resource res = conn.getNoteTable().noteResourceTable.getNoteResource(r.getGuid(), true);
- if (res.getAttributes() != null &&
- res.getAttributes().getFileName() != null &&
- !res.getAttributes().getFileName().trim().equals(""))
- fileName = res.getGuid()+Global.attachmentNameDelimeter+res.getAttributes().getFileName();
- else
- fileName = res.getGuid()+".pdf";
- QFile file = new QFile(Global.getDirectoryPath() +"res/"+fileName);
- QFile.OpenMode mode = new QFile.OpenMode();
- mode.set(QFile.OpenModeFlag.WriteOnly);
- file.open(mode);
- QDataStream out = new QDataStream(file);
- Resource resBinary = conn.getNoteTable().noteResourceTable.getNoteResource(res.getGuid(), true);
- QByteArray binData = new QByteArray(resBinary.getData().getBody());
- resBinary = null;
- out.writeBytes(binData.toByteArray());
- file.close();
- PDFPreview pdfPreview = new PDFPreview();
- goodPreview = pdfPreview.setupPreview(file.fileName(), appl,0);
- if (goodPreview) {
- QDomElement span = doc.createElement("span");
- QDomElement table = doc.createElement("table");
- span.setAttribute("pdfNavigationTable", "true");
- QDomElement tr = doc.createElement("tr");
- QDomElement td = doc.createElement("td");
- QDomElement left = doc.createElement("img");
- left.setAttribute("onMouseDown", "window.jambi.nextPage('" +file.fileName() +"')");
- left.setAttribute("onMouseDown", "window.jambi.nextPage('" +file.fileName() +"')");
- left.setAttribute("onMouseOver", "style.cursor='hand'");
- QDomElement right = doc.createElement("img");
- right.setAttribute("onMouseDown", "window.jambi.nextPage('" +file.fileName() +"')");
- left.setAttribute("onMouseDown", "window.jambi.previousPage('" +file.fileName() +"')");
- left.setAttribute("src", Global.currentDir+"images/small_left.png");
- right.setAttribute("src", Global.currentDir+"images/small_right.png");
- right.setAttribute("onMouseOver", "style.cursor='hand'");
-
- table.appendChild(tr);
- tr.appendChild(td);
- td.appendChild(left);
- td.appendChild(right);
- span.appendChild(table);
- enmedia.parentNode().insertBefore(span, enmedia);
- }
- filePath = fileName+".png";
- }
- String icon = findIcon(appl);
- if (icon.equals("attachment.png"))
- icon = findIcon(fileDetails.substring(fileDetails.indexOf(".")+1));
- newText.setAttribute("src", Global.getDirectoryPath()+"images"+File.separator +icon);
- if (goodPreview) {
- newText.setAttribute("src", Global.getDirectoryPath()+"res/"+filePath);
- newText.setAttribute("style", "border-style:solid; border-color:green; padding:0.5mm 0.5mm 0.5mm 0.5mm;");
- }
- newText.setAttribute("title", fileDetails);
- enmedia.removeChild(enmedia.firstChild());
-
- enmedia.appendChild(newText);
- }
- }
- logger.log(logger.HIGH, "Leaving NeverNote.modifyApplicationTags");
- }
- // Modify the en-to tag into an input field
- private void modifyTodoTags(QDomElement todo) {
- logger.log(logger.HIGH, "Entering NeverNote.modifyTodoTags");
- todo.setAttribute("type", "checkbox");
- String checked = todo.attribute("checked");
- todo.removeAttribute("checked");
- if (checked.equalsIgnoreCase("true"))
- todo.setAttribute("checked", "");
- else
- todo.setAttribute("unchecked","");
- todo.setAttribute("value", checked);
- todo.setAttribute("onClick", "value=checked;window.jambi.contentChanged(); ");
- todo.setTagName("input");
- logger.log(logger.HIGH, "Leaving NeverNote.modifyTodoTags");
- }
- // Modify any cached todo tags that may have changed
- private String modifyCachedTodoTags(String note) {
- logger.log(logger.HIGH, "Entering NeverNote.modifyCachedTodoTags");
- StringBuffer html = new StringBuffer(note);
- for (int i=html.indexOf("<input", 0); i>-1; i=html.indexOf("<input", i)) {
- int endPos =html.indexOf(">",i+1);
- String input = html.substring(i,endPos);
- if (input.indexOf("value=\"true\"") > 0)
- input = input.replace("unchecked=\"\"", "checked=\"\"");
- else
- input = input.replace("checked=\"\"", "unchecked=\"\"");
- html.replace(i, endPos, input);
- i++;
- }
- logger.log(logger.HIGH, "Leaving NeverNote.modifyCachedTodoTags");
- return html.toString();
- }
- // Modify the en-media tag into an image tag so it can be displayed.
- private void modifyImageTags(QDomElement docElem, QDomElement enmedia, QDomAttr hash) {
- logger.log(logger.HIGH, "Entering NeverNote.modifyImageTags");
- String type = enmedia.attribute("type");
- if (type.startsWith("image/"))
- type = "."+type.substring(6);
- else
- type="";
-
- String resGuid = conn.getNoteTable().noteResourceTable.getNoteResourceGuidByHashHex(currentNoteGuid, hash.value());
- QFile tfile = new QFile(Global.getDirectoryPath()+"res"+File.separator +resGuid+type);
- if (!tfile.exists()) {
- Resource r = null;
- if (resGuid != null)
- r = conn.getNoteTable().noteResourceTable.getNoteResource(resGuid,true);
- if (r==null || r.getData() == null || r.getData().getBody().length == 0)
- resourceErrorMessage();
- if (r!= null && r.getData() != null && r.getData().getBody().length > 0) {
- tfile.open(new QIODevice.OpenMode(QIODevice.OpenModeFlag.WriteOnly));
- QByteArray binData = new QByteArray(r.getData().getBody());
- tfile.write(binData);
- tfile.close();
- enmedia.setAttribute("src", QUrl.fromLocalFile(tfile.fileName()).toString());
- enmedia.setAttribute("en-tag", "en-media");
- enmedia.setNodeValue("");
- enmedia.setAttribute("guid", r.getGuid());
- enmedia.setTagName("img");
- }
- }
- enmedia.setAttribute("src", QUrl.fromLocalFile(tfile.fileName()).toString());
- enmedia.setAttribute("en-tag", "en-media");
- enmedia.setAttribute("onContextMenu", "window.jambi.imageContextMenu('" +tfile.fileName() +"');");
- enmedia.setNodeValue("");
- enmedia.setAttribute("guid", resGuid);
- enmedia.setTagName("img");
-
- logger.log(logger.HIGH, "Leaving NeverNote.modifyImageTags");
- }
- // Modify tags from Evernote specific things to XHTML tags.
- private QDomDocument modifyTags(QDomDocument doc) {
- logger.log(logger.HIGH, "Entering NeverNote.modifyTags");
- if (tempFiles == null)
- tempFiles = new ArrayList<QTemporaryFile>();
- tempFiles.clear();
- QDomElement docElem = doc.documentElement();
-
- // Modify en-media tags
- QDomNodeList anchors = docElem.elementsByTagName("en-media");
- int enMediaCount = anchors.length();
- for (int i=enMediaCount-1; i>=0; i--) {
- QDomElement enmedia = anchors.at(i).toElement();
- if (enmedia.hasAttribute("type")) {
- QDomAttr attr = enmedia.attributeNode("type");
- QDomAttr hash = enmedia.attributeNode("hash");
- String[] type = attr.nodeValue().split("/");
- String appl = type[1];
-
- if (type[0] != null) {
- if (type[0].equals("image")) {
- modifyImageTags(docElem, enmedia, hash);
- }
- if (!type[0].equals("image")) {
- modifyApplicationTags(doc, docElem, enmedia, hash, appl);
- }
- }
- }
- }
-
- // Modify todo tags
- anchors = docElem.elementsByTagName("en-todo");
- int enTodoCount = anchors.length();
- for (int i=enTodoCount-1; i>=0; i--) {
- QDomElement enmedia = anchors.at(i).toElement();
- modifyTodoTags(enmedia);
- }
-
- // Modify en-crypt tags
- anchors = docElem.elementsByTagName("en-crypt");
- int enCryptLen = anchors.length();
- for (int i=enCryptLen-1; i>=0; i--) {
- QDomElement enmedia = anchors.at(i).toElement();
- enmedia.setAttribute("contentEditable","false");
- enmedia.setAttribute("src", Global.getDirectoryPath()+"images/encrypt.png");
- enmedia.setAttribute("en-tag","en-crypt");
- enmedia.setAttribute("alt", enmedia.text());
- Global.cryptCounter++;
- enmedia.setAttribute("id", "crypt"+Global.cryptCounter.toString());
- String encryptedText = enmedia.text();
-
- // If the encryption string contains crlf at the end, remove them because they mess up the javascript.
- if (encryptedText.endsWith("\n"))
- encryptedText = encryptedText.substring(0,encryptedText.length()-1);
- if (encryptedText.endsWith("\r"))
- encryptedText = encryptedText.substring(0,encryptedText.length()-1);
-
- // Add the commands
- String hint = enmedia.attribute("hint");
- hint = hint.replace("'","'");
- enmedia.setAttribute("onClick", "window.jambi.decryptText('crypt"+Global.cryptCounter.toString()+"', '"+encryptedText+"', '"+hint+"');");
- enmedia.setAttribute("onMouseOver", "style.cursor='hand'");
- enmedia.setTagName("img");
- enmedia.removeChild(enmedia.firstChild()); // Remove the actual encrypted text
- }
-
- logger.log(logger.HIGH, "Leaving NeverNote.modifyTags");
- return doc;
- }
- // Rebuild the note HTML to something usable
- private String rebuildNoteHTML(String noteGuid, String note) {
- logger.log(logger.HIGH, "Entering NeverNote.rebuildNoteHTML");
- logger.log(logger.EXTREME, "Note guid: " +noteGuid);
- logger.log(logger.EXTREME, "Note Text:" +note);
- QDomDocument doc = new QDomDocument();
- QDomDocument.Result result = doc.setContent(note);
- if (!result.success) {
- logger.log(logger.MEDIUM, tr("Parse error when rebuilding HTML"));
- logger.log(logger.MEDIUM, tr("Note guid: " +noteGuid));
- logger.log(logger.EXTREME, tr("Start of unmodified note HTML"));
- logger.log(logger.EXTREME, note);
- logger.log(logger.EXTREME, tr("End of unmodified note HTML"));
- return note;
- }
-
- if (tempFiles == null)
- tempFiles = new ArrayList<QTemporaryFile>();
- tempFiles.clear();
-
- doc = modifyTags(doc);
- doc = addHilight(doc);
- QDomElement docElem = doc.documentElement();
- docElem.setTagName("Body");
-// docElem.setAttribute("bgcolor", "green");
- logger.log(logger.EXTREME, "Rebuilt HTML:");
- logger.log(logger.EXTREME, doc.toString());
- logger.log(logger.HIGH, "Leaving NeverNote.rebuildNoteHTML");
- // Fix the stupid problem where inserting an <img> tag after an <a> tag (which is done
- // to get the <en-media> application tag to work properly) causes spaces to be inserted
- // between the <a> & <img>. This messes things up later. This is an ugly hack.
- StringBuffer html = new StringBuffer(doc.toString());
- for (int i=html.indexOf("<a en-tag=\"en-media\" ", 0); i>-1; i=html.indexOf("<a en-tag=\"en-media\" ", i)) {
- i=html.indexOf(">\n",i+1);
- int z = html.indexOf("<img",i);
- for (int j=z-1; j>i; j--)
- html.deleteCharAt(j);
- i=html.indexOf("/>", z+1);
- z = html.indexOf("</a>",i);
- for (int j=z-1; j>i+1; j--)
- html.deleteCharAt(j);
- }
- return html.toString();
- }
- // Scan and do hilighting of words
- private QDomDocument addHilight(QDomDocument doc) {
- EnSearch e = listManager.getEnSearch();
- if (e.hilightWords == null || e.hilightWords.size() == 0)
- return doc;
- XMLInsertHilight hilight = new XMLInsertHilight(doc, listManager.getEnSearch().hilightWords);
- return hilight.getDoc();
- }
-
// An error has happended fetching a resource. let the user know
private void resourceErrorMessage() {
if (inkNote)
"this note on the Evernote servers. Sorry."+
"\n\nP.S. You might want to re-synchronize to see if it corrects this problem.\nWho knows, you might get lucky."));
inkNote = true;
-//// browserWindow.setEnabled(false);
browserWindow.setReadOnly(true);
}
if (syncThreadsReady > 0) {
saveNoteIndexWidth();
+ saveNoteColumnPositions();
if (syncRunner.addWork("SYNC")) {
syncRunning = true;
syncRunner.syncNeeded = true;
}
@SuppressWarnings("unused")
private void syncThreadComplete(Boolean refreshNeeded) {
- setMessage("Finalizing Synchronization");
+ setMessage(tr("Finalizing Synchronization"));
syncThreadsReady++;
syncRunning = false;
syncRunner.syncNeeded = false;
synchronizeAnimationTimer.stop();
- noteIndexUpdated(true);
- synchronizeButton.setIcon(synchronizeAnimation.get(0));
+ synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
saveNote();
-// noteTableView.selectionModel().selectionChanged.disconnect(this, "noteTableSelection()");
+ if (currentNote == null) {
+ currentNote = conn.getNoteTable().getNote(currentNoteGuid, false, false, false, false, true);
+ }
+ listManager.setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());
+ noteIndexUpdated(false);
noteTableView.selectionModel().blockSignals(true);
scrollToGuid(currentNoteGuid);
noteTableView.selectionModel().blockSignals(false);
-// noteTableView.selectionModel().selectionChanged.connect(this, "noteTableSelection()");
-// indexRunner.setKeepRunning(Global.keepRunning);
-
- // Reload the unindexed table If the dbthread is dead, we are probably shutting down.
- if (!dbThread.isAlive())
- return;
- listManager.setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());
- for (int i=0; i<noteTableView.model.rowCount(); i++) {
- QModelIndex modelIndex = noteTableView.model.index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
- SortedMap<Integer, Object> ix = noteTableView.model.itemData(modelIndex);
- String tableGuid = (String)ix.values().toArray()[0];
- String synch = "true";
- for (int j=0; j<listManager.getUnsynchronizedNotes().size(); j++) {
- if (listManager.getUnsynchronizedNotes().get(j).equalsIgnoreCase(tableGuid)) {
- synch = "false";
- j = listManager.getUnsynchronizedNotes().size();
- }
- }
- noteTableView.model.setData(i, Global.noteTableSynchronizedPosition, synch);
- }
- }
refreshEvernoteNote(false);
scrollToGuid(currentNoteGuid);
- setMessage("Synchronization Complete");
+ waitCursor(false);
+ if (!syncRunner.error)
+ setMessage(tr("Synchronization Complete"));
+ else
+ setMessage(tr("Synchronization completed with errors. Please check the log for details."));
logger.log(logger.MEDIUM, "Sync complete.");
}
-// public void setSequenceDate(long t) {
-// Global.setSequenceDate(t);
-// }
public void saveUploadAmount(long t) {
Global.saveUploadAmount(t);
}
-// public void setUpdateSequenceNumber(int t) {
-// Global.setUpdateSequenceNumber(t);
-// }
public void saveUserInformation(User user) {
Global.saveUserInformation(user);
}
indexTimer.setInterval(indexTime);
}
if (indexRunning) {
- setMessage("Index completed.");
+ setMessage(tr("Index completed."));
logger.log(logger.LOW, "Indexing has completed.");
indexRunning = false;
indexTimer.setInterval(indexTime);
indexRunner.setIndexType(indexRunner.CONTENT);
indexRunner.addWork("CONTENT "+unindexedNote);
if (!indexRunning) {
- setMessage("Indexing notes.");
+ setMessage(tr("Indexing notes."));
logger.log(logger.LOW, "Beginning to index note contents.");
indexRunning = true;
}
logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
indexRunner.addWork(new String("RESOURCE "+unindexedResource));
if (!indexRunning) {
- setMessage("Indexing notes.");
+ setMessage(tr("Indexing notes."));
indexRunning = true;
}
logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
logger.log(logger.HIGH, "Entering NeverNote.toggleIndexing");
indexDisabled = !indexDisabled;
if (!indexDisabled)
- setMessage("Indexing is now enabled.");
+ setMessage(tr("Indexing is now enabled."));
else
- setMessage("Indexing is now disabled.");
+ setMessage(tr("Indexing is now disabled."));
menuBar.disableIndexing.setChecked(indexDisabled);
logger.log(logger.HIGH, "Leaving NeverNote.toggleIndexing");
}
if (!alive) {
tagDeadCount++;
if (tagDeadCount > MAX)
- QMessageBox.information(this, "A thread his died.", "It appears as the tag counter thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), tr("It appears as the tag counter thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
tagDeadCount=0;
alive = listManager.threadCheck(Global.notebookCounterThreadId);
if (!alive) {
notebookThreadDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the notebook counter thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), tr("It appears as the notebook counter thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
notebookThreadDeadCount=0;
alive = listManager.threadCheck(Global.trashCounterThreadId);
if (!alive) {
trashDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the trash counter thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), ("It appears as the trash counter thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
trashDeadCount = 0;
alive = listManager.threadCheck(Global.saveThreadId);
if (!alive) {
saveThreadDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the note saver thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), tr("It appears as the note saver thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
saveThreadDeadCount=0;
- if (!dbThread.isAlive()) {
- dbThreadDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the database thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
- } else
- dbThreadDeadCount=0;
-
if (!syncThread.isAlive()) {
syncThreadDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the synchronization thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), tr("It appears as the synchronization thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
syncThreadDeadCount=0;
if (!indexThread.isAlive()) {
indexThreadDeadCount++;
- QMessageBox.information(this, "A thread his died.", "It appears as the index thread has died. I recommend "+
- "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry.");
+ QMessageBox.information(this, tr("A thread his died."), tr("It appears as the index thread has died. I recommend "+
+ "checking stopping NeverNote, saving the logs for later viewing, and restarting. Sorry."));
} else
indexThreadDeadCount=0;
}
-
+ private void thumbnailTimer() {
+ if (Global.enableThumbnails() && conn.getNoteTable().getThumbnailNeededCount() > 1) {
+ thumbnailTimer.setInterval(10*1000);
+ thumbnailRunner.addWork("SCAN");
+ } else {
+ thumbnailTimer.setInterval(60*1000);
+ }
+ }
//**************************************************
//* Backup & Restore
QFileDialog fd = new QFileDialog(this);
fd.setFileMode(FileMode.AnyFile);
fd.setConfirmOverwrite(true);
- fd.setWindowTitle("Backup Database");
+ fd.setWindowTitle(tr("Backup Database"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptSave);
fd.setDirectory(System.getProperty("user.home"));
waitCursor(true);
- setMessage("Backing up database");
+ setMessage(tr("Backing up database"));
saveNote();
// conn.backupDatabase(Global.getUpdateSequenceNumber(), Global.getSequenceDate());
if (!fileName.endsWith(".nnex"))
fileName = fileName +".nnex";
noteWriter.exportData(fileName);
- setMessage("Database backup completed.");
+ setMessage(tr("Database backup completed."));
waitCursor(false);
}
@SuppressWarnings("unused")
private void databaseRestore() {
- if (QMessageBox.question(this, "Confirmation",
- "This is used to restore a database from backups.\n" +
+ if (QMessageBox.question(this, tr("Confirmation"),
+ tr("This is used to restore a database from backups.\n" +
"It is HIGHLY recommened that this only be used to populate\n" +
"an empty database. Restoring into a database that\n already has data" +
- " can cause problems.\n\nAre you sure you want to continue?",
+ " can cause problems.\n\nAre you sure you want to continue?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
QFileDialog fd = new QFileDialog(this);
fd.setFileMode(FileMode.ExistingFile);
fd.setConfirmOverwrite(true);
- fd.setWindowTitle("Restore Database");
+ fd.setWindowTitle(tr("Restore Database"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
fd.setDirectory(System.getProperty("user.home"));
waitCursor(true);
- setMessage("Restoring database");
+ setMessage(tr("Restoring database"));
ImportData noteReader = new ImportData(conn, true);
noteReader.importData(fd.selectedFiles().get(0));
listManager.loadNoteTitleColors();
refreshLists();
refreshEvernoteNote(true);
- setMessage("Database has been restored.");
+ setMessage(tr("Database has been restored."));
waitCursor(false);
}
@SuppressWarnings("unused")
QFileDialog fd = new QFileDialog(this);
fd.setFileMode(FileMode.AnyFile);
fd.setConfirmOverwrite(true);
- fd.setWindowTitle("Backup Database");
+ fd.setWindowTitle(tr("Backup Database"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptSave);
fd.setDirectory(System.getProperty("user.home"));
waitCursor(true);
- setMessage("Exporting Notes");
+ setMessage(tr("Exporting Notes"));
saveNote();
if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
if (!fileName.endsWith(".nnex"))
fileName = fileName +".nnex";
noteWriter.exportData(fileName);
- setMessage("Export completed.");
+ setMessage(tr("Export completed."));
waitCursor(false);
QFileDialog fd = new QFileDialog(this);
fd.setFileMode(FileMode.ExistingFile);
fd.setConfirmOverwrite(true);
- fd.setWindowTitle("Import Notes");
+ fd.setWindowTitle(tr("Import Notes"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
fd.setDirectory(System.getProperty("user.home"));
listManager.loadNoteTitleColors();
refreshLists();
refreshEvernoteNote(false);
- setMessage("Notes have been imported.");
+ setMessage(tr("Notes have been imported."));
waitCursor(false);
setMessage("Import completed.");
listManager.addNote(newNote);
conn.getNoteTable().addNote(newNote, true);
listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(listManager, newNote, true, -1);
+ noteTableView.insertRow(newNote, true, -1);
listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
listManager.countNotebookResults(listManager.getNoteIndex());
importedFiles.add(list.get(i).absoluteFilePath());
listManager.addNote(newNote);
conn.getNoteTable().addNote(newNote, true);
listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(listManager, newNote, true, -1);
+ noteTableView.insertRow(newNote, true, -1);
listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
listManager.countNotebookResults(listManager.getNoteIndex());
dir.remove(dir.at(i));
//**************************************************
private void externalFileEdited(String fileName) throws NoSuchAlgorithmException {
logger.log(logger.HIGH, "Entering exernalFileEdited");
-
- String dPath = Global.getDirectoryPath() + "res/";
- dPath = dPath.replace('\\', '/');
+
+ // Strip URL prefix and base dir path
+ String dPath = FileUtils.toForwardSlashedPath(Global.getFileManager().getResDirPath());
String name = fileName.replace(dPath, "");
int pos = name.lastIndexOf('.');
String guid = name;
byte[] hash = md.digest();
String newHash = Global.byteArrayToHexString(hash);
if (r.getNoteGuid().equalsIgnoreCase(currentNoteGuid)) {
- updateResourceContentHash(r.getGuid(), oldHash, newHash);
+ updateResourceContentHash(browserWindow, r.getGuid(), oldHash, newHash);
+ }
+ if (externalWindows.containsKey(r.getNoteGuid())) {
+ updateResourceContentHash(externalWindows.get(r.getNoteGuid()).getBrowserWindow(),
+ r.getGuid(), oldHash, newHash);
}
conn.getNoteTable().updateResourceContentHash(r.getNoteGuid(), oldHash, newHash);
Data data = r.getData();
browserWindow.getBrowser().triggerPageAction(WebAction.Reload);
}
+ if (externalWindows.containsKey(r.getNoteGuid())) {
+ QWebSettings.setMaximumPagesInCache(0);
+ QWebSettings.setObjectCacheCapacities(0, 0, 0);
+ externalWindows.get(r.getNoteGuid()).getBrowserWindow().getBrowser().triggerPageAction(WebAction.Reload);
+
+ }
+
logger.log(logger.HIGH, "Exiting externalFielEdited");
}
// This is a timer event that tries to save any external files that were edited. This
// If an attachment on the current note was edited, we need to update the current notes's hash
// Update a note content's hash. This happens if a resource is edited outside of NN
- public void updateResourceContentHash(String guid, String oldHash, String newHash) {
+ public void updateResourceContentHash(BrowserWindow browser, String guid, String oldHash, String newHash) {
int position = browserWindow.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=");
int endPos;
for (;position>-1;) {
- endPos = browserWindow.getContent().indexOf(">", position+1);
- String oldSegment = browserWindow.getContent().substring(position,endPos);
+ endPos = browser.getContent().indexOf(">", position+1);
+ String oldSegment = browser.getContent().substring(position,endPos);
int hashPos = oldSegment.indexOf("hash=\"");
int hashEnd = oldSegment.indexOf("\"", hashPos+7);
String hash = oldSegment.substring(hashPos+6, hashEnd);
if (hash.equalsIgnoreCase(oldHash)) {
String newSegment = oldSegment.replace(oldHash, newHash);
- String content = browserWindow.getContent().substring(0,position) +
+ String content = browser.getContent().substring(0,position) +
newSegment +
- browserWindow.getContent().substring(endPos);
- browserWindow.getBrowser().setContent(new QByteArray(content));;
+ browser.getContent().substring(endPos);
+ browser.getBrowser().setContent(new QByteArray(content));;
}
- position = browserWindow.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=", position+1);
+ position = browser.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=", position+1);
}
}
-
+ //*************************************************
+ //* Minimize to tray
+ //*************************************************
+ @Override
+ public void changeEvent(QEvent e) {
+ if (e.type() == QEvent.Type.WindowStateChange) {
+ if (isMinimized() && Global.showTrayIcon()) {
+ e.accept();
+ QTimer.singleShot(10, this, "hide()");
+ return;
+ }
+ if (isMaximized())
+ windowMaximized = true;
+ else
+ windowMaximized = false;
+ }
+ }
//*************************************************
//* Check database userid & passwords
//*************************************************
- public boolean databaseCheck(String url,String userid, String userPassword, String cypherPassword) {
+ private static boolean databaseCheck(String url,String userid, String userPassword, String cypherPassword) {
Connection connection;
try {
OSDN Git Service
