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.log4j.Level;
+import org.apache.log4j.Logger;
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.notestore.NoteFilter;
import com.evernote.edam.notestore.NoteVersionId;
import com.evernote.edam.type.Data;
+import com.evernote.edam.type.LinkedNotebook;
import com.evernote.edam.type.Note;
import com.evernote.edam.type.NoteAttributes;
import com.evernote.edam.type.Notebook;
+import com.evernote.edam.type.Publishing;
import com.evernote.edam.type.QueryFormat;
import com.evernote.edam.type.Resource;
import com.evernote.edam.type.SavedSearch;
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.QTranslator;
import com.trolltech.qt.core.QUrl;
import com.trolltech.qt.core.Qt;
+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.QIcon;
import com.trolltech.qt.gui.QImage;
import com.trolltech.qt.gui.QLabel;
-import com.trolltech.qt.gui.QListWidget;
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.QTextEdit;
import com.trolltech.qt.gui.QToolBar;
import com.trolltech.qt.gui.QTreeWidgetItem;
+import com.trolltech.qt.network.QNetworkAccessManager;
+import com.trolltech.qt.network.QNetworkReply;
+import com.trolltech.qt.network.QNetworkRequest;
import com.trolltech.qt.webkit.QWebPage.WebAction;
import com.trolltech.qt.webkit.QWebSettings;
-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 cx.fbn.nevernote.config.FileManager;
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.IgnoreSync;
+import cx.fbn.nevernote.dialog.LogFileDialog;
import cx.fbn.nevernote.dialog.LoginDialog;
import cx.fbn.nevernote.dialog.NotebookArchive;
import cx.fbn.nevernote.dialog.NotebookEdit;
import cx.fbn.nevernote.dialog.OnlineNoteHistory;
+import cx.fbn.nevernote.dialog.PublishNotebook;
import cx.fbn.nevernote.dialog.SavedSearchEdit;
+import cx.fbn.nevernote.dialog.SetIcon;
+import cx.fbn.nevernote.dialog.ShareNotebook;
+import cx.fbn.nevernote.dialog.StackNotebook;
import cx.fbn.nevernote.dialog.TagEdit;
import cx.fbn.nevernote.dialog.ThumbnailViewer;
+import cx.fbn.nevernote.dialog.UpgradeAvailableDialog;
import cx.fbn.nevernote.dialog.WatchFolder;
-import cx.fbn.nevernote.filters.EnSearch;
+import cx.fbn.nevernote.filters.FilterEditorNotebooks;
+import cx.fbn.nevernote.filters.FilterEditorTags;
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.gui.controls.QuotaProgressBar;
import cx.fbn.nevernote.sql.DatabaseConnection;
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.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{
QAction trayExitAction; // Exit the application
QAction trayShowAction; // toggle the show/hide action
QAction trayAddNoteAction; // Add a note from the system tray
+ QNetworkAccessManager versionChecker; // Used when checking for new versions
NotebookTreeWidget notebookTree; // List of notebooks
AttributeTreeWidget attributeTree; // List of note attributes
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
List<String> selectedNoteGUIDs; // List of selected notes
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
Note currentNote; // The currently viewed note
boolean noteDirty; // Has the note been changed?
- boolean inkNote; // if this is an ink note, it is read only
+ boolean inkNote; // if this is an ink note, it is read only
+ boolean readOnly; // Is this note read-only?
+
ListManager listManager; // DB runnable task
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
+ int synchronizeIconAngle; // Used to rotate sync icon
QAction printButton; // Print Button
QAction tagButton; // Tag edit button
QAction attributeButton; // Attribute information button
int tagDeadCount=0; // number of consecutive dead times for the tag thread
int trashDeadCount=0; // number of consecutive dead times for the trash thread
int saveThreadDeadCount=0; // number of consecutive dead times for the save thread
+ boolean disableTagThreadCheck=false;
+ boolean disableNotebookThreadCheck=false;
+ boolean disableTrashThreadCheck=false;
+ boolean disableSaveThreadCheck=false;
+ boolean disableSyncThreadCheck=false;
+ boolean disableIndexThreadCheck=false;
HashMap<String, String> noteCache; // Cash of note content
+ HashMap<String, Boolean> readOnlyCache; // List of cashe notes that are read-only
+ HashMap<String, Boolean> inkNoteCache; // List of cache notes that are ink notes
List<String> historyGuids; // GUIDs of previously viewed items
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.
+ List<QPixmap> syncIcons; // Array of icons used in sync animation
+ private boolean closeAction = false; // Used to say when to close or when to minimize
+ private static Logger log = Logger.getLogger(NeverNote.class);
+ private String saveLastPath; // last path we used
+ private final QTimer messageTimer; // Timer to clear the status message.
+
String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
//***************************************************************
//***************************************************************
// Application Constructor
+ @SuppressWarnings("static-access")
public NeverNote(DatabaseConnection dbConn) {
conn = dbConn;
+ if (conn.getConnection() == null) {
+ String msg = new String(tr("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, tr("Database Connection Error") ,msg);
+ System.exit(16);
+ }
thread().setPriority(Thread.MAX_PRIORITY);
logger = new ApplicationLogger("nevernote.log");
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();
logger.log(logger.EXTREME, "Starting GUI build");
- QTranslator qtTranslator = new QTranslator();
- qtTranslator.load("classpath:/translations/qt_" + QLocale.system().name() + ".qm");
- QApplication.instance().installTranslator(qtTranslator);
-
QTranslator nevernoteTranslator = new QTranslator();
- nevernoteTranslator.load("classpath:/translations/nevernote_"+QLocale.system().name()+ ".qm");
+ nevernoteTranslator.load(Global.getFileManager().getTranslateFilePath("nevernote_" + QLocale.system().name() + ".qm"));
QApplication.instance().installTranslator(nevernoteTranslator);
Global.originalPalette = QApplication.palette();
if (Global.useStandardPalette())
QApplication.setPalette(QApplication.style().standardPalette());
setWindowTitle("NeverNote");
-
+
mainLeftRightSplitter = new QSplitter();
setCentralWidget(mainLeftRightSplitter);
leftSplitter1 = new QSplitter();
listManager = new ListManager(conn, logger);
logger.log(logger.EXTREME, "Building index runners & timers");
- indexRunner = new IndexRunner("indexRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ indexRunner = new IndexRunner("indexRunner.log",
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
indexThread = new QThread(indexRunner, "Index Thread");
+ indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
indexThread.start();
synchronizeAnimationTimer = new QTimer();
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;
logger.log(logger.EXTREME, "Setting sync thread & timers");
syncThreadsReady=1;
- syncRunner = new SyncRunner("syncRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ syncRunner = new SyncRunner("syncRunner.log",
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
+ 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, "Starting thumnail thread");
+ pdfReadyQueue = new ArrayList<String>();
+ thumbnailRunner = new ThumbnailRunner("thumbnailRunner.log",
+ Global.getDatabaseUrl(), Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
+ 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(500*1000); // Thumbnail every minute
+ thumbnailTimer.start();
+
logger.log(logger.EXTREME, "Starting authentication timer");
authTimer = new QTimer();
authTimer.timeout.connect(this, "authTimer()");
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)");
logger.log(logger.EXTREME, "Starting external file monitor timer");
externalFileSaveTimer = new QTimer();
importFilesKeep = new ArrayList<String>();
externalFileSaveTimer.start();
- notebookTree = new NotebookTreeWidget();
+ notebookTree = new NotebookTreeWidget(conn);
attributeTree = new AttributeTreeWidget();
tagTree = new TagTreeWidget(conn);
savedSearchTree = new SavedSearchTreeWidget();
// Setup the browser window
noteCache = new HashMap<String,String>();
+ readOnlyCache = new HashMap<String, Boolean>();
+ inkNoteCache = new HashMap<String, Boolean>();
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();
tagTree.setDeleteAction(menuBar.tagDeleteAction);
tagTree.setEditAction(menuBar.tagEditAction);
tagTree.setAddAction(menuBar.tagAddAction);
+ tagTree.setIconAction(menuBar.tagIconAction);
tagTree.setVisible(Global.isWindowVisible("tagTree"));
tagTree.noteSignal.tagsAdded.connect(this, "tagsAdded(String, String)");
menuBar.hideTags.setChecked(Global.isWindowVisible("tagTree"));
notebookTree.setDeleteAction(menuBar.notebookDeleteAction);
notebookTree.setEditAction(menuBar.notebookEditAction);
notebookTree.setAddAction(menuBar.notebookAddAction);
+ notebookTree.setIconAction(menuBar.notebookIconAction);
+ notebookTree.setStackAction(menuBar.notebookStackAction);
+ notebookTree.setPublishAction(menuBar.notebookPublishAction);
+ notebookTree.setShareAction(menuBar.notebookShareAction);
notebookTree.setVisible(Global.isWindowVisible("notebookTree"));
notebookTree.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
+ notebookTree.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
+ notebookTree.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
menuBar.hideNotebooks.setChecked(Global.isWindowVisible("notebookTree"));
savedSearchTree.setAddAction(menuBar.savedSearchAddAction);
savedSearchTree.setEditAction(menuBar.savedSearchEditAction);
savedSearchTree.setDeleteAction(menuBar.savedSearchDeleteAction);
+ savedSearchTree.setIconAction(menuBar.savedSearchIconAction);
savedSearchTree.itemSelectionChanged.connect(this, "updateSavedSearchSelection()");
savedSearchTree.setVisible(Global.isWindowVisible("savedSearchTree"));
menuBar.hideSavedSearches.setChecked(Global.isWindowVisible("savedSearchTree"));
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();
trayExitAction = new QAction("Exit", this);
trayAddNoteAction = new QAction("Add Note", this);
- trayExitAction.triggered.connect(this, "close()");
+ trayExitAction.triggered.connect(this, "closeNeverNote()");
trayAddNoteAction.triggered.connect(this, "addNote()");
trayShowAction.triggered.connect(this, "trayToggleVisible()");
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;
+ menuBar.blockSignals(true);
+ menuBar.narrowListView.blockSignals(true);
+ menuBar.wideListView.blockSignals(true);
+ if (Global.getListView() == Global.View_List_Narrow) {
+ menuBar.narrowListView.setChecked(true);
+ }
+ else{
+ menuBar.wideListView.setChecked(true);
+ }
+ menuBar.blockSignals(false);
+ menuBar.narrowListView.blockSignals(false);
+ menuBar.wideListView.blockSignals(false);
+
+ if (Global.getListView() == Global.View_List_Wide) {
+ browserIndexSplitter.addWidget(noteTableView);
+ browserIndexSplitter.addWidget(browserWindow);
+ } else {
+ mainLeftRightSplitter.addWidget(noteTableView);
+ mainLeftRightSplitter.addWidget(browserWindow);
+ }
+
+ messageTimer = new QTimer();
+ messageTimer.timeout.connect(this, "clearMessage()");
+ messageTimer.setInterval(1000*15);
+ clearMessage();
+
int sortCol = Global.getSortColumn();
int sortOrder = Global.getSortOrder();
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+ if (Global.checkVersionUpgrade())
+ checkForUpdates();
}
-
-
+
// Main entry point
public static void main(String[] args) {
+ log.setLevel(Level.FATAL);
QApplication.initialize(args);
QPixmap pixmap = new QPixmap("classpath:cx/fbn/nevernote/icons/splash_logo.png");
QSplashScreen splash = new QSplashScreen(pixmap);
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();
+ Global.getFileManager().purgeResDirectory(true);
} catch (InitializationException e) {
// Fatal
NeverNote application = new NeverNote(dbConn);
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();
*/
private static DatabaseConnection setupDatabaseConnection() throws InitializationException {
ApplicationLogger logger = new ApplicationLogger("nevernote-database.log");
- DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
-
+
+ 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) {
Global.getDatabaseUserPassword(), Global.cipherPassword);
}
}
- return dbConn;
+ DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(),
+ Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword, 0);
+ 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, tr("Are you sure"),
+ tr("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;
}
private static void initializeGlobalSettings(String[] args) throws InitializationException {
- StartupConfig startupConfig = new 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);
- }
+ 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
public void closeEvent(QCloseEvent event) {
+ if (Global.minimizeOnClose() && !closeAction && Global.showTrayIcon()) {
+ event.ignore();
+ hide();
+ return;
+ }
logger.log(logger.HIGH, "Entering NeverNote.closeEvent");
waitCursor(true);
}
saveNote();
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(tr("Performing synchronization before closing."));
+ syncRunner.syncNeeded = true;
syncRunner.addWork("SYNC");
+ syncRunner.addWork("STOP");
+ } else {
+ syncRunner.addWork("STOP");
+ syncRunner.keepRunning = false;
}
setMessage("Closing Program.");
threadMonitorTimer.stop();
- syncRunner.addWork("STOP");
+ thumbnailRunner.addWork("STOP");
indexRunner.addWork("STOP");
saveNote();
listManager.stop();
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);
Global.keepRunning = false;
try {
logger.log(logger.MEDIUM, "Waiting for indexThread to stop");
- indexRunner.thread().join(50);
- logger.log(logger.MEDIUM, "Index thread has stopped");
+ if (indexRunner.thread().isAlive())
+ indexRunner.thread().join(50);
+ if (!indexRunner.thread().isAlive())
+ logger.log(logger.MEDIUM, "Index thread has stopped");
+ else {
+ logger.log(logger.MEDIUM, "Index thread still running - interrupting");
+ indexRunner.thread().interrupt();
+ }
} catch (InterruptedException e1) {
e1.printStackTrace();
}
+
+ syncRunner.addWork("STOP");
if (!syncRunner.isIdle()) {
try {
logger.log(logger.MEDIUM, "Waiting for syncThread to stop");
+ System.out.println(tr("Synchronizing. Please be patient."));
syncThread.join();
logger.log(logger.MEDIUM, "Sync thread has stopped");
} catch (InterruptedException e1) {
}
}
+ if (encryptOnShutdown) {
+ encryptOnShutdown();
+ }
+ if (decryptOnShutdown) {
+ decryptOnShutdown();
+ }
+ try {
+ Global.getFileManager().purgeResDirectory(false);
+ } catch (InitializationException e) {
+ System.out.println(tr("Empty res directory purge failed"));
+ e.printStackTrace();
+ }
logger.log(logger.HIGH, "Leaving NeverNote.closeEvent");
}
+ @SuppressWarnings("unused")
+ private void closeNeverNote() {
+ closeAction = true;
+ close();
+ }
public void setMessage(String s) {
logger.log(logger.HIGH, "Entering NeverNote.setMessage");
+
+ statusBar.show();
logger.log(logger.HIGH, "Message: " +s);
statusBar.showMessage(s);
emitLog.add(s);
+
+
+ messageTimer.stop();
+ messageTimer.setSingleShot(true);
+ messageTimer.start();
+
+
logger.log(logger.HIGH, "Leaving NeverNote.setMessage");
}
+
+ private void clearMessage() {
+ statusBar.clearMessage();
+ statusBar.hide();
+ }
private void waitCursor(boolean wait) {
- if (wait)
- QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.WaitCursor));
- else
- QApplication.restoreOverrideCursor();
+ if (wait) {
+ if (QApplication.overrideCursor() == null)
+ QApplication.setOverrideCursor(new QCursor(Qt.CursorShape.WaitCursor));
+ }
+ else {
+ while (QApplication.overrideCursor() != null)
+ QApplication.restoreOverrideCursor();
+ }
}
private void setupIndexListeners() {
- indexRunner.noteSignal.noteIndexed.connect(this, "indexThreadComplete(String)");
- indexRunner.resourceSignal.resourceIndexed.connect(this, "indexThreadComplete(String)");
-// indexRunner.threadSignal.indexNeeded.connect(listManager, "setIndexNeeded(String, String, Boolean)");
+// indexRunner.noteSignal.noteIndexed.connect(this, "indexThreadComplete(String)");
+// indexRunner.resourceSignal.resourceIndexed.connect(this, "indexThreadComplete(String)");
+ indexRunner.signal.indexStarted.connect(this, "indexStarted()");
+ indexRunner.signal.indexFinished.connect(this, "indexComplete()");
}
private void setupSyncSignalListeners() {
syncRunner.tagSignal.listChanged.connect(this, "tagIndexUpdated()");
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.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
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.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
- browserWindow.noteSignal.createdDateChanged.connect(listManager, "updateNoteCreatedDate(String, QDateTime)");
- browserWindow.noteSignal.alteredDateChanged.connect(listManager, "updateNoteAlteredDate(String, QDateTime)");
- browserWindow.noteSignal.subjectDateChanged.connect(listManager, "updateNoteSubjectDate(String, QDateTime)");
- browserWindow.noteSignal.authorChanged.connect(listManager, "updateNoteAuthor(String, String)");
- browserWindow.noteSignal.geoChanged.connect(listManager, "updateNoteGeoTag(String, Double,Double,Double)");
- browserWindow.noteSignal.geoChanged.connect(this, "setNoteDirty()");
- browserWindow.noteSignal.sourceUrlChanged.connect(listManager, "updateNoteSourceUrl(String, String)");
- browserWindow.focusLost.connect(this, "saveNote()");
- browserWindow.resourceSignal.contentChanged.connect(this, "externalFileEdited(String)");
+ setupBrowserWindowListeners(browserWindow, 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)");
+ }
//***************************************************************
//***************************************************************
@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();
+ indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
if (Global.showTrayIcon())
trayIcon.show();
else
trayIcon.hide();
showColumns();
if (menuBar.showEditorBar.isChecked())
- showEditorButtons();
+ showEditorButtons(browserWindow);
// Reset the save timer
if (Global.getAutoSaveInterval() > 0)
// if (!dateFormat.equals(Global.getDateFormat()) ||
// !timeFormat.equals(Global.getTimeFormat())) {
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.clear();
noteIndexUpdated(true);
// }
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.getFileManager().getQssDirPath("default.qss");
+ String fileName = Global.getFileManager().getQssDirPathUser("default.qss");
+ fileName = Global.getFileManager().getQssDirPath("default.qss");
QFile file = new QFile(fileName);
+
+ // If a user default.qss doesn't exist, we use the one shipped with NeverNote
+ if (!file.exists()) {
+ fileName = Global.getFileManager().getQssDirPath("default.qss");
+ 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.itemClicked.connect(this, "notebookTreeSelection()");
+ notebookTree.selectionSignal.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
menuBar.noteRestoreAction.setVisible(false);
menuBar.notebookEditAction.setEnabled(true);
menuBar.notebookDeleteAction.setEnabled(true);
+ menuBar.notebookPublishAction.setEnabled(true);
+ menuBar.notebookShareAction.setEnabled(true);
+ menuBar.notebookIconAction.setEnabled(true);
+ menuBar.notebookStackAction.setEnabled(true);
List<QTreeWidgetItem> selections = notebookTree.selectedItems();
- QTreeWidgetItem currentSelection;
selectedNotebookGUIDs.clear();
- if (!Global.mimicEvernoteInterface) {
- for (int i=0; i<selections.size(); i++) {
- currentSelection = selections.get(i);
- selectedNotebookGUIDs.add(currentSelection.text(2));
- }
-
-
- // There is the potential for no notebooks to be selected if this
- // happens then we make it look like all notebooks were selecetd.
- // If that happens, just select the "all notebooks"
- selections = notebookTree.selectedItems();
- if (selections.size()==0) {
- selectedNotebookGUIDs.clear();
- menuBar.notebookEditAction.setEnabled(false);
- menuBar.notebookDeleteAction.setEnabled(false);
- }
+ String guid = "";
+ String stackName = "";
+ if (selections.size() > 0) {
+ guid = (selections.get(0).text(2));
+ stackName = selections.get(0).text(0);
+ }
+ if (!Global.mimicEvernoteInterface) {
+ // If no notebooks are selected, we make it look like the "all notebooks" one was selected
+ if (selections.size()==0) {
+ selectedNotebookGUIDs.clear();
+ for (int i=0; i < listManager.getNotebookIndex().size(); i++) {
+ selectedNotebookGUIDs.add(listManager.getNotebookIndex().get(i).getGuid());
+ }
+ menuBar.notebookEditAction.setEnabled(false);
+ menuBar.notebookDeleteAction.setEnabled(false);
+ menuBar.notebookStackAction.setEnabled(false);
+ menuBar.notebookIconAction.setEnabled(false);
+ }
+ }
+ if (!guid.equals("") && !guid.equals("STACK")) {
+ selectedNotebookGUIDs.add(guid);
+ menuBar.notebookIconAction.setEnabled(true);
} else {
- String guid = "";
- if (selections.size() > 0)
- guid = (selections.get(0).text(2));
- if (!guid.equals(""))
- selectedNotebookGUIDs.add(guid);
+ menuBar.notebookIconAction.setEnabled(true);
+ for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
+ Notebook book = listManager.getNotebookIndex().get(j);
+ if (book.getStack() != null && book.getStack().equalsIgnoreCase(stackName))
+ selectedNotebookGUIDs.add(book.getGuid());
+ }
}
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--) {
}
// Edit an existing notebook
@SuppressWarnings("unused")
+ private void stackNotebook() {
+ logger.log(logger.HIGH, "Entering NeverNote.stackNotebook");
+ StackNotebook edit = new StackNotebook();
+
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ for (int i=0; i<selections.size(); i++) {
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+ if (guid.equalsIgnoreCase("")) {
+ QMessageBox.critical(this, tr("Unable To Stack") ,tr("You can't stack the \"All Notebooks\" item."));
+ return;
+ }
+ if (guid.equalsIgnoreCase("STACK")) {
+ QMessageBox.critical(this, tr("Unable To Stack") ,tr("You can't stack a stack."));
+ return;
+ }
+ }
+
+ edit.setStackNames(conn.getNotebookTable().getAllStackNames());
+
+
+ edit.exec();
+
+ if (!edit.okPressed())
+ return;
+
+ String stack = edit.getStackName();
+
+ for (int i=0; i<selections.size(); i++) {
+ currentSelection = selections.get(i);
+ String guid = currentSelection.text(2);
+ listManager.updateNotebookStack(guid, stack);
+ }
+ notebookIndexUpdated();
+ logger.log(logger.HIGH, "Leaving NeverNote.stackNotebook");
+ }
+ // Edit an existing notebook
+ @SuppressWarnings("unused")
private void editNotebook() {
logger.log(logger.HIGH, "Entering NeverNote.editNotebook");
NotebookEdit edit = new NotebookEdit();
- 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);
+ if (!guid.equalsIgnoreCase("STACK")) {
+ edit.setTitle(tr("Edit Notebook"));
+ edit.setNotebooks(listManager.getNotebookIndex());
+ edit.setLocalCheckboxEnabled(false);
+ 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();
+ }
+ }
+ } else {
+ edit.setTitle(tr("Edit Stack"));
+ edit.setStacks(conn.getNotebookTable().getAllStackNames());
+ edit.hideLocalCheckbox();
+ edit.hideDefaultCheckbox();
+ }
+
edit.exec();
if (!edit.okPressed())
return;
- String guid = currentSelection.text(2);
+
+ if (guid.equalsIgnoreCase("STACK")) {
+ conn.getNotebookTable().renameStacks(currentSelection.text(0), edit.getNotebook());
+ for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
+ if (listManager.getNotebookIndex().get(j).getStack() != null &&
+ listManager.getNotebookIndex().get(j).getStack().equalsIgnoreCase(currentSelection.text(0)))
+ listManager.getNotebookIndex().get(j).setStack(edit.getNotebook());
+ }
+ conn.getNotebookTable().renameStacks(currentSelection.text(0), edit.getNotebook());
+ currentSelection.setText(0, edit.getNotebook());
+ return;
+ }
+
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);
+ if (conn.getNotebookTable().isLinked(listManager.getNotebookIndex().get(i).getGuid())) {
+ LinkedNotebook linkedNotebook = conn.getLinkedNotebookTable().getByNotebookGuid(listManager.getNotebookIndex().get(i).getGuid());
+ linkedNotebook.setShareName(edit.getNotebook());
+ conn.getLinkedNotebookTable().updateNotebook(linkedNotebook, true);
+ }
i=listManager.getNotebookIndex().size();
}
}
nbooks.add(listManager.getNotebookIndex().get(i));
}
- browserWindow.setNotebookList(nbooks);
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
+ browserWindow.setNotebookList(filteredBooks);
+ Iterator<String> set = externalWindows.keySet().iterator();
+ while(set.hasNext())
+ externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
logger.log(logger.HIGH, "Leaving NeverNote.editNotebook");
}
+ // Publish a notebook
+ @SuppressWarnings("unused")
+ private void publishNotebook() {
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+
+ if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
+ return;
+
+ Notebook n = null;
+ int position = 0;
+ for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
+ if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
+ n = listManager.getNotebookIndex().get(i);
+ position = i;
+ i = listManager.getNotebookIndex().size();
+ }
+ }
+ if (n == null)
+ return;
+
+ PublishNotebook publish = new PublishNotebook(Global.username, Global.getServer(), n);
+ publish.exec();
+
+ if (!publish.okClicked())
+ return;
+
+ Publishing p = publish.getPublishing();
+ boolean isPublished = !publish.isStopPressed();
+ conn.getNotebookTable().setPublishing(n.getGuid(), isPublished, p);
+ n.setPublished(isPublished);
+ n.setPublishing(p);
+ listManager.getNotebookIndex().set(position, n);
+ notebookIndexUpdated();
+ }
+ // Publish a notebook
+ @SuppressWarnings("unused")
+ private void shareNotebook() {
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+
+ if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
+ return;
+
+ Notebook n = null;;
+ for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
+ if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
+ n = listManager.getNotebookIndex().get(i);
+ i = listManager.getNotebookIndex().size();
+ }
+ }
+
+ String authToken = null;
+ if (syncRunner.isConnected)
+ authToken = syncRunner.authToken;
+ ShareNotebook share = new ShareNotebook(n.getName(), conn, n, syncRunner);
+ share.exec();
+
+ }
+
// Delete an existing notebook
@SuppressWarnings("unused")
private void deleteNotebook() {
logger.log(logger.HIGH, "Entering NeverNote.deleteNotebook");
+ boolean stacksFound = false;
+ boolean notebooksFound = false;
boolean assigned = false;
// Check if any notes have this notebook
List<QTreeWidgetItem> selections = notebookTree.selectedItems();
QTreeWidgetItem currentSelection;
currentSelection = selections.get(i);
String guid = currentSelection.text(2);
- for (int j=0; j<listManager.getNoteIndex().size(); j++) {
- String noteGuid = listManager.getNoteIndex().get(j).getNotebookGuid();
- if (noteGuid.equals(guid)) {
- assigned = true;
- j=listManager.getNoteIndex().size();
- i=selections.size();
+ if (!guid.equalsIgnoreCase("STACK")) {
+ notebooksFound = true;
+ for (int j=0; j<listManager.getNoteIndex().size(); j++) {
+ String noteGuid = listManager.getNoteIndex().get(j).getNotebookGuid();
+ if (noteGuid.equals(guid)) {
+ assigned = true;
+ j=listManager.getNoteIndex().size();
+ i=selections.size();
+ }
}
+ } else {
+ stacksFound = true;
}
}
if (assigned) {
}
// If all notebooks are clear, verify the delete
- if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected notebooks?"),
+ String msg1 = new String(tr("Delete selected notebooks?"));
+ String msg2 = new String(tr("Remove selected stacks (notebooks will not be deleted)?"));
+ String msg3 = new String(tr("Delete selected notebooks & remove stacks? Notebooks under the stacks are" +
+ " not deleted unless selected?"));
+ String msg = "";
+ if (stacksFound && notebooksFound)
+ msg = msg3;
+ if (!stacksFound && notebooksFound)
+ msg = msg1;
+ if (stacksFound && !notebooksFound)
+ msg = msg2;
+ if (QMessageBox.question(this, tr("Confirmation"), msg,
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
QTreeWidgetItem currentSelection;
currentSelection = selections.get(i);
String guid = currentSelection.text(2);
- conn.getNotebookTable().expungeNotebook(guid, true);
- listManager.deleteNotebook(guid);
+ if (currentSelection.text(2).equalsIgnoreCase("STACK")) {
+ conn.getNotebookTable().renameStacks(currentSelection.text(0), "");
+ listManager.renameStack(currentSelection.text(0), "");
+ } else {
+ conn.getNotebookTable().expungeNotebook(guid, true);
+ listManager.deleteNotebook(guid);
+ }
}
-// 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());
+
+ notebookIndexUpdated();
+// notebookTreeSelection();
+// notebookTree.load(listManager.getNotebookIndex(), listManager.getLocalNotebooks());
+// listManager.countNotebookResults(listManager.getNoteIndex());
logger.log(logger.HIGH, "Entering NeverNote.deleteNotebook");
}
// A note's notebook has been updated
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;
}
}
listManager.loadNotesIndex();
notebookIndexUpdated();
noteIndexUpdated(false);
+ reloadTagTree(true);
// noteIndexUpdated(false);
// Build a list of non-closed notebooks
if (!found)
nbooks.add(listManager.getNotebookIndex().get(i));
}
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
+ browserWindow.setNotebookList(filteredBooks);
+
+ // Update any external windows
+ Iterator<String> set = externalWindows.keySet().iterator();
+ while(set.hasNext())
+ externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
+
waitCursor(false);
- browserWindow.setNotebookList(nbooks);
}
+ // Change the notebook's icon
+ @SuppressWarnings("unused")
+ private void setNotebookIcon() {
+ boolean stackSelected = false;
+ boolean allNotebookSelected = false;
+
+ QTreeWidgetItem currentSelection;
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ if (selections.size() == 0)
+ return;
+
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+ if (guid.equalsIgnoreCase(""))
+ allNotebookSelected = true;
+ if (guid.equalsIgnoreCase("STACK"))
+ stackSelected = true;
+ QIcon currentIcon = currentSelection.icon(0);
+ QIcon icon;
+ SetIcon dialog;
+
+ if (!stackSelected && !allNotebookSelected) {
+ icon = conn.getNotebookTable().getIcon(guid);
+ if (icon == null) {
+ dialog = new SetIcon(currentIcon, saveLastPath);
+ dialog.setUseDefaultIcon(true);
+ } else {
+ dialog = new SetIcon(icon, saveLastPath);
+ dialog.setUseDefaultIcon(false);
+ }
+ } else {
+ if (stackSelected) {
+ icon = conn.getSystemIconTable().getIcon(currentSelection.text(0), "STACK");
+ } else {
+ icon = conn.getSystemIconTable().getIcon(currentSelection.text(0), "ALLNOTEBOOK");
+ }
+ if (icon == null) {
+ dialog = new SetIcon(currentIcon, saveLastPath);
+ dialog.setUseDefaultIcon(true);
+ } else {
+ dialog = new SetIcon(icon, saveLastPath);
+ dialog.setUseDefaultIcon(false);
+ }
+ }
+ dialog.exec();
+ if (dialog.okPressed()) {
+ saveLastPath = dialog.getPath();
+
+ QIcon newIcon = dialog.getIcon();
+ if (stackSelected) {
+ conn.getSystemIconTable().setIcon(currentSelection.text(0), "STACK", newIcon, dialog.getFileType());
+ if (newIcon == null) {
+ newIcon = new QIcon(iconPath+"books2.png");
+ }
+ currentSelection.setIcon(0,newIcon);
+ return;
+ }
+ if (allNotebookSelected) {
+ conn.getSystemIconTable().setIcon(currentSelection.text(0), "ALLNOTEBOOK", newIcon, dialog.getFileType());
+ if (newIcon == null) {
+ newIcon = new QIcon(iconPath+"notebook-green.png");
+ }
+ currentSelection.setIcon(0,newIcon);
+ return;
+ }
+ 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");
}
+ @SuppressWarnings("unused")
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
// 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()");
+ tagTree.selectionSignal.connect(this, "tagTreeSelection()");
listManager.tagSignal.refreshTagTreeCounts.connect(tagTree, "updateCounts(List)");
logger.log(logger.HIGH, "Leaving NeverNote.initializeTagTree");
}
if (selections.size() > 0) {
menuBar.tagEditAction.setEnabled(true);
menuBar.tagDeleteAction.setEnabled(true);
+ menuBar.tagIconAction.setEnabled(true);
}
else {
menuBar.tagEditAction.setEnabled(false);
menuBar.tagDeleteAction.setEnabled(false);
+ menuBar.tagIconAction.setEnabled(true);
}
listManager.setSelectedTags(selectedTagGUIDs);
listManager.loadNotesIndex();
logger.log(logger.HIGH, "Entering NeverNote.tagIndexUpdated");
if (selectedTagGUIDs == null)
selectedTagGUIDs = new ArrayList<String>();
-// selectedTagGUIDs.clear(); // clear out old entries
+ if (reload)
+ listManager.reloadTagIndex();
tagTree.blockSignals(true);
- if (reload)
+ if (reload) {
+ tagTree.setIcons(conn.getTagTable().getAllIcons());
tagTree.load(listManager.getTagIndex());
+ }
for (int i=selectedTagGUIDs.size()-1; i>=0; i--) {
boolean found = tagTree.selectGuid(selectedTagGUIDs.get(i));
if (!found)
menuBar.noteRestoreAction.setVisible(false);
menuBar.tagEditAction.setEnabled(false);
menuBar.tagDeleteAction.setEnabled(false);
+ menuBar.tagIconAction.setEnabled(false);
selectedTagGUIDs.clear();
listManager.setSelectedTags(selectedTagGUIDs);
tagTree.blockSignals(false);
}
+ // Change the icon for a tag
+ @SuppressWarnings("unused")
+ private void setTagIcon() {
+ QTreeWidgetItem currentSelection;
+ List<QTreeWidgetItem> selections = tagTree.selectedItems();
+ if (selections.size() == 0)
+ return;
+
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+
+ QIcon currentIcon = currentSelection.icon(0);
+ QIcon icon = conn.getTagTable().getIcon(guid);
+ SetIcon dialog;
+ if (icon == null) {
+ dialog = new SetIcon(currentIcon, saveLastPath);
+ dialog.setUseDefaultIcon(true);
+ } else {
+ dialog = new SetIcon(icon, saveLastPath);
+ dialog.setUseDefaultIcon(false);
+ }
+ dialog.exec();
+ if (dialog.okPressed()) {
+ saveLastPath = dialog.getPath();
+ QIcon newIcon = dialog.getIcon();
+ conn.getTagTable().setIcon(guid, newIcon, dialog.getFileType());
+ if (newIcon == null)
+ newIcon = new QIcon(iconPath+"tag.png");
+ currentSelection.setIcon(0, newIcon);
+ }
+ }
+
//***************************************************************
//***************************************************************
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);
String currentGuid = selectedSavedSearchGUID;
menuBar.savedSearchEditAction.setEnabled(true);
menuBar.savedSearchDeleteAction.setEnabled(true);
+ menuBar.savedSearchIconAction.setEnabled(true);
List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
QTreeWidgetItem currentSelection;
selectedSavedSearchGUID = "";
private void clearSavedSearchFilter() {
menuBar.savedSearchEditAction.setEnabled(false);
menuBar.savedSearchDeleteAction.setEnabled(false);
+ menuBar.savedSearchIconAction.setEnabled(false);
savedSearchTree.blockSignals(true);
savedSearchTree.clearSelection();
savedSearchTree.blockSignals(false);
if (selectedSavedSearchGUID == null)
selectedSavedSearchGUID = new String();
savedSearchTree.blockSignals(true);
+ savedSearchTree.setIcons(conn.getSavedSearchTable().getAllIcons());
savedSearchTree.load(listManager.getSavedSearchIndex());
savedSearchTree.selectGuid(selectedSavedSearchGUID);
savedSearchTree.blockSignals(false);
menuBar.savedSearchEditAction.setEnabled(true);
menuBar.savedSearchDeleteAction.setEnabled(true);
+ menuBar.savedSearchIconAction.setEnabled(true);
List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
if (selections.size() > 0) {
menuBar.savedSearchEditAction.setEnabled(true);
menuBar.savedSearchDeleteAction.setEnabled(true);
+ menuBar.savedSearchIconAction.setEnabled(true);
selectedSavedSearchGUID = selections.get(0).text(1);
SavedSearch s = conn.getSavedSearchTable().getSavedSearch(selectedSavedSearchGUID);
searchField.setEditText(s.getQuery());
} else {
menuBar.savedSearchEditAction.setEnabled(false);
menuBar.savedSearchDeleteAction.setEnabled(false);
+ menuBar.savedSearchIconAction.setEnabled(false);
selectedSavedSearchGUID = "";
searchField.setEditText("");
}
Global.saveWindowVisible("savedSearchTree", savedSearchTree.isVisible());
logger.log(logger.HIGH, "Leaving NeverNote.toggleSavedSearchWindow");
}
+ // Change the icon for a saved search
+ @SuppressWarnings("unused")
+ private void setSavedSearchIcon() {
+ QTreeWidgetItem currentSelection;
+ List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
+ if (selections.size() == 0)
+ return;
+
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(1);
+
+ QIcon currentIcon = currentSelection.icon(0);
+ QIcon icon = conn.getSavedSearchTable().getIcon(guid);
+ SetIcon dialog;
+ if (icon == null) {
+ dialog = new SetIcon(currentIcon, saveLastPath);
+ dialog.setUseDefaultIcon(true);
+ } else {
+ dialog = new SetIcon(icon, saveLastPath);
+ dialog.setUseDefaultIcon(false);
+ }
+ dialog.exec();
+ if (dialog.okPressed()) {
+ saveLastPath = dialog.getPath();
+ QIcon newIcon = dialog.getIcon();
+ conn.getSavedSearchTable().setIcon(guid, newIcon, dialog.getFileType());
+ if (newIcon == null)
+ newIcon = new QIcon(iconPath+"search.png");
+ currentSelection.setIcon(0, newIcon);
+ }
+
+ }
@SuppressWarnings("unused")
private void databaseStatus() {
waitCursor(true);
+ indexRunner.interrupt = true;
int dirty = conn.getNoteTable().getDirtyCount();
int unindexed = conn.getNoteTable().getUnindexedCount();
DatabaseStatus status = new DatabaseStatus();
status.setUnindexed(unindexed);
status.setNoteCount(conn.getNoteTable().getNoteCount());
status.setNotebookCount(listManager.getNotebookIndex().size());
+ status.setUnindexedResourceCount(conn.getNoteTable().noteResourceTable.getUnindexedCount());
status.setSavedSearchCount(listManager.getSavedSearchIndex().size());
status.setTagCount(listManager.getTagIndex().size());
status.setResourceCount(conn.getNoteTable().noteResourceTable.getResourceCount());
@SuppressWarnings("unused")
private void logger() {
logger.log(logger.HIGH, "Entering NeverNote.logger");
- QDialog dialog = new QDialog(this);
- QHBoxLayout layout = new QHBoxLayout();
- QListWidget textBox = new QListWidget();
- layout.addWidget(textBox);
- textBox.addItems(emitLog);
-
- dialog.setLayout(layout);
- dialog.setWindowTitle(tr("Mesasge Log"));
- dialog.show();
+ LogFileDialog dialog = new LogFileDialog(emitLog);
+ dialog.exec();
logger.log(logger.HIGH, "Leaving NeverNote.logger");
}
// Menu option "help/about" was selected
tr("<h4><center><b>NeverNote</b></center></h4><hr><center>Version ")
+Global.version
+tr("<hr></center>Evernote"
- +" Generic client.<br><br>"
+ +"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
Global.saveWindowVisible("leftPanel", hidden);
}
+ public void checkForUpdates() {
+ // Send off thread to check for a new version
+ versionChecker = new QNetworkAccessManager(this);
+ versionChecker.finished.connect(this, "upgradeFileRead(QNetworkReply)");
+ QNetworkRequest request = new QNetworkRequest();
+ request.setUrl(new QUrl(Global.getUpdatesAvailableUrl()));
+ versionChecker.get(request);
+ }
+ @SuppressWarnings("unused")
+ private void upgradeFileRead(QNetworkReply reply) {
+ if (!reply.isReadable())
+ return;
+
+ String winVersion = Global.version;
+ String osxVersion = Global.version;
+ String linuxVersion = Global.version;
+ String linux64Version = Global.version;
+ String version = Global.version;
+
+ // Determine the versions available
+ QByteArray data = reply.readLine();
+ while (data != null && !reply.atEnd()) {
+ String line = data.toString();
+ String lineVersion;
+ if (line.contains(":"))
+ lineVersion = line.substring(line.indexOf(":")+1).replace(" ", "").replace("\n", "");
+ else
+ lineVersion = "";
+ if (line.toLowerCase().contains("windows"))
+ winVersion = lineVersion;
+ else if (line.toLowerCase().contains("os-x"))
+ osxVersion = lineVersion;
+ else if (line.toLowerCase().contains("linux amd64"))
+ linux64Version = lineVersion;
+ else if (line.toLowerCase().contains("linux i386"))
+ linuxVersion = lineVersion;
+ else if (line.toLowerCase().contains("default"))
+ version = lineVersion;
+ // Read the next line
+ data = reply.readLine();
+ }
+
+ // Now we need to determine what system we are on.
+ if (System.getProperty("os.name").toLowerCase().contains("windows"))
+ version = winVersion;
+ if (System.getProperty("os.name").toLowerCase().contains("mac os"))
+ version = osxVersion;
+ if (System.getProperty("os.name").toLowerCase().contains("Linux")) {
+ if (System.getProperty("os.arch").contains("amd64") ||
+ System.getProperty("os.arch").contains("x86_64"))
+ version = linux64Version;
+ else
+ version = linuxVersion;
+ }
+
+
+ for (String validVersion : Global.validVersions) {
+ if (version.equals(validVersion))
+ return;
+ }
+
+ UpgradeAvailableDialog dialog = new UpgradeAvailableDialog();
+ dialog.exec();
+ if (dialog.remindMe())
+ Global.setCheckVersionUpgrade(true);
+ else
+ Global.setCheckVersionUpgrade(false);
+ }
+
//***************************************************************
//***************************************************************
//***************************************************************
// Text in the search bar has been cleared
private void searchFieldCleared() {
+ saveNote();
+
+ // This is done because we want to force a reload of
+ // images. Some images we may want to highlight the text.
+ readOnlyCache.clear();
+ inkNoteCache.clear();
+ noteCache.clear();
+ QWebSettings.setMaximumPagesInCache(0);
+ QWebSettings.setObjectCacheCapacities(0, 0, 0);
+
searchField.setEditText("");
+ saveNoteColumnPositions();
saveNoteIndexWidth();
+ noteIndexUpdated(true);
+ if (currentNote == null && listManager.getNoteIndex().size() > 0) {
+ currentNote = listManager.getNoteIndex().get(0);
+ currentNoteGuid = currentNote.getGuid();
+ }
+ if (currentNote != null)
+ loadNoteBrowserInformation(browserWindow);
}
// text in the search bar changed. We only use this to tell if it was cleared,
// otherwise we trigger off searchFieldChanged.
@SuppressWarnings("unused")
private void searchFieldTextChanged(String text) {
+ QWebSettings.setMaximumPagesInCache(0);
+ QWebSettings.setObjectCacheCapacities(0, 0, 0);
+
if (text.trim().equals("")) {
searchFieldCleared();
if (searchPerformed) {
+
+ // This is done because we want to force a reload of
+ // images. Some images we may want to highlight the text.
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.clear();
+
listManager.setEnSearch("");
-///// listManager.clearNoteIndexSearch();
- //noteIndexUpdated(true);
listManager.loadNotesIndex();
refreshEvernoteNote(true);
noteIndexUpdated(false);
private void searchFieldChanged() {
logger.log(logger.HIGH, "Entering NeverNote.searchFieldChanged");
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.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++;
- if (synchronizeFrame == 4)
- synchronizeFrame = 0;
- synchronizeButton.setIcon(synchronizeAnimation.get(synchronizeFrame));
+
+ if (syncIcons == null) {
+ syncIcons = new ArrayList<QPixmap>();
+ double angle = 0.0;
+ synchronizeIconAngle = 0;
+ QPixmap pix = new QPixmap(iconPath+"synchronize.png");
+ syncIcons.add(pix);
+ for (int i=0; i<=360; i++) {
+ 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);
+ angle = angle+1.0;
+ p.rotate(angle);
+ p.setBackgroundMode(BGMode.OpaqueMode);
+ p.translate(-size.width()/2, -size.height()/2);
+ p.drawPixmap(0,0, pix);
+ p.end();
+ syncIcons.add(rotatedPix);
+ }
+ }
+
+ synchronizeIconAngle++;
+ if (synchronizeIconAngle > 359)
+ synchronizeIconAngle=0;
+ synchronizeButton.setIcon(syncIcons.get(synchronizeIconAngle));
+
}
// Synchronize with Evernote
@SuppressWarnings("unused")
if (!Global.isConnected)
remoteConnect();
if (Global.isConnected)
- synchronizeAnimationTimer.start(200);
+ synchronizeAnimationTimer.start(5);
+// 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);
+ Global.isConnected = false;
synchronizeAnimationTimer.stop();
return;
}
} catch (FileNotFoundException e) {
// File not found, so we'll just get empty strings anyway.
}
+
+ 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.userStoreUrl = Global.userStoreUrl;
+ syncRunner.noteStoreUrl = Global.noteStoreUrl;
+ syncRunner.noteStoreUrlBase = Global.noteStoreUrlBase;
+
String userid = aes.getUserid();
String password = aes.getPassword();
if (!userid.equals("") && !password.equals("")) {
Global.username = userid;
Global.password = password;
+ syncRunner.username = Global.username;
+ syncRunner.password = Global.password;
+ syncRunner.enConnect();
}
- // Show the login dialog box
- if (!Global.automaticLogin() || userid.equals("")|| password.equals("")) {
- LoginDialog login = new LoginDialog();
- login.exec();
+ Global.isConnected = syncRunner.isConnected;
- if (!login.okPressed()) {
- return;
- }
+ if (!Global.isConnected) {
+ // Show the login dialog box
+ if (!Global.automaticLogin() || userid.equals("")|| password.equals("")) {
+ LoginDialog login = new LoginDialog();
+ login.exec();
+
+ if (!login.okPressed()) {
+ return;
+ }
- Global.username = login.getUserid();
- Global.password = login.getPassword();
+ Global.username = login.getUserid();
+ Global.password = login.getPassword();
+ }
+ syncRunner.username = Global.username;
+ syncRunner.password = Global.password;
+ syncRunner.enConnect();
+ Global.isConnected = syncRunner.isConnected;
}
- syncRunner.username = Global.username;
- syncRunner.password = Global.password;
- syncRunner.userStoreUrl = Global.userStoreUrl;
- syncRunner.noteStoreUrl = Global.noteStoreUrl;
- syncRunner.noteStoreUrlBase = Global.noteStoreUrlBase;
- syncRunner.enConnect();
- Global.isConnected = syncRunner.isConnected;
+
+ if (!Global.isConnected)
+ return;
setupOnlineMenu();
setupConnectMenuOptions();
logger.log(logger.HIGH, "Leaving NeverNote.remoteConnect");
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");
@SuppressWarnings("unused")
private void attributeTreeClicked(QTreeWidgetItem item, Integer integer) {
- clearTagFilter();
- clearNotebookFilter();
+// clearTagFilter();
+// clearNotebookFilter();
clearTrashFilter();
- clearSavedSearchFilter();
+// clearSavedSearchFilter();
if (attributeTreeSelected == null || item.nativeId() != attributeTreeSelected.nativeId()) {
if (item.childCount() > 0) {
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;
refreshEvernoteNoteList();
logger.log(logger.HIGH, "Calling note table reload in NeverNote.noteIndexUpdated() - "+reload);
noteTableView.load(reload);
+ if (currentNoteGuid == null || currentNoteGuid.equals("")) {
+ int pos;
+ if (noteTableView.proxyModel.sortOrder() == SortOrder.AscendingOrder)
+ pos = noteTableView.proxyModel.rowCount();
+ else
+ pos = 1;
+ if (noteTableView.proxyModel.rowCount() == 0)
+ pos = 0;
+ if (pos>0) {
+ QModelIndex i = noteTableView.proxyModel.index(pos-1, Global.noteTableGuidPosition);
+ if (i!=null) {
+ currentNoteGuid = (String)i.data();
+ noteTableView.selectRow(pos-1);
+ }
+ }
+ }
+ showColumns();
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();
- currentNote = listManager.getNoteIndex().get(listManager.getNoteIndex().size()-1);
- refreshEvernoteNote(true);
- } else {
+ if (!saveCurrentNoteGuid.equals("")) {
refreshEvernoteNote(false);
+ } else {
+ currentNoteGuid = "";
}
- reloadTagTree();
+ reloadTagTree(false);
logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNoteList");
}
if (tableGuid.equals(guid)) {
listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition,tagBuffer.toString());
listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ noteTableView.proxyModel.invalidate();
return;
}
}
//QModelIndex modelIndex = noteTableView.proxyModel.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 = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
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) {
if (tableGuid.equals(guid)) {
listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
listManager.getNoteTableModel().setData(i, Global.noteTableSourceUrlPosition,url);
+ noteTableView.proxyModel.invalidate();
return;
}
}
}
logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
}
+ @SuppressWarnings("unused")
private void updateListGuid(String oldGuid, String newGuid) {
logger.log(logger.HIGH, "Entering NeverNote.updateListTitle");
String noteGuid = (String)ix.values().toArray()[0];
if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
- //listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
i=listManager.getNoteTableModel().rowCount();
}
}
String noteGuid = (String)ix.values().toArray()[0];
if (noteGuid.equalsIgnoreCase(listManager.getNoteIndex().get(j).getGuid())) {
listManager.getNoteTableModel().setData(i, Global.noteTableTagPosition, newName);
-// listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
i=listManager.getNoteTableModel().rowCount();
}
}
SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableName = (String)ix.values().toArray()[0];
if (tableName.equalsIgnoreCase(oldName)) {
-// listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
listManager.getNoteTableModel().setData(i, Global.noteTableNotebookPosition, newName);
}
}
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(guid)) {
listManager.getNoteTableModel().setData(i, Global.noteTableCreationPosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ noteTableView.proxyModel.invalidate();
return;
}
}
if (tableGuid.equals(guid)) {
listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
listManager.getNoteTableModel().setData(i, Global.noteTableSubjectDatePosition, date.toString(Global.getDateFormat()+" " +Global.getTimeFormat()));
+ noteTableView.proxyModel.invalidate();
return;
}
}
}
logger.log(logger.HIGH, "Leaving NeverNote.updateListDateCreated");
}
- @SuppressWarnings("unused")
private void updateListDateChanged(String guid, QDateTime date) {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
}
private void updateListDateChanged() {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
- QDateTime date = new QDateTime(QDateTime.currentDateTime());
- for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
- QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
- if (modelIndex != null) {
- SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
- String tableGuid = (String)ix.values().toArray()[0];
- if (tableGuid.equals(currentNoteGuid)) {
- listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
- listManager.getNoteTableModel().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
- @SuppressWarnings("unused")
private void scrollToCurrentGuid() {
//scrollToGuid(currentNoteGuid);
List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
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")
}
}
}
- logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
+ logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
+ }
+ // Wide list was chosen
+ public void narrowListView() {
+ saveNoteColumnPositions();
+ saveNoteIndexWidth();
+ saveWindowState();
+ int sortCol = noteTableView.proxyModel.sortColumn();
+ int sortOrder = noteTableView.proxyModel.sortOrder().value();
+ Global.setSortColumn(sortCol);
+ Global.setSortOrder(sortOrder);
+
+ 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();
+
+ sortCol = Global.getSortColumn();
+ sortOrder = Global.getSortOrder();
+ noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+
+ showColumns();
+ noteTableView.load(false);
+ scrollToCurrentGuid();
+ }
+ public void wideListView() {
+ int sortCol = noteTableView.proxyModel.sortColumn();
+ int sortOrder = noteTableView.proxyModel.sortOrder().value();
+ Global.setSortColumn(sortCol);
+ Global.setSortOrder(sortOrder);
+
+ 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();
+
+ sortCol = Global.getSortColumn();
+ sortOrder = Global.getSortOrder();
+ noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+
+ showColumns();
+ noteTableView.load(false);
+ scrollToCurrentGuid();
+ }
+
+
+ //***************************************************************
+ //***************************************************************
+ //** External editor window functions
+ //***************************************************************
+ //***************************************************************
+ 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({ "rawtypes", "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);
}
+
//***************************************************************
//***************************************************************
//** These functions deal with Note specific things
private void setNoteDirty() {
logger.log(logger.EXTREME, "Entering NeverNote.setNoteDirty()");
+ // 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;
*/
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.disableViewing) {
browserWindow.setEnabled(false);
return;
}
inkNote = false;
- if (!Global.showDeleted)
- browserWindow.setReadOnly(false);
+ readOnly = false;
+ if (Global.showDeleted)
+ readOnly = true;
Global.cryptCounter =0;
if (currentNoteGuid.equals("")) {
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());
- }
+
+ if (formatter.resourceError)
+ resourceErrorMessage();
+ readOnly = formatter.readOnly;
+ inkNote = formatter.inkNote;
+ if (readOnly)
+ readOnlyCache.put(currentNoteGuid, true);
+ if (inkNote)
+ inkNoteCache.put(currentNoteGuid, true);
} 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 (readOnlyCache.containsKey(currentNoteGuid))
+ readOnly = true;
+ if (inkNoteCache.containsKey(currentNoteGuid))
+ inkNote = true;
+ }
+ if (conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
+ thumbnailHTMLReady(currentNoteGuid, js, Global.calculateThumbnailZoom(js.toString()));
+ }
+
+ if (readOnly || inkNote)
+ browser.getBrowser().page().setContentEditable(false); // We don't allow editing of ink notes
+ else
+ browser.getBrowser().page().setContentEditable(true);
+ browser.setReadOnly(readOnly);
+ deleteButton.setEnabled(!readOnly);
+ tagButton.setEnabled(!readOnly);
+ menuBar.noteDelete.setEnabled(!readOnly);
+ menuBar.noteTags.setEnabled(!readOnly);
+ browser.setNote(currentNote);
+
+ if (conn.getNotebookTable().isLinked(currentNote.getNotebookGuid())) {
+ deleteButton.setEnabled(false);
+ menuBar.notebookDeleteAction.setEnabled(false);
+ } else {
+ deleteButton.setEnabled(true);
+ menuBar.notebookDeleteAction.setEnabled(true);
}
-
- browserWindow.getBrowser().page().setContentEditable(!inkNote); // We don't allow editing of ink notes
- browserWindow.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.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());
+
+ FilterEditorTags tagFilter = new FilterEditorTags(conn, logger);
+ List<Tag> tagList = tagFilter.getValidTags(currentNote);
+ browser.setAllTags(tagList);
+
+ browser.setCurrentTags(currentNote.getTagNames());
noteDirty = false;
scrollToGuid(currentNoteGuid);
- browserWindow.loadingData(false);
+ browser.loadingData(false);
if (thumbnailViewer.isActiveWindow())
thumbnailView();
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ browser.setNotebookList(notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex()));
+
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.getFileManager().getResDirPath("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);
}
/*
@SuppressWarnings("unused")
private void fullReindex() {
logger.log(logger.HIGH, "Entering NeverNote.fullReindex");
- // If we are deleting non-trash notes
- if (currentNote.getDeleted() == 0) {
- 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?"),
- QMessageBox.StandardButton.Yes,
- QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
- return;
- }
- }
- waitCursor(true);
- setMessage(tr("Marking notes for reindex."));
- conn.getNoteTable().reindexAllNotes();
- conn.getNoteTable().noteResourceTable.reindexAll();
+ indexRunner.addWork("REINDEXALL");
setMessage(tr("Database will be reindexed."));
- waitCursor(false);
- logger.log(logger.HIGH, "Leaving NeverNote.fullRefresh");
+ logger.log(logger.HIGH, "Leaving NeverNote.fullReindex");
}
// Listener when a user wants to reindex a specific note
@SuppressWarnings("unused")
private void reindexNote() {
logger.log(logger.HIGH, "Entering NeverNote.reindexNote");
for (int i=0; i<selectedNoteGUIDs.size(); i++) {
- conn.getNoteTable().setIndexNeeded(selectedNoteGUIDs.get(i), true);
+ indexRunner.addWork("REINDEXNOTE "+selectedNoteGUIDs.get(i));
}
if (selectedNotebookGUIDs.size() > 1)
setMessage(tr("Notes will be reindexed."));
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));
}
}
if (!match)
- goodNotebooks.add(listManager.getNotebookIndex().get(i).deepCopy());
+ //goodNotebooks.add(listManager.getNotebookIndex().get(i).deepCopy());
+ goodNotebooks.add((Notebook)Global.deepCopy(listManager.getNotebookIndex().get(i)));
}
// Now we have a list of good notebooks, so we can look for the default
found = false;
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());
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();
}
+ @SuppressWarnings("unused")
+ 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);
- }
+// if (guid.equals(currentNoteGuid) && !noteDirty)
+ refreshEvernoteNote(true);
}
// Signal received that a note guid has changed
@SuppressWarnings("unused")
private void noteGuidChanged(String oldGuid, String newGuid) {
if (noteCache.containsKey(oldGuid)) {
- String cache = noteCache.get(oldGuid);
- noteCache.put(newGuid, cache);
- noteCache.remove(oldGuid);
+ if (!oldGuid.equals(currentNoteGuid)) {
+ String cache = noteCache.get(oldGuid);
+ noteCache.put(newGuid, cache);
+ noteCache.remove(oldGuid);
+ } else {
+ noteCache.remove(oldGuid);
+ noteCache.put(newGuid, browserWindow.getContent());
+ }
}
+
listManager.updateNoteGuid(oldGuid, newGuid, false);
if (currentNoteGuid.equals(oldGuid)) {
if (currentNote != null)
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);
-
- 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"));
+ private void showEditorButtons(BrowserWindow browser) {
+ browser.buttonLayout.setVisible(true);
+ browser.undoAction.setVisible(false);
+
+ browser.undoButton.setVisible(false);
+
+ 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);
+ Note oldNote = conn.getNoteTable().getNote(guid, true, false,false,false,true);
List<Resource> resList = conn.getNoteTable().noteResourceTable.getNoteResources(guid, true);
+ oldNote.setContent(conn.getNoteTable().getNoteContentBinary(guid));
oldNote.setResources(resList);
duplicateNote(oldNote);
}
Long l = new Long(currentTime.getTimeInMillis());
String newGuid = new String(Long.toString(l));
- Note newNote = oldNote.deepCopy();
+// Note newNote = oldNote.deepCopy();
+ Note newNote = (Note)Global.deepCopy(oldNote);
newNote.setUpdateSequenceNum(0);
newNote.setGuid(newGuid);
newNote.setDeleted(0);
newNote.setActive(true);
+
+ /*
+ List<String> tagNames = new ArrayList<String>();
+ List<String> tagGuids = new ArrayList<String>();;
+ for (int i=0; i<oldNote.getTagGuidsSize(); i++) {
+ tagNames.add(oldNote.getTagNames().get(i));
+ tagGuids.add(oldNote.getTagGuids().get(i));
+ }
+
+ // Sort note Tags to make them look nice
+ for (int i=0; i<tagNames.size()-1; i++) {
+ if (tagNames.get(i).compareTo(tagNames.get(i+1))<0) {
+ String n1 = tagNames.get(i);
+ String n2 = tagNames.get(i+1);
+ tagNames.set(i, n2);
+ tagNames.set(i+1, n1);
+ }
+ }
+ newNote.setTagGuids(tagGuids);
+ newNote.setTagNames(tagNames);
+
+ // Add tag guids to note
+ */
+
+ // Duplicate resources
List<Resource> resList = oldNote.getResources();
if (resList == null)
resList = new ArrayList<Resource>();
resList.get(i).setGuid(newResGuid);
resList.get(i).setUpdateSequenceNum(0);
resList.get(i).setActive(true);
- conn.getNoteTable().noteResourceTable.saveNoteResource(new Resource(resList.get(i).deepCopy()), true);
+ conn.getNoteTable().noteResourceTable.saveNoteResource(
+ (Resource)Global.deepCopy(resList.get(i)), true);
}
newNote.setResources(resList);
+
+ // Add note to the database
listManager.addNote(newNote);
conn.getNoteTable().addNote(newNote, true);
listManager.getUnsynchronizedNotes().add(newNote.getGuid());
noteTableView.insertRow(newNote, true, -1);
+ currentNoteGuid = newNote.getGuid();
+ currentNote = newNote;
+ refreshEvernoteNote(true);
listManager.countNotebookResults(listManager.getNoteIndex());
waitCursor(false);
}
+ // View all notes
+ @SuppressWarnings("unused")
+ private void allNotes() {
+ clearAttributeFilter();
+ clearNotebookFilter();
+ clearSavedSearchFilter();
+ clearTrashFilter();
+ clearTagFilter();
+ searchField.clear();
+ if (Global.mimicEvernoteInterface) {
+ notebookTree.selectGuid("");
+ }
+ notebookTreeSelection();
+ }
// Merge notes
@SuppressWarnings("unused")
private void mergeNotes() {
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
private void setupOnlineMenu() {
if (!Global.isConnected) {
menuBar.noteOnlineHistoryAction.setEnabled(false);
+ menuBar.selectiveSyncAction.setEnabled(false);
return;
} else {
menuBar.noteOnlineHistoryAction.setEnabled(true);
+ menuBar.selectiveSyncAction.setEnabled(true);
}
}
@SuppressWarnings("unused")
// 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()");
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;
}
refreshEvernoteNote(true);
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();
- String relativePath = appl + ".png";
- File f = Global.getFileManager().getImageDirFile(relativePath);
- if (f.exists()) {
- return relativePath;
- }
- 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;
- FileManager fileManager = Global.getFileManager();
- if (fileDetails != null && !fileDetails.equals("")) {
- enmedia.setAttribute("href", "nnres://" +r.getGuid() +Global.attachmentNameDelimeter +fileDetails);
- contextFileName = fileManager.getResDirPath(r.getGuid() + Global.attachmentNameDelimeter + fileDetails);
- } else {
- enmedia.setAttribute("href", "nnres://" +r.getGuid() +Global.attachmentNameDelimeter +appl);
- contextFileName = fileManager.getResDirPath(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(fileManager.getResDirPath(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() +"')");
- // NFC TODO: should these be file:// URLs?
- left.setAttribute("src", Global.getFileManager().getImageDirPath("small_left.png"));
- right.setAttribute("src", Global.getFileManager().getImageDirPath("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));
- // NFC TODO: should this be a 'file://' URL?
- newText.setAttribute("src", Global.getFileManager().getImageDirPath(icon));
- if (goodPreview) {
- // NFC TODO: should this be a 'file://' URL?
- newText.setAttribute("src", fileManager.getResDirPath(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++;
+ @SuppressWarnings("unused")
+ private void setupSelectiveSync() {
+
+ // Get a list of valid notebooks
+ List<Notebook> notebooks = null;
+ List<Tag> tags = null;
+ List<LinkedNotebook> linkedNotebooks = null;
+ try {
+ notebooks = syncRunner.noteStore.listNotebooks(syncRunner.authToken);
+ tags = syncRunner.noteStore.listTags(syncRunner.authToken);
+ linkedNotebooks = syncRunner.noteStore.listLinkedNotebooks(syncRunner.authToken);
+ } catch (EDAMUserException e) {
+ setMessage("EDAMUserException: " +e.getMessage());
+ return;
+ } catch (EDAMSystemException e) {
+ setMessage("EDAMSystemException: " +e.getMessage());
+ return;
+ } catch (TException e) {
+ setMessage("EDAMTransactionException: " +e.getMessage());
+ return;
+ } catch (EDAMNotFoundException e) {
+ setMessage("EDAMNotFoundException: " +e.getMessage());
+ return;
}
- 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.getFileManager().getResDirPath(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");
+ // Split up notebooks into synchronized & non-synchronized
+ List<Notebook> ignoredBooks = new ArrayList<Notebook>();
+ List<String> dbIgnoredNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
+
+ for (int i=notebooks.size()-1; i>=0; i--) {
+ for (int j=0; j<dbIgnoredNotebooks.size(); j++) {
+ if (notebooks.get(i).getGuid().equalsIgnoreCase(dbIgnoredNotebooks.get(j))) {
+ ignoredBooks.add(notebooks.get(i));
+ j=dbIgnoredNotebooks.size();
+ }
}
}
- 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);
- }
+
+ // split up tags into synchronized & non-synchronized
+ List<Tag> ignoredTags = new ArrayList<Tag>();
+ List<String> dbIgnoredTags = conn.getSyncTable().getIgnoreRecords("TAG");
+
+ for (int i=tags.size()-1; i>=0; i--) {
+ for (int j=0; j<dbIgnoredTags.size(); j++) {
+ if (tags.get(i).getGuid().equalsIgnoreCase(dbIgnoredTags.get(j))) {
+ ignoredTags.add(tags.get(i));
+ j=dbIgnoredTags.size();
+ }
+ }
+ }
+
+ // split up linked notebooks into synchronized & non-synchronized
+ List<LinkedNotebook> ignoredLinkedNotebooks = new ArrayList<LinkedNotebook>();
+ List<String> dbIgnoredLinkedNotebooks = conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK");
+ for (int i=linkedNotebooks.size()-1; i>=0; i--) {
+ String notebookGuid = linkedNotebooks.get(i).getGuid();
+ for (int j=0; j<dbIgnoredLinkedNotebooks.size(); j++) {
+ if (notebookGuid.equalsIgnoreCase(dbIgnoredLinkedNotebooks.get(j))) {
+ ignoredLinkedNotebooks.add(linkedNotebooks.get(i));
+ j=dbIgnoredLinkedNotebooks.size();
+ }
+ }
+ }
+
+ IgnoreSync ignore = new IgnoreSync(notebooks, ignoredBooks, tags, ignoredTags, linkedNotebooks, ignoredLinkedNotebooks);
+ ignore.exec();
+ if (!ignore.okClicked())
+ return;
+
+ waitCursor(true);
+
+ // Clear out old notebooks & add the new ones
+ List<String> oldIgnoreNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
+ for (int i=0; i<oldIgnoreNotebooks.size(); i++) {
+ conn.getSyncTable().deleteRecord("IGNORENOTEBOOK-"+oldIgnoreNotebooks.get(i));
+ }
+
+ List<String> newNotebooks = new ArrayList<String>();
+ for (int i=ignore.getIgnoredBookList().count()-1; i>=0; i--) {
+ String text = ignore.getIgnoredBookList().takeItem(i).text();
+ for (int j=0; j<notebooks.size(); j++) {
+ if (notebooks.get(j).getName().equalsIgnoreCase(text)) {
+ Notebook n = notebooks.get(j);
+ conn.getSyncTable().addRecord("IGNORENOTEBOOK-"+n.getGuid(), n.getGuid());
+ j=notebooks.size();
+ newNotebooks.add(n.getGuid());
}
}
}
- // 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);
+ // Clear out old tags & add new ones
+ List<String> oldIgnoreTags = conn.getSyncTable().getIgnoreRecords("TAG");
+ for (int i=0; i<oldIgnoreTags.size(); i++) {
+ conn.getSyncTable().deleteRecord("IGNORETAG-"+oldIgnoreTags.get(i));
}
- // 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.getFileManager().getImageDirPath("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
+ List<String> newTags = new ArrayList<String>();
+ for (int i=ignore.getIgnoredTagList().count()-1; i>=0; i--) {
+ String text = ignore.getIgnoredTagList().takeItem(i).text();
+ for (int j=0; j<tags.size(); j++) {
+ if (tags.get(j).getName().equalsIgnoreCase(text)) {
+ Tag t = tags.get(j);
+ conn.getSyncTable().addRecord("IGNORETAG-"+t.getGuid(), t.getGuid());
+ newTags.add(t.getGuid());
+ j=tags.size();
+ }
+ }
}
-
- 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, "Parse error when rebuilding HTML");
- logger.log(logger.MEDIUM, "Note guid: " +noteGuid);
- logger.log(logger.EXTREME, "Start of unmodified note HTML");
- logger.log(logger.EXTREME, note);
- logger.log(logger.EXTREME, "End of unmodified note HTML");
- return note;
+
+ // Clear out old tags & add new ones
+ List<String> oldIgnoreLinkedNotebooks = conn.getSyncTable().getIgnoreRecords("LINKEDNOTEBOOK");
+ for (int i=0; i<oldIgnoreLinkedNotebooks.size(); i++) {
+ conn.getSyncTable().deleteRecord("IGNORELINKEDNOTEBOOK-"+oldIgnoreLinkedNotebooks.get(i));
}
-
- 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();
- }
-
+
+ List<String> newLinked = new ArrayList<String>();
+ for (int i=ignore.getIgnoredLinkedNotebookList().count()-1; i>=0; i--) {
+ String text = ignore.getIgnoredLinkedNotebookList().takeItem(i).text();
+ for (int j=0; j<linkedNotebooks.size(); j++) {
+ if (linkedNotebooks.get(j).getShareName().equalsIgnoreCase(text)) {
+ LinkedNotebook t = linkedNotebooks.get(j);
+ conn.getSyncTable().addRecord("IGNORELINKEDNOTEBOOK-"+t.getGuid(), t.getGuid());
+ newLinked.add(t.getGuid());
+ j=linkedNotebooks.size();
+ }
+ }
+ }
+
+ conn.getNoteTable().expungeIgnoreSynchronizedNotes(newNotebooks, newTags, newLinked);
+ waitCursor(false);
+ refreshLists();
+ }
+
+
+ //**********************************************************
+ //**********************************************************
+ //* XML Modifying methods
+ //**********************************************************
+ //**********************************************************
// 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);
}
syncRunner.syncDeletedContent = Global.synchronizeDeletedContent();
if (syncThreadsReady > 0) {
+ thumbnailRunner.interrupt = true;
saveNoteIndexWidth();
+ saveNoteColumnPositions();
if (syncRunner.addWork("SYNC")) {
syncRunning = true;
syncRunner.syncNeeded = true;
syncRunning = false;
syncRunner.syncNeeded = false;
synchronizeAnimationTimer.stop();
- synchronizeButton.setIcon(synchronizeAnimation.get(0));
+ synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
saveNote();
if (currentNote == null) {
currentNote = conn.getNoteTable().getNote(currentNoteGuid, false, false, false, false, true);
refreshEvernoteNote(false);
scrollToGuid(currentNoteGuid);
waitCursor(false);
- setMessage(tr("Synchronization Complete"));
+ 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 saveUploadAmount(long t) {
logger.log(logger.EXTREME, "Index timer activated. Sync running="+syncRunning);
if (syncRunning)
return;
- // Look for any unindexed notes. We only refresh occasionally
- // and do one at a time to keep overhead down.
- if (!indexDisabled && indexRunner.getWorkQueueSize() == 0) {
- List<String> notes = conn.getNoteTable().getNextUnindexed(1);
- String unindexedNote = null;
- if (notes.size() > 0)
- unindexedNote = notes.get(0);
- if (unindexedNote != null && Global.keepRunning) {
- indexNoteContent(unindexedNote);
- }
- if (notes.size()>0) {
- indexTimer.setInterval(100);
- return;
- }
- List<String> unindexedResources = conn.getNoteTable().noteResourceTable.getNextUnindexed(1);
- if (unindexedResources.size() > 0 && indexRunner.getWorkQueueSize() == 0) {
- String unindexedResource = unindexedResources.get(0);
- if (unindexedResource != null && Global.keepRunning) {
- indexNoteResource(unindexedResource);
- }
- }
- if (unindexedResources.size() > 0) {
- indexTimer.setInterval(100);
- return;
- } else {
- indexTimer.setInterval(indexTime);
- }
- if (indexRunning) {
- setMessage(tr("Index completed."));
- logger.log(logger.LOW, "Indexing has completed.");
- indexRunning = false;
- indexTimer.setInterval(indexTime);
- }
+ if (!indexDisabled && indexRunner.idle) {
+ thumbnailRunner.interrupt = true;
+ indexRunner.addWork("SCAN");
}
logger.log(logger.EXTREME, "Leaving neverNote index timer");
}
- private synchronized void indexNoteContent(String unindexedNote) {
- logger.log(logger.EXTREME, "Entering NeverNote.indexNoteContent()");
- logger.log(logger.MEDIUM, "Unindexed Note found: "+unindexedNote);
- indexRunner.setIndexType(indexRunner.CONTENT);
- indexRunner.addWork("CONTENT "+unindexedNote);
- if (!indexRunning) {
- setMessage(tr("Indexing notes."));
- logger.log(logger.LOW, "Beginning to index note contents.");
- indexRunning = true;
- }
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteContent()");
- }
- private synchronized void indexNoteResource(String unindexedResource) {
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
- indexRunner.addWork(new String("RESOURCE "+unindexedResource));
- if (!indexRunning) {
- setMessage(tr("Indexing notes."));
- indexRunning = true;
- }
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
+
+ @SuppressWarnings("unused")
+ private void indexStarted() {
+ setMessage(tr("Indexing notes"));
}
@SuppressWarnings("unused")
- private void indexThreadComplete(String guid) {
- logger.log(logger.MEDIUM, "Index complete for "+guid);
+ private void indexComplete() {
+ setMessage(tr("Index complete"));
}
@SuppressWarnings("unused")
private synchronized void toggleNoteIndexing() {
alive = listManager.threadCheck(Global.tagCounterThreadId);
if (!alive) {
tagDeadCount++;
- if (tagDeadCount > MAX)
+ if (tagDeadCount > MAX && !disableTagThreadCheck) {
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."));
+ disableTagThreadCheck = true;
+ }
} else
tagDeadCount=0;
alive = listManager.threadCheck(Global.notebookCounterThreadId);
if (!alive) {
notebookThreadDeadCount++;
- 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."));
+ if (notebookThreadDeadCount > MAX && !disableNotebookThreadCheck) {
+ 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."));
+ disableNotebookThreadCheck=true;
+ }
} else
notebookThreadDeadCount=0;
alive = listManager.threadCheck(Global.trashCounterThreadId);
if (!alive) {
trashDeadCount++;
- 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."));
+ if (trashDeadCount > MAX && !disableTrashThreadCheck) {
+ 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."));
+ disableTrashThreadCheck = true;
+ }
} else
trashDeadCount = 0;
alive = listManager.threadCheck(Global.saveThreadId);
if (!alive) {
saveThreadDeadCount++;
- 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."));
+ if (saveThreadDeadCount > MAX && !disableSaveThreadCheck) {
+ 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."));
+ disableSaveThreadCheck = true;
+ }
} else
saveThreadDeadCount=0;
if (!syncThread.isAlive()) {
syncThreadDeadCount++;
- 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."));
+ if (syncThreadDeadCount > MAX && !disableSyncThreadCheck) {
+ 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."));
+ disableSyncThreadCheck = true;
+ }
} else
syncThreadDeadCount=0;
if (!indexThread.isAlive()) {
indexThreadDeadCount++;
- 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."));
+ if (indexThreadDeadCount > MAX && !disableIndexThreadCheck) {
+ 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."));
+ disableIndexThreadCheck = true;
+ }
} else
indexThreadDeadCount=0;
}
-
+ private void thumbnailTimer() {
+ if (Global.enableThumbnails() && !syncRunning && indexRunner.idle) {
+ thumbnailRunner.addWork("SCAN");
+ }
+ }
//**************************************************
//* Backup & Restore
fd.setWindowTitle(tr("Backup Database"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptSave);
- fd.setDirectory(System.getProperty("user.home"));
+ if (saveLastPath == null || saveLastPath.equals(""))
+ fd.setDirectory(System.getProperty("user.home"));
+ else
+ fd.setDirectory(saveLastPath);
if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
return;
}
waitCursor(true);
+ saveLastPath = fd.selectedFiles().get(0);
+ saveLastPath = saveLastPath.substring(0,saveLastPath.lastIndexOf("/"));
setMessage(tr("Backing up database"));
saveNote();
// conn.backupDatabase(Global.getUpdateSequenceNumber(), Global.getSequenceDate());
fd.setWindowTitle(tr("Restore Database"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
- fd.setDirectory(System.getProperty("user.home"));
+ if (saveLastPath == null || saveLastPath.equals(""))
+ fd.setDirectory(System.getProperty("user.home"));
+ else
+ fd.setDirectory(saveLastPath);
if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
return;
}
waitCursor(true);
+ saveLastPath = fd.selectedFiles().get(0);
+ saveLastPath = saveLastPath.substring(0,saveLastPath.lastIndexOf("/"));
+
setMessage(tr("Restoring database"));
ImportData noteReader = new ImportData(conn, true);
noteReader.importData(fd.selectedFiles().get(0));
fd.setWindowTitle(tr("Import Notes"));
fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
- fd.setDirectory(System.getProperty("user.home"));
+ if (saveLastPath == null || saveLastPath.equals(""))
+ fd.setDirectory(System.getProperty("user.home"));
+ else
+ fd.setDirectory(saveLastPath);
if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
return;
}
ImportData noteReader = new ImportData(conn, false);
String fileName = fd.selectedFiles().get(0);
+// saveLastPath.substring(0,fileName.lastIndexOf("/"));
if (!fileName.endsWith(".nnex"))
fileName = fileName +".nnex";
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
OSDN Git Service
