import com.trolltech.qt.core.QIODevice;
import com.trolltech.qt.core.QIODevice.OpenModeFlag;
import com.trolltech.qt.core.QLocale;
+import com.trolltech.qt.core.QMimeData;
import com.trolltech.qt.core.QModelIndex;
import com.trolltech.qt.core.QSize;
import com.trolltech.qt.core.QTemporaryFile;
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.KeyboardModifier;
+import com.trolltech.qt.core.Qt.MouseButton;
import com.trolltech.qt.core.Qt.SortOrder;
import com.trolltech.qt.core.Qt.WidgetAttribute;
import com.trolltech.qt.gui.QAbstractItemView;
import com.trolltech.qt.gui.QAbstractItemView.ScrollHint;
import com.trolltech.qt.gui.QAction;
import com.trolltech.qt.gui.QApplication;
+import com.trolltech.qt.gui.QClipboard;
import com.trolltech.qt.gui.QCloseEvent;
import com.trolltech.qt.gui.QColor;
import com.trolltech.qt.gui.QComboBox;
-import com.trolltech.qt.gui.QComboBox.InsertPolicy;
import com.trolltech.qt.gui.QCursor;
import com.trolltech.qt.gui.QDesktopServices;
import com.trolltech.qt.gui.QDialog;
import com.trolltech.qt.gui.QHBoxLayout;
import com.trolltech.qt.gui.QIcon;
import com.trolltech.qt.gui.QImage;
+import com.trolltech.qt.gui.QKeySequence;
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.QPixmap;
import com.trolltech.qt.gui.QPrintDialog;
import com.trolltech.qt.gui.QPrinter;
+import com.trolltech.qt.gui.QShortcut;
import com.trolltech.qt.gui.QSizePolicy;
import com.trolltech.qt.gui.QSizePolicy.Policy;
import com.trolltech.qt.gui.QSpinBox;
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.SavedSearchEdit;
import cx.fbn.nevernote.dialog.SetIcon;
import cx.fbn.nevernote.dialog.ShareNotebook;
+import cx.fbn.nevernote.dialog.SharedNotebookSyncError;
import cx.fbn.nevernote.dialog.StackNotebook;
+import cx.fbn.nevernote.dialog.SynchronizationRequiredWarning;
import cx.fbn.nevernote.dialog.TagEdit;
+import cx.fbn.nevernote.dialog.TagMerge;
import cx.fbn.nevernote.dialog.ThumbnailViewer;
import cx.fbn.nevernote.dialog.UpgradeAvailableDialog;
import cx.fbn.nevernote.dialog.WatchFolder;
import cx.fbn.nevernote.gui.MainMenuBar;
import cx.fbn.nevernote.gui.NotebookTreeWidget;
import cx.fbn.nevernote.gui.SavedSearchTreeWidget;
+import cx.fbn.nevernote.gui.SearchPanel;
import cx.fbn.nevernote.gui.TableView;
import cx.fbn.nevernote.gui.TagTreeWidget;
import cx.fbn.nevernote.gui.Thumbnailer;
public BrowserWindow browserWindow; // Window containing browser & labels
public QToolBar toolBar; // The tool bar under the menu
QComboBox searchField; // search filter bar on the toolbar;
+ QShortcut searchShortcut; // Shortcut to search bar
boolean searchPerformed = false; // Search was done?
QuotaProgressBar quotaBar; // The current quota usage
QSpinBox zoomSpinner; // Zoom zoom
QAction searchClearButton; // Clear the search field
+ SearchPanel searchLayout; // Widget to hold search field, zoom, & quota
+
QSplitter mainLeftRightSplitter; // main splitter for left/right side
QSplitter leftSplitter1; // first left hand splitter
QSplitter browserIndexSplitter; // splitter between note index & note text
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
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.
+ private QTimer blockTimer;
+ BrowserWindow blockingWindow;
String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
QMessageBox.critical(null, tr("Database Connection Error") ,msg);
System.exit(16);
}
-
- thread().setPriority(Thread.MAX_PRIORITY);
+ setObjectName("mainWindow");
+// thread().setPriority(Thread.MAX_PRIORITY);
logger = new ApplicationLogger("nevernote.log");
logger.log(logger.HIGH, "Starting Application");
QApplication.setStyle(Global.getStyle());
if (Global.useStandardPalette())
QApplication.setPalette(QApplication.style().standardPalette());
- setWindowTitle("NeverNote");
+ setWindowTitle(tr("NeverNote"));
mainLeftRightSplitter = new QSplitter();
setCentralWidget(mainLeftRightSplitter);
browserIndexSplitter.setOrientation(Qt.Orientation.Vertical);
//* Setup threads & thread timers
- int indexRunnerCount = Global.getIndexThreads();
- indexRunnerCount = 1;
- QThreadPool.globalInstance().setMaxThreadCount(indexRunnerCount+5); // increase max thread count
+// int indexRunnerCount = Global.getIndexThreads();
+// indexRunnerCount = 1;
+ QThreadPool.globalInstance().setMaxThreadCount(Global.threadCount); // increase max thread count
logger.log(logger.EXTREME, "Building list manager");
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();
+ indexRunner.indexImageRecognition = Global.indexImageRecognition();
+ indexRunner.indexNoteBody = Global.indexNoteBody();
+ indexRunner.indexNoteTitle = Global.indexNoteTitle();
+ indexRunner.specialIndexCharacters = Global.getSpecialIndexCharacters();
indexThread.start();
synchronizeAnimationTimer = new QTimer();
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()");
logger.log(logger.EXTREME, "Starting thumnail thread");
pdfReadyQueue = new ArrayList<String>();
- thumbnailRunner = new ThumbnailRunner("thumbnailRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ 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();
thumbnailTimer = new QTimer();
thumbnailTimer.timeout.connect(this, "thumbnailTimer()");
thumbnailTimer();
- thumbnailTimer.setInterval(60*1000); // Thumbnail every minute
+ thumbnailTimer.setInterval(500*1000); // Thumbnail every minute
thumbnailTimer.start();
logger.log(logger.EXTREME, "Starting authentication timer");
trashTree = new TrashTreeWidget();
noteTableView = new TableView(logger, listManager);
+
+ searchField = new QComboBox();
+ searchField.setObjectName("searchField");
+ //setStyleSheet("QComboBox#searchField { background-color: yellow }");
+ searchField.setEditable(true);
+ searchField.activatedIndex.connect(this, "searchFieldChanged()");
+ searchField.setDuplicatesEnabled(false);
+ searchField.editTextChanged.connect(this,"searchFieldTextChanged(String)");
+ searchShortcut = new QShortcut(this);
+ setupShortcut(searchShortcut, "Focus_Search");
+ searchShortcut.activated.connect(this, "focusSearch()");
+
+ quotaBar = new QuotaProgressBar();
+ // Setup the zoom
+ zoomSpinner = new QSpinBox();
+ zoomSpinner.setMinimum(10);
+ zoomSpinner.setMaximum(1000);
+ zoomSpinner.setAccelerated(true);
+ zoomSpinner.setSingleStep(10);
+ zoomSpinner.setValue(100);
+ zoomSpinner.valueChanged.connect(this, "zoomChanged()");
+
+ searchLayout = new SearchPanel(searchField, quotaBar, notebookTree, zoomSpinner);
+
+
QGridLayout leftGrid = new QGridLayout();
+ leftSplitter1.setContentsMargins(5, 0, 0, 7);
leftSplitter1.setLayout(leftGrid);
- leftGrid.addWidget(notebookTree, 1, 1);
+ leftGrid.addWidget(searchLayout,1,1);
leftGrid.addWidget(tagTree,2,1);
leftGrid.addWidget(attributeTree,3,1);
leftGrid.addWidget(savedSearchTree,4,1);
- leftGrid.addWidget(trashTree, 5, 1);
+ leftGrid.addWidget(trashTree,5, 1);
// Setup the browser window
noteCache = new HashMap<String,String>();
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 QuotaProgressBar();
// Setup the thumbnail viewer
thumbnailViewer = new ThumbnailViewer();
emitLog = new ArrayList<String>();
tagTree.setDeleteAction(menuBar.tagDeleteAction);
+ tagTree.setMergeAction(menuBar.tagMergeAction);
tagTree.setEditAction(menuBar.tagEditAction);
tagTree.setAddAction(menuBar.tagAddAction);
tagTree.setIconAction(menuBar.tagIconAction);
tagTree.setVisible(Global.isWindowVisible("tagTree"));
+ leftSplitter1.setVisible(Global.isWindowVisible("leftPanel"));
tagTree.noteSignal.tagsAdded.connect(this, "tagsAdded(String, String)");
menuBar.hideTags.setChecked(Global.isWindowVisible("tagTree"));
listManager.tagSignal.listChanged.connect(this, "reloadTagTree()");
+
+ if (!Global.isWindowVisible("zoom")) {
+ searchLayout.hideZoom();
+ menuBar.hideZoom.setChecked(false);
+ }
notebookTree.setDeleteAction(menuBar.notebookDeleteAction);
notebookTree.setEditAction(menuBar.notebookEditAction);
noteTableView.setNoteHistoryAction(menuBar.noteOnlineHistoryAction);
noteTableView.noteSignal.titleColorChanged.connect(this, "titleColorChanged(Integer)");
noteTableView.setMergeNotesAction(menuBar.noteMergeAction);
- noteTableView.rowChanged.connect(this, "scrollToGuid(String)");
- noteTableView.resetViewport.connect(this, "scrollToCurrentGuid()");
+ noteTableView.setCopyAsUrlAction(menuBar.noteCopyAsUrlAction);
noteTableView.doubleClicked.connect(this, "listDoubleClick()");
listManager.trashSignal.countChanged.connect(trashTree, "updateCounts(Integer)");
menuBar.hideLeftSide.setChecked(true);
if (Global.isWindowVisible("noteInformation"))
toggleNoteInformation();
+ quotaBar.setVisible(Global.isWindowVisible("quota"));
+ if (!quotaBar.isVisible())
+ menuBar.hideQuota.setChecked(false);
+ searchField.setVisible(Global.isWindowVisible("searchField"));
+ if (!searchField.isVisible())
+ menuBar.hideSearch.setChecked(false);
+
+ if (searchField.isHidden() && quotaBar.isHidden() && zoomSpinner.isHidden() && notebookTree.isHidden())
+ searchLayout.hide();
setMenuBar(menuBar);
setupToolBar();
find.getOkButton().clicked.connect(this, "doFindText()");
// Setup the tray icon menu bar
- trayShowAction = new QAction("Show/Hide", this);
- trayExitAction = new QAction("Exit", this);
- trayAddNoteAction = new QAction("Add Note", this);
+ trayShowAction = new QAction(tr("Show/Hide"), this);
+ trayExitAction = new QAction(tr("Exit"), this);
+ trayAddNoteAction = new QAction(tr("Add Note"), this);
trayExitAction.triggered.connect(this, "closeNeverNote()");
trayAddNoteAction.triggered.connect(this, "addNote()");
trayIcon = new QSystemTrayIcon(this);
- trayIcon.setToolTip("NeverNote");
+ trayIcon.setToolTip(tr("NeverNote"));
trayIcon.setContextMenu(trayMenu);
trayIcon.activated.connect(this, "trayActivated(com.trolltech.qt.gui.QSystemTrayIcon$ActivationReason)");
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));
Global.getDatabaseUserPassword(), Global.cipherPassword);
}
}
- DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
+ DatabaseConnection dbConn = new DatabaseConnection(logger,Global.getDatabaseUrl(),
+ Global.getIndexDatabaseUrl(), Global.getResourceDatabaseUrl(),
+ Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword, 0);
return dbConn;
}
try {
Statement st = conn.getConnection().createStatement();
st.execute("shutdown");
- if (QMessageBox.question(this, "Are you sure",
- "Are you sure you wish to encrypt the database?",
+ 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");
+ Global.setDatabaseUrl(Global.getIndexDatabaseUrl() + ";CIPHER="+encryptCipher);
+ Global.setDatabaseUrl(Global.getResourceDatabaseUrl() + ";CIPHER="+encryptCipher);
+ QMessageBox.information(this, tr("Encryption Complete"), tr("Encryption is complete"));
}
} catch (SQLException e) {
e.printStackTrace();
}
} else {
DBEncryptDialog dialog = new DBEncryptDialog();
- dialog.setWindowTitle("Database Decryption");
+ dialog.setWindowTitle(tr("Database Decryption"));
dialog.hideEncryption();
dialog.exec();
if (dialog.okPressed()) {
externalFileEditedSaver();
if (Global.isConnected && Global.synchronizeOnClose()) {
setMessage(tr("Performing synchronization before closing."));
+ syncRunner.syncNeeded = true;
syncRunner.addWork("SYNC");
+ } else {
+ syncRunner.keepRunning = false;
}
+ syncRunner.addWork("STOP");
setMessage("Closing Program.");
threadMonitorTimer.stop();
- syncRunner.addWork("STOP");
- syncRunner.keepRunning = false;
thumbnailRunner.addWork("STOP");
- syncRunner.keepRunning = false;
indexRunner.addWork("STOP");
- syncRunner.keepRunning = false;
saveNote();
listManager.stop();
saveWindowState();
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 - bypassing");
+ else {
+ logger.log(logger.MEDIUM, "Index thread still running - interrupting");
+ indexRunner.thread().interrupt();
+ }
} catch (InterruptedException e1) {
e1.printStackTrace();
}
- if (!syncRunner.isIdle()) {
- try {
- logger.log(logger.MEDIUM, "Waiting for syncThread to stop");
- syncThread.join();
- logger.log(logger.MEDIUM, "Sync thread has stopped");
- } catch (InterruptedException e1) {
- e1.printStackTrace();
+
+ if (!syncRunner.thread().isAlive()) {
+ logger.log(logger.MEDIUM, "Waiting for syncThread to stop");
+ if (syncRunner.thread().isAlive()) {
+ System.out.println(tr("Synchronizing. Please be patient."));
+ for(;syncRunner.thread().isAlive();) {
+ try {
+ wait(10);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
}
+ logger.log(logger.MEDIUM, "Sync thread has stopped");
}
if (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");
}
}
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) {
while (QApplication.overrideCursor() != null)
QApplication.restoreOverrideCursor();
}
+ listManager.refreshCounters();
}
private void setupIndexListeners() {
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()");
}
browser.noteSignal.geoChanged.connect(listManager, "updateNoteGeoTag(String, Double,Double,Double)");
browser.noteSignal.geoChanged.connect(this, "setNoteDirty()");
browser.noteSignal.sourceUrlChanged.connect(listManager, "updateNoteSourceUrl(String, String)");
+ browser.blockApplication.connect(this, "blockApplication(BrowserWindow)");
+ browser.unblockApplication.connect(this, "unblockApplication()");
if (master) browser.focusLost.connect(this, "saveNote()");
browser.resourceSignal.contentChanged.connect(this, "externalFileEdited(String)");
+ browser.evernoteLinkClicked.connect(this, "evernoteLinkClick(String, String)");
}
+ //**************************************************
+ //* Setup shortcuts
+ //**************************************************
+ private void setupShortcut(QShortcut action, String text) {
+ if (!Global.shortcutKeys.containsAction(text))
+ return;
+ action.setKey(new QKeySequence(Global.shortcutKeys.getShortcut(text)));
+ }
+
//***************************************************************
//***************************************************************
//* Settings and look & feel
settings.exec();
indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
+ indexRunner.indexNoteBody = Global.indexNoteBody();
+ indexRunner.indexNoteTitle = Global.indexNoteTitle();
+ indexRunner.specialIndexCharacters = Global.getSpecialIndexCharacters();
+ indexRunner.indexImageRecognition = Global.indexImageRecognition();
if (Global.showTrayIcon())
trayIcon.show();
else
else
saveTimer.stop();
- // This is a hack to force a reload of the index in case the date or time changed.
-// if (!dateFormat.equals(Global.getDateFormat()) ||
-// !timeFormat.equals(Global.getTimeFormat())) {
- noteCache.clear();
- readOnlyCache.clear();
- inkNoteCache.clear();
- noteIndexUpdated(true);
-// }
+ // Set special reloads
+ if (settings.getDebugPage().reloadSharedNotebooksClicked()) {
+ conn.executeSql("Delete from LinkedNotebook");
+ conn.executeSql("delete from SharedNotebook");
+ conn.executeSql("Delete from Notebook where linked=true");
+ conn.executeSql("Insert into Sync (key, value) values ('FullLinkedNotebookSync', 'true')");
+ conn.executeSql("Insert into Sync (key, value) values ('FullSharedNotebookSync', 'true')");
+ }
+
+ // Reload user data
+ 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(boolean mainWindow) {
// We need to name things or this doesn't work.
setObjectName("NeverNote");
+ restoreState(Global.restoreState(objectName()));
mainLeftRightSplitter.setObjectName("mainLeftRightSplitter");
browserIndexSplitter.setObjectName("browserIndexSplitter");
leftSplitter1.setObjectName("leftSplitter1");
Global.saveState(mainLeftRightSplitter.objectName(), mainLeftRightSplitter.saveState());
Global.saveState(browserIndexSplitter.objectName(), browserIndexSplitter.saveState());
Global.saveState(leftSplitter1.objectName(), leftSplitter1.saveState());
+ Global.saveState(objectName(), saveState());
}
// Load the style sheet
private void loadStyleSheet() {
- String fileName = Global.getFileManager().getQssDirPath("default.qss");
+ String styleSheetName = "default.qss";
+ if (Global.getStyle().equalsIgnoreCase("cleanlooks"))
+ styleSheetName = "default-cleanlooks.qss";
+ String fileName = Global.getFileManager().getQssDirPathUser("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(styleSheetName);
+ file = new QFile(fileName);
+ }
file.open(OpenModeFlag.ReadOnly);
String styleSheet = file.readAll().toString();
file.close();
Global.setColumnWidth("noteTableGuidPosition", width);
}
+ @SuppressWarnings("unused")
+ private void toggleSearchWindow() {
+ logger.log(logger.HIGH, "Entering NeverNote.toggleSearchWindow");
+ searchLayout.toggleSearchField();
+ menuBar.hideSearch.setChecked(searchField.isVisible());
+ Global.saveWindowVisible("searchField", searchField.isVisible());
+ logger.log(logger.HIGH, "Leaving NeverNote.toggleSearchWindow");
+ }
+ @SuppressWarnings("unused")
+ private void toggleQuotaWindow() {
+ logger.log(logger.HIGH, "Entering NeverNote.toggleQuotaWindow");
+ searchLayout.toggleQuotaBar();
+ menuBar.hideQuota.setChecked(quotaBar.isVisible());
+ Global.saveWindowVisible("quota", quotaBar.isVisible());
+ logger.log(logger.HIGH, "Leaving NeverNote.toggleQuotaWindow");
+ }
+ @SuppressWarnings("unused")
+ private void toggleZoomWindow() {
+ logger.log(logger.HIGH, "Entering NeverNote.toggleZoomWindow");
+ searchLayout.toggleZoom();
+ menuBar.hideZoom.setChecked(zoomSpinner.isVisible());
+ Global.saveWindowVisible("zoom", zoomSpinner.isVisible());
+ logger.log(logger.HIGH, "Leaving NeverNote.toggleZoomWindow");
+ }
+
+
//***************************************************************
//***************************************************************
listManager.setSelectedNotebooks(selectedNotebookGUIDs);
listManager.loadNotesIndex();
noteIndexUpdated(false);
+ refreshEvernoteNote(true);
+ listManager.refreshCounters = true;
+ listManager.refreshCounters();
logger.log(logger.HIGH, "Leaving NeverNote.notebookTreeSelection");
}
if (!found)
selectedNotebookGUIDs.remove(i);
}
+ listManager.refreshCounters = true;
+ listManager.refreshCounters();
notebookTree.blockSignals(false);
logger.log(logger.HIGH, "Leaving NeverNote.notebookIndexUpdated");
}
// Show/Hide note information
+ @SuppressWarnings("unused")
private void toggleNotebookWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleNotebookWindow");
- if (notebookTree.isVisible())
- notebookTree.hide();
- else
- notebookTree.show();
+ searchLayout.toggleNotebook();
menuBar.hideNotebooks.setChecked(notebookTree.isVisible());
Global.saveWindowVisible("notebookTree", notebookTree.isVisible());
logger.log(logger.HIGH, "Leaving NeverNote.toggleNotebookWindow");
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().equalsIgnoreCase(currentSelection.text(0)))
+ 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());
if (!stackSelected && !allNotebookSelected) {
icon = conn.getNotebookTable().getIcon(guid);
if (icon == null) {
- dialog = new SetIcon(currentIcon);
+ dialog = new SetIcon(currentIcon, saveLastPath);
dialog.setUseDefaultIcon(true);
} else {
- dialog = new SetIcon(icon);
+ dialog = new SetIcon(icon, saveLastPath);
dialog.setUseDefaultIcon(false);
}
} else {
icon = conn.getSystemIconTable().getIcon(currentSelection.text(0), "ALLNOTEBOOK");
}
if (icon == null) {
- dialog = new SetIcon(currentIcon);
+ dialog = new SetIcon(currentIcon, saveLastPath);
dialog.setUseDefaultIcon(true);
} else {
- dialog = new SetIcon(icon);
+ 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());
logger.log(logger.HIGH, "Inside NeverNote.addTag");
TagEdit edit = new TagEdit();
edit.setTagList(listManager.getTagIndex());
+
+ List<QTreeWidgetItem> selections = tagTree.selectedItems();
+ QTreeWidgetItem currentSelection = null;
+ if (selections.size() > 0) {
+ currentSelection = selections.get(0);
+ edit.setParentTag(currentSelection.text(0));
+ }
+
edit.exec();
if (!edit.okPressed())
newTag.setUpdateSequenceNum(0);
newTag.setGuid(randint);
newTag.setName(edit.getTag());
+ if (edit.getParentTag().isChecked()) {
+ newTag.setParentGuid(currentSelection.text(2));
+ newTag.setParentGuidIsSet(true);
+ currentSelection.setExpanded(true);
+ }
conn.getTagTable().addTag(newTag, true);
listManager.getTagIndex().add(newTag);
reloadTagTree(true);
logger.log(logger.HIGH, "Entering NeverNote.reloadTagTree");
tagIndexUpdated(reload);
boolean filter = false;
- listManager.countTagResults(listManager.getNoteIndex());
+ if (reload)
+ listManager.countTagResults(listManager.getNoteIndex());
if (notebookTree.selectedItems().size() > 0
&& !notebookTree.selectedItems().get(0).text(0).equalsIgnoreCase("All Notebooks"))
filter = true;
menuBar.tagDeleteAction.setEnabled(false);
menuBar.tagIconAction.setEnabled(true);
}
+ if (selections.size() > 1)
+ menuBar.tagMergeAction.setEnabled(true);
+ else
+ menuBar.tagMergeAction.setEnabled(false);
listManager.setSelectedTags(selectedTagGUIDs);
listManager.loadNotesIndex();
noteIndexUpdated(false);
+ refreshEvernoteNote(true);
+ listManager.refreshCounters = true;
+ listManager.refreshCounters();
logger.log(logger.HIGH, "Leaving NeverNote.tagTreeSelection");
}
// trigger the tag index to be refreshed
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)
logger.log(logger.HIGH, "Leaving NeverNote.tagIndexUpdated");
}
// Show/Hide note information
+ @SuppressWarnings("unused")
private void toggleTagWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleTagWindow");
if (tagTree.isVisible())
tagTree.clearSelection();
menuBar.noteRestoreAction.setVisible(false);
menuBar.tagEditAction.setEnabled(false);
+ menuBar.tagMergeAction.setEnabled(false);
menuBar.tagDeleteAction.setEnabled(false);
menuBar.tagIconAction.setEnabled(false);
selectedTagGUIDs.clear();
QIcon icon = conn.getTagTable().getIcon(guid);
SetIcon dialog;
if (icon == null) {
- dialog = new SetIcon(currentIcon);
+ dialog = new SetIcon(currentIcon, saveLastPath);
dialog.setUseDefaultIcon(true);
} else {
- dialog = new SetIcon(icon);
+ 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)
}
}
+ // Merge tags
+ @SuppressWarnings("unused")
+ private void mergeTags() {
+ List<Tag> tags = new ArrayList<Tag>();
+ List<QTreeWidgetItem> selections = tagTree.selectedItems();
+ for (int i=0; i<selections.size(); i++) {
+ Tag record = new Tag();
+ record.setGuid(selections.get(i).text(2));
+ record.setName(selections.get(i).text(0));
+ tags.add(record);
+ }
+ TagMerge mergeDialog = new TagMerge(tags);
+ mergeDialog.exec();
+ if (!mergeDialog.okClicked())
+ return;
+ String newGuid = mergeDialog.getNewTagGuid();
+
+ for (int i=0; i<tags.size(); i++) {
+ if (!tags.get(i).getGuid().equals(newGuid)) {
+ List<String> noteGuids = conn.getNoteTable().noteTagsTable.getTagNotes(tags.get(i).getGuid());
+ for (int j=0; j<noteGuids.size(); j++) {
+ String noteGuid = noteGuids.get(j);
+ conn.getNoteTable().noteTagsTable.deleteNoteTag(noteGuid);
+ if (!conn.getNoteTable().noteTagsTable.checkNoteNoteTags(noteGuid, newGuid))
+ conn.getNoteTable().noteTagsTable.saveNoteTag(noteGuid, newGuid);
+ }
+ }
+ }
+ listManager.reloadIndexes();
+ }
//***************************************************************
//***************************************************************
private void deleteSavedSearch() {
logger.log(logger.HIGH, "Entering NeverNote.deleteSavedSearch");
- if (QMessageBox.question(this, "Confirmation", "Delete the selected search?",
+ if (QMessageBox.question(this, tr("Confirmation"), tr("Delete the selected search?"),
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
}
// Show/Hide note information
+ @SuppressWarnings("unused")
private void toggleSavedSearchWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleSavedSearchWindow");
if (savedSearchTree.isVisible())
QIcon icon = conn.getSavedSearchTable().getIcon(guid);
SetIcon dialog;
if (icon == null) {
- dialog = new SetIcon(currentIcon);
+ dialog = new SetIcon(currentIcon, saveLastPath);
dialog.setUseDefaultIcon(true);
} else {
- dialog = new SetIcon(icon);
+ 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)
@SuppressWarnings("unused")
private void databaseStatus() {
waitCursor(true);
+ indexRunner.interrupt = true;
int dirty = conn.getNoteTable().getDirtyCount();
int unindexed = conn.getNoteTable().getUnindexedCount();
DatabaseStatus status = new DatabaseStatus();
@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
+"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 Oracle Corporation.<br><hr>"));
+ +"Java is a registered trademark of Oracle Corporation.<br><hr>"
+ +"Special thanks to:<br>BitRock InstallBuilder for the Windows installer"
+ +"<br>CodeCogs (www.codecogs.com) for the LaTeX image rendering."));
logger.log(logger.HIGH, "Leaving NeverNote.about");
}
// Hide the entire left hand side
hidden = !menuBar.hideLeftSide.isChecked();
menuBar.hideLeftSide.setChecked(!hidden);
- if (notebookTree.isVisible() != hidden)
- toggleNotebookWindow();
- if (savedSearchTree.isVisible() != hidden)
- toggleSavedSearchWindow();
- if (tagTree.isVisible() != hidden)
- toggleTagWindow();
- if (attributeTree.isVisible() != hidden)
- toggleAttributesWindow();
- if (trashTree.isVisible() != hidden)
- toggleTrashWindow();
+ if (!hidden)
+ leftSplitter1.setHidden(true);
+ else
+ leftSplitter1.setHidden(false);
Global.saveWindowVisible("leftPanel", hidden);
version = osxVersion;
if (System.getProperty("os.name").toLowerCase().contains("Linux")) {
if (System.getProperty("os.arch").contains("amd64") ||
- System.getProperty("os.arch").contains("x86_64") ||
- System.getProperty("os.arch").contains("i686"))
+ System.getProperty("os.arch").contains("x86_64"))
version = linux64Version;
else
version = linuxVersion;
}
- if (Global.version.equals(version))
- return;
+ for (String validVersion : Global.validVersions) {
+ if (version.equals(validVersion))
+ return;
+ }
UpgradeAvailableDialog dialog = new UpgradeAvailableDialog();
dialog.exec();
//***************************************************************
//** These functions deal with the Toolbar
//***************************************************************
- //***************************************************************
+ //***************************************************************
+ @SuppressWarnings("unused")
+ private void focusSearch() {
+ searchField.setFocus();
+ }
+
// Text in the search bar has been cleared
private void searchFieldCleared() {
saveNote();
currentNote = listManager.getNoteIndex().get(0);
currentNoteGuid = currentNote.getGuid();
}
+ refreshEvernoteNote(true);
if (currentNote != null)
- loadNoteBrowserInformation(browserWindow);
+ loadNoteBrowserInformation(browserWindow, currentNoteGuid, currentNote);
}
// text in the search bar changed. We only use this to tell if it was cleared,
// otherwise we trigger off searchFieldChanged.
listManager.loadNotesIndex();
refreshEvernoteNote(true);
noteIndexUpdated(false);
+ refreshEvernoteNote(true);
}
searchPerformed = false;
}
String text = searchField.currentText();
listManager.setEnSearch(text.trim());
listManager.loadNotesIndex();
-//--->>> noteIndexUpdated(true);
noteIndexUpdated(false);
refreshEvernoteNote(true);
searchPerformed = true;
private void setupToolBar() {
logger.log(logger.HIGH, "Entering NeverNote.setupToolBar");
toolBar = addToolBar(tr("Tool Bar"));
+ toolBar.setObjectName("toolBar");
menuBar.setupToolBarVisible();
if (!Global.isWindowVisible("toolBar"))
toolBar.setVisible(false);
else
toolBar.setVisible(true);
- prevButton = toolBar.addAction("Previous");
+// toolBar.addWidget(menuBar);
+// menuBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
+// toolBar.addSeparator();
+ prevButton = toolBar.addAction(tr("Previous"));
QIcon prevIcon = new QIcon(iconPath+"back.png");
prevButton.setIcon(prevIcon);
prevButton.triggered.connect(this, "previousViewedAction()");
togglePrevArrowButton(Global.isToolbarButtonVisible("prevArrow"));
- nextButton = toolBar.addAction("Next");
+ nextButton = toolBar.addAction(tr("Next"));
QIcon nextIcon = new QIcon(iconPath+"forward.png");
nextButton.setIcon(nextIcon);
nextButton.triggered.connect(this, "nextViewedAction()");
toggleNextArrowButton(Global.isToolbarButtonVisible("nextArrow"));
- upButton = toolBar.addAction("Up");
+ upButton = toolBar.addAction(tr("Up"));
QIcon upIcon = new QIcon(iconPath+"up.png");
upButton.setIcon(upIcon);
upButton.triggered.connect(this, "upAction()");
toggleUpArrowButton(Global.isToolbarButtonVisible("upArrow"));
- downButton = toolBar.addAction("Down");
+ downButton = toolBar.addAction(tr("Down"));
QIcon downIcon = new QIcon(iconPath+"down.png");
downButton.setIcon(downIcon);
downButton.triggered.connect(this, "downAction()");
toggleDownArrowButton(Global.isToolbarButtonVisible("downArrow"));
- synchronizeButton = toolBar.addAction("Synchronize");
+ synchronizeButton = toolBar.addAction(tr("Synchronize"));
synchronizeButton.setIcon(new QIcon(iconPath+"synchronize.png"));
synchronizeIconAngle = 0;
synchronizeButton.triggered.connect(this, "evernoteSync()");
toggleSynchronizeButton(Global.isToolbarButtonVisible("synchronize"));
- printButton = toolBar.addAction("Print");
+ printButton = toolBar.addAction(tr("Print"));
QIcon printIcon = new QIcon(iconPath+"print.png");
printButton.setIcon(printIcon);
printButton.triggered.connect(this, "printNote()");
togglePrintButton(Global.isToolbarButtonVisible("print"));
- tagButton = toolBar.addAction("Tag");
+ tagButton = toolBar.addAction(tr("Tag"));
QIcon tagIcon = new QIcon(iconPath+"tag.png");
tagButton.setIcon(tagIcon);
tagButton.triggered.connect(browserWindow, "modifyTags()");
toggleTagButton(Global.isToolbarButtonVisible("tag"));
- attributeButton = toolBar.addAction("Attributes");
+ attributeButton = toolBar.addAction(tr("Attributes"));
QIcon attributeIcon = new QIcon(iconPath+"attribute.png");
attributeButton.setIcon(attributeIcon);
attributeButton.triggered.connect(this, "toggleNoteInformation()");
toggleAttributeButton(Global.isToolbarButtonVisible("attribute"));
- emailButton = toolBar.addAction("Email");
+ emailButton = toolBar.addAction(tr("Email"));
QIcon emailIcon = new QIcon(iconPath+"email.png");
emailButton.setIcon(emailIcon);
emailButton.triggered.connect(this, "emailNote()");
toggleEmailButton(Global.isToolbarButtonVisible("email"));
- deleteButton = toolBar.addAction("Delete");
+ deleteButton = toolBar.addAction(tr("Delete"));
QIcon deleteIcon = new QIcon(iconPath+"delete.png");
deleteButton.setIcon(deleteIcon);
deleteButton.triggered.connect(this, "deleteNote()");
toggleDeleteButton(Global.isToolbarButtonVisible("delete"));
- newButton = toolBar.addAction("New");
+ newButton = toolBar.addAction(tr("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");
+ allNotesButton = toolBar.addAction(tr("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(tr("Quota:")));
- toolBar.addWidget(quotaBar);
+ //toolBar.addSeparator();
+ //toolBar.addWidget(new QLabel(tr("Quota:")));
+ //toolBar.addWidget(quotaBar);
//quotaBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
updateQuotaBar();
- toolBar.addSeparator();
+ //toolBar.addSeparator();
- // Setup the zoom
- zoomSpinner = new QSpinBox();
- zoomSpinner.setMinimum(10);
- zoomSpinner.setMaximum(1000);
- zoomSpinner.setAccelerated(true);
- zoomSpinner.setSingleStep(10);
- zoomSpinner.setValue(100);
- zoomSpinner.valueChanged.connect(this, "zoomChanged()");
- toolBar.addWidget(new QLabel(tr("Zoom")));
- toolBar.addWidget(zoomSpinner);
+ //toolBar.addWidget(new QLabel(tr("Zoom")));
+ //toolBar.addWidget(zoomSpinner);
//toolBar.addWidget(new QLabel(" "));
- toolBar.addSeparator();
- toolBar.addWidget(new QLabel(tr(" Search:")));
- toolBar.addWidget(searchField);
+ //toolBar.addSeparator();
+ //toolBar.addWidget(new QLabel(tr(" Search:")));
+ //toolBar.addWidget(searchField);
QSizePolicy sizePolicy = new QSizePolicy();
sizePolicy.setHorizontalPolicy(Policy.MinimumExpanding);
- searchField.setSizePolicy(sizePolicy);
- searchField.setInsertPolicy(InsertPolicy.InsertAtTop);
+ QLabel spacer = new QLabel("");
+ spacer.setSizePolicy(sizePolicy);
+ toolBar.addWidget(spacer);
+ //searchField.setInsertPolicy(InsertPolicy.InsertAtTop);
- searchClearButton = toolBar.addAction("Search Clear");
- QIcon searchClearIcon = new QIcon(iconPath+"searchclear.png");
- searchClearButton.setIcon(searchClearIcon);
- searchClearButton.triggered.connect(this, "searchFieldCleared()");
- toggleSearchClearButton(Global.isToolbarButtonVisible("searchClear"));
+ //searchClearButton = toolBar.addAction("Search Clear");
+ //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");
}
allNotesButton.setVisible(toggle);
Global.saveToolbarButtonsVisible("allNotes", toggle);
}
- private void toggleSearchClearButton(Boolean toggle) {
+ @SuppressWarnings("unused")
+ private void toggleSearchClearButton(Boolean toggle) {
searchClearButton.setVisible(toggle);
Global.saveToolbarButtonsVisible("searchClear", toggle);
}
}
// Synchronize with Evernote
- @SuppressWarnings("unused")
+
private void evernoteSync() {
logger.log(logger.HIGH, "Entering NeverNote.evernoteSync");
if (!Global.isConnected)
@SuppressWarnings("unused")
private void emptyTrash() {
// browserWindow.clear();
+ logger.log(logger.EXTREME, "Emptying Trash");
listManager.emptyTrash();
+ logger.log(logger.EXTREME, "Resetting view after trash empty");
if (trashTree.selectedItems().size() > 0) {
listManager.getSelectedNotebooks().clear();
listManager.getSelectedTags().clear();
menuBar.noteRestoreAction.setVisible(false);
listManager.loadNotesIndex();
-//--->>> noteIndexUpdated(true);
noteIndexUpdated(false);
}
}
// Show/Hide trash window
+ @SuppressWarnings("unused")
private void toggleTrashWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleTrashWindow");
if (trashTree.isVisible())
} 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;
- if (Global.getProxyValue("url").equals("")) {
- System.setProperty("http.proxyHost","") ;
- System.setProperty("http.proxyPort", "") ;
- System.setProperty("https.proxyHost","") ;
- System.setProperty("https.proxyPort", "") ;
- } else {
- // PROXY
- System.setProperty("http.proxyHost",Global.getProxyValue("url")) ;
- System.setProperty("http.proxyPort", Global.getProxyValue("port")) ;
- System.setProperty("https.proxyHost",Global.getProxyValue("url")) ;
- System.setProperty("https.proxyPort", Global.getProxyValue("port")) ;
-
- if (Global.getProxyValue("userid").equals("")) {
- Authenticator.setDefault(new Authenticator() {
- @Override
- protected PasswordAuthentication getPasswordAuthentication() {
- return new
- PasswordAuthentication(Global.getProxyValue("userid"),Global.getProxyValue("password").toCharArray());
- }});
- }
- }
-
-
- syncRunner.enConnect();
- Global.isConnected = syncRunner.isConnected;
+ if (!Global.isConnected)
+ return;
setupOnlineMenu();
setupConnectMenuOptions();
logger.log(logger.HIGH, "Leaving NeverNote.remoteConnect");
}
// Show/Hide attribute search window
+ @SuppressWarnings("unused")
private void toggleAttributesWindow() {
logger.log(logger.HIGH, "Entering NeverNote.toggleAttributesWindow");
if (attributeTree.isVisible())
@SuppressWarnings("unused")
private void noteTableSelection() {
logger.log(logger.HIGH, "Entering NeverNote.noteTableSelection");
+
saveNote();
+
+ // If the ctrl key is pressed, then they are selecting multiple
+ // entries and we don't want to change the currently viewed note.
+ if (QApplication.keyboardModifiers().isSet(KeyboardModifier.ControlModifier) &&
+ QApplication.mouseButtons().isSet(MouseButton.LeftButton))
+ return;
+
if (historyGuids.size() == 0) {
historyGuids.add(currentNoteGuid);
historyPosition = 1;
refreshEvernoteNoteList();
logger.log(logger.HIGH, "Calling note table reload in NeverNote.noteIndexUpdated() - "+reload);
noteTableView.load(reload);
- scrollToGuid(currentNoteGuid);
+ 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();
+ }
+ }
+ }
+ if (!noteTableView.isColumnHidden(Global.noteTableGuidPosition))
+ showColumns();
+ scrollToGuid(currentNoteGuid);
logger.log(logger.HIGH, "Leaving NeverNote.noteIndexUpdated");
}
// Called when the list of notes is updated
browserWindow.setDisabled(true);
}
- if (saveCurrentNoteGuid.equals("") && listManager.getNoteIndex().size() > 0) {
- currentNote = listManager.getNoteIndex().get(listManager.getNoteIndex().size()-1);
- currentNoteGuid = currentNote.getGuid();
- refreshEvernoteNote(true);
- } else {
- //we can reload if note not dirty
-// refreshEvernoteNote(!noteDirty);
+ if (!saveCurrentNoteGuid.equals("")) {
refreshEvernoteNote(false);
+ } else {
+ currentNoteGuid = "";
}
reloadTagTree(false);
String guid = (String)index.model().index(row, Global.noteTableGuidPosition).data();
scrollToGuid(guid);
}
+ // Scroll to the current GUID in tthe list.
// Scroll to a particular index item
private void scrollToGuid(String guid) {
if (currentNote == null || guid == null)
}
}
}
-
if (!currentNote.isActive() && !Global.showDeleted) {
for (int i=0; i<listManager.getNoteIndex().size(); i++) {
if (listManager.getNoteIndex().get(i).isActive()) {
}
}
}
-
QModelIndex index;
for (int i=0; i<noteTableView.model().rowCount(); i++) {
index = noteTableView.model().index(i, Global.noteTableGuidPosition);
if (currentNoteGuid.equals(index.data())) {
-// noteTableView.setCurrentIndex(index);
+// noteTableView.selectionModel().blockSignals(true);
noteTableView.selectRow(i);
+// noteTableView.selectionModel().blockSignals(false);
noteTableView.scrollTo(index, ScrollHint.EnsureVisible); // This should work, but it doesn't
i=listManager.getNoteTableModel().rowCount();
}
showColumns();
noteTableView.load(false);
+ refreshEvernoteNote(true);
scrollToCurrentGuid();
}
public void wideListView() {
//***************************************************************
+ @SuppressWarnings("unused")
+ private void evernoteLinkClick(String syncGuid, String locGuid) {
+ String guid = null;
+ if (conn.getNoteTable().guidExists(syncGuid)) {
+ guid = syncGuid;
+ } else {
+ // If we didn't find it via the synchronized guid, look under the local guid
+ // Iwe don't find it there, look to see if the GUID is posted under the local GUID, but was
+ // later synchronized (that causes the guid to change so we need to find the new one).
+ if (conn.getNoteTable().guidExists(locGuid))
+ guid = locGuid;
+ else
+ guid = conn.getNoteTable().findAlternateGuid(locGuid);
+ }
+ if (guid != null) {
+ openExternalEditor(guid);
+ return;
+ }
+
+ //If we've gotten this far, we can't find the note
+ QMessageBox.information(this, tr("Note Not Found"), tr("Sorry, but I can't"+
+ " seem to find that note."));
+ }
+ //***************************************************************
//***************************************************************
//** External editor window functions
//***************************************************************
//***************************************************************
private void listDoubleClick() {
- saveNote();
- if (externalWindows.containsKey(currentNoteGuid)) {
- externalWindows.get(currentNoteGuid).raise();
+ saveNote();
+ openExternalEditor(currentNoteGuid);
+ }
+ private void openExternalEditor(String guid) {
+
+ if (externalWindows.containsKey(guid)) {
+ externalWindows.get(guid).raise();
return;
}
+ Note note = conn.getNoteTable().getNote(guid, true, true, false, true, true);
// 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);
+ externalWindows.put(guid, newBrowser);
showEditorButtons(newBrowser.getBrowserWindow());
- loadNoteBrowserInformation(newBrowser.getBrowserWindow());
+ loadNoteBrowserInformation(newBrowser.getBrowserWindow(), guid, note);
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)");
+ newBrowser.getBrowserWindow().blockApplication.connect(this, "blockApplication(BrowserWindow)");
+ newBrowser.getBrowserWindow().unblockApplication.connect(this, "unblockApplication()");
browserWindow.noteSignal.tagsChanged.connect(newBrowser, "updateTags(String, List)");
browserWindow.noteSignal.titleChanged.connect(newBrowser, "updateTitle(String, String)");
private void externalWindowClosing(String guid) {
externalWindows.remove(guid);
}
-
+
//***************************************************************
@SuppressWarnings("unused")
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);
+ window.getBrowserWindow().setContent(unicode);
}
// If the note is dirty, then it is unsynchronized by default.
noteCache.put(guid, unicode.toString());
if (guid.equals(currentNoteGuid)) {
noteDirty = true;
- browserWindow.getBrowser().setContent(unicode);
+ browserWindow.setContent(unicode);
}
if (save) {
thumbnailRunner.addWork("GENERATE "+ guid);
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");
}
inkNote = false;
readOnly = false;
- if (Global.showDeleted)
+ if (Global.showDeleted || currentNoteGuid == null || currentNoteGuid.equals(""))
readOnly = true;
Global.cryptCounter =0;
- if (currentNoteGuid.equals("")) {
+ if (readOnly) {
browserWindow.setReadOnly(true);
return;
}
currentNote = conn.getNoteTable().getNote(currentNoteGuid, true,true,false,false,true);
if (currentNote == null)
return;
-
- loadNoteBrowserInformation(browserWindow);
+ loadNoteBrowserInformation(browserWindow, currentNoteGuid, currentNote);
}
- private void loadNoteBrowserInformation(BrowserWindow browser) {
+ private void loadNoteBrowserInformation(BrowserWindow browser, String guid, Note note) {
NoteFormatter formatter = new NoteFormatter(logger, conn, tempFiles);
- formatter.setNote(currentNote, Global.pdfPreview());
+ formatter.setNote(note, Global.pdfPreview());
formatter.setHighlight(listManager.getEnSearch());
QByteArray js;
- if (!noteCache.containsKey(currentNoteGuid) || conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
+ if (!noteCache.containsKey(guid)) {
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> 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>");
- formatter.setNote(currentNote, Global.pdfPreview());
+ formatter.setNote(note, 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'?>", "");
- browser.getBrowser().setContent(js);
- noteCache.put(currentNoteGuid, js.toString());
+// if (Global.enableHTMLEntitiesFix) {
+// browser.getBrowser().setContent(new QByteArray(StringEscapeUtils.unescapeHtml(js.toString())));
+// } else
+ browser.setContent(js);
+ noteCache.put(guid, js.toString());
if (formatter.resourceError)
resourceErrorMessage();
+ if (formatter.formatError) {
+ waitCursor(false);
+ QMessageBox.information(this, tr("Error"),
+ tr("NeverNote had issues formatting this note." +
+ " To protect your data this note is being marked as read-only."));
+ waitCursor(true);
+ }
readOnly = formatter.readOnly;
inkNote = formatter.inkNote;
if (readOnly)
- readOnlyCache.put(currentNoteGuid, true);
+ readOnlyCache.put(guid, true);
if (inkNote)
- inkNoteCache.put(currentNoteGuid, true);
+ inkNoteCache.put(guid, true);
} else {
logger.log(logger.HIGH, "Note content is being pulled from the cache");
- String cachedContent = formatter.modifyCachedTodoTags(noteCache.get(currentNoteGuid));
+ String cachedContent = formatter.modifyCachedTodoTags(noteCache.get(guid));
js = new QByteArray(cachedContent);
- browser.getBrowser().setContent(js);
- if (readOnlyCache.containsKey(currentNoteGuid))
+ browser.setContent(js);
+ if (readOnlyCache.containsKey(guid))
readOnly = true;
- if (inkNoteCache.containsKey(currentNoteGuid))
+ if (inkNoteCache.containsKey(guid))
inkNote = true;
}
- if (conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
- thumbnailHTMLReady(currentNoteGuid, js, Global.calculateThumbnailZoom(js.toString()));
+ if (conn.getNoteTable().isThumbnailNeeded(guid)) {
+ thumbnailHTMLReady(guid, js, Global.calculateThumbnailZoom(js.toString()));
}
-
if (readOnly || inkNote)
browser.getBrowser().page().setContentEditable(false); // We don't allow editing of ink notes
else
tagButton.setEnabled(!readOnly);
menuBar.noteDelete.setEnabled(!readOnly);
menuBar.noteTags.setEnabled(!readOnly);
- browser.setNote(currentNote);
+ browser.setNote(note);
- if (conn.getNotebookTable().isLinked(currentNote.getNotebookGuid())) {
+ if (note != null && note.getNotebookGuid() != null &&
+ conn.getNotebookTable().isLinked(note.getNotebookGuid())) {
deleteButton.setEnabled(false);
menuBar.notebookDeleteAction.setEnabled(false);
} else {
nbooks.add(listManager.getNotebookIndex().get(i));
}
- browser.setTitle(currentNote.getTitle());
- browser.setTag(getTagNamesForNote(currentNote));
- browser.setAuthor(currentNote.getAttributes().getAuthor());
-
- browser.setAltered(currentNote.getUpdated());
- browser.setCreation(currentNote.getCreated());
- if (currentNote.getAttributes().getSubjectDate() > 0)
- browser.setSubjectDate(currentNote.getAttributes().getSubjectDate());
+ browser.setTitle(note.getTitle());
+ browser.setTag(getTagNamesForNote(note));
+ browser.setAuthor(note.getAttributes().getAuthor());
+
+ browser.setAltered(note.getUpdated());
+ browser.setCreation(note.getCreated());
+ if (note.getAttributes().getSubjectDate() > 0)
+ browser.setSubjectDate(note.getAttributes().getSubjectDate());
else
- browser.setSubjectDate(currentNote.getCreated());
- browser.setUrl(currentNote.getAttributes().getSourceURL());
+ browser.setSubjectDate(note.getCreated());
+ browser.setUrl(note.getAttributes().getSourceURL());
FilterEditorTags tagFilter = new FilterEditorTags(conn, logger);
- List<Tag> tagList = tagFilter.getValidTags(currentNote);
+ List<Tag> tagList = tagFilter.getValidTags(note);
browser.setAllTags(tagList);
- browser.setCurrentTags(currentNote.getTagNames());
+ browser.setCurrentTags(note.getTagNames());
noteDirty = false;
- scrollToGuid(currentNoteGuid);
+ scrollToGuid(guid);
browser.loadingData(false);
if (thumbnailViewer.isActiveWindow())
thumbnailView();
FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
- browser.setNotebookList(notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex()));
+ browser.setNotebookList(notebookFilter.getValidNotebooks(note, listManager.getNotebookIndex()));
waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNote");
return;
if (currentNoteGuid.equals(""))
return;
-
+ String title = null;
+ if (selectedNoteGUIDs.size() == 1)
+ title = conn.getNoteTable().getNote(selectedNoteGUIDs.get(0),false,false,false,false,false).getTitle();
+
// If we are deleting non-trash notes
if (currentNote.isActive()) {
if (Global.verifyDelete()) {
- if (QMessageBox.question(this, tr("Confirmation"), tr("Delete selected note(s)?"),
+ String msg;
+ if (selectedNoteGUIDs.size() > 1) {
+ msg = new String(tr("Delete ") +selectedNoteGUIDs.size() +" notes?");
+ } else {
+ if (title != null)
+ msg = new String(tr("Delete note \"") +title +"\"?");
+ else
+ msg = new String(tr("Delete note selected note?"));
+ }
+ if (QMessageBox.question(this, tr("Confirmation"), msg,
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
return;
} else {
// If we are deleting from the trash.
if (Global.verifyDelete()) {
- if (QMessageBox.question(this, "Confirmation", "Permanently delete selected note(s)?",
+ String msg;
+ if (selectedNoteGUIDs.size() > 1) {
+ msg = new String(tr("Permanently delete ") +selectedNoteGUIDs.size() +" notes?");
+ } else {
+ if (title != null)
+ msg = new String(tr("Permanently delete note \"") +title +"\"?");
+ else
+ msg = new String(tr("Permanently delete note selected note?"));
+ }
+ if (QMessageBox.question(this, "Confirmation", msg,
QMessageBox.StandardButton.Yes,
QMessageBox.StandardButton.No)==StandardButton.No.value()) {
return;
}
}
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.setUpdateSequenceNum(0);
newNote.setGuid(randint);
newNote.setNotebookGuid(notebook);
- newNote.setTitle("");
+ newNote.setTitle("Untitled Note");
newNote.setContent(noteString.toString());
newNote.setDeleted(0);
newNote.setCreated(System.currentTimeMillis());
currentNote = newNote;
currentNoteGuid = currentNote.getGuid();
+ noteTableView.clearSelection();
refreshEvernoteNote(true);
listManager.countNotebookResults(listManager.getNoteIndex());
browserWindow.titleLabel.setFocus();
// If the window is hidden, then we want to popup this in an external window &
if (!isVisible())
listDoubleClick();
+ waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.addNote");
}
// Restore a note from the trash;
// it from the cache.
@SuppressWarnings("unused")
private void invalidateNoteCache(String guid, String content) {
- String v = noteCache.remove(guid);
-// if (guid.equals(currentNoteGuid) && !noteDirty)
- refreshEvernoteNote(true);
+ noteCache.remove(guid);
+ refreshEvernoteNote(true);
}
// Signal received that a note guid has changed
@SuppressWarnings("unused")
}
private void duplicateNote(String guid) {
- Note oldNote = conn.getNoteTable().getNote(guid, true, true, false, false, false);
+ 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);
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);
}
notebookTree.selectGuid("");
}
notebookTreeSelection();
+ refreshEvernoteNote(true);
}
// Merge notes
@SuppressWarnings("unused")
// A resource within a note has had a guid change
@SuppressWarnings("unused")
private void noteResourceGuidChanged(String noteGuid, String oldGuid, String newGuid) {
- if (!oldGuid.equals(newGuid))
+ if (oldGuid != null && !oldGuid.equals(newGuid))
Global.resourceMap.put(oldGuid, newGuid);
}
// View a thumbnail of the note
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. "+
+ msg = tr("An error has happened while saving the note \"") +title+
+ tr("\".\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.";
+ "\nbe lost. Please review the note to recover any critical data before restarting.");
QMessageBox.information(this, tr("Error Saving Note"), tr(msg));
}
versions = null;
try {
if (Global.isPremium())
- versions = syncRunner.noteStore.listNoteVersions(syncRunner.authToken, currentNoteGuid);
+ versions = syncRunner.localNoteStore.listNoteVersions(syncRunner.authToken, currentNoteGuid);
else
versions = new ArrayList<NoteVersionId>();
- currentOnlineNote = syncRunner.noteStore.getNote(syncRunner.authToken, currentNoteGuid, true, true, false, false);
+ currentOnlineNote = syncRunner.localNoteStore.getNote(syncRunner.authToken, currentNoteGuid, true, true, false, false);
} catch (EDAMUserException e) {
setMessage("EDAMUserException: " +e.getMessage());
return;
return;
} catch (EDAMNotFoundException e) {
setMessage(tr("Note not found on server."));
- QMessageBox.information(this, "Error", "This note could not be found on Evernote's servers.");
+ QMessageBox.information(this, tr("Error"), tr("This note could not be found on Evernote's servers."));
return;
} catch (TException e) {
setMessage("EDAMTransactionException: " +e.getMessage());
try {
if (index > -1) {
usn = versions.get(index).getUpdateSequenceNum();
- historyNote = syncRunner.noteStore.getNoteVersion(syncRunner.authToken, currentNoteGuid, usn, true, true, true);
+ historyNote = syncRunner.localNoteStore.getNoteVersion(syncRunner.authToken, currentNoteGuid, usn, true, true, true);
} else
- historyNote = syncRunner.noteStore.getNote(syncRunner.authToken, currentNoteGuid, true,true,true,true);
+ historyNote = syncRunner.localNoteStore.getNote(syncRunner.authToken, currentNoteGuid, true,true,true,true);
} catch (EDAMUserException e) {
setMessage("EDAMUserException: " +e.getMessage());
waitCursor(false);
// 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);
+ notebooks = syncRunner.localNoteStore.listNotebooks(syncRunner.authToken);
+ tags = syncRunner.localNoteStore.listTags(syncRunner.authToken);
+ linkedNotebooks = syncRunner.localNoteStore.listLinkedNotebooks(syncRunner.authToken);
} catch (EDAMUserException e) {
setMessage("EDAMUserException: " +e.getMessage());
return;
} catch (TException e) {
setMessage("EDAMTransactionException: " +e.getMessage());
return;
+ } catch (EDAMNotFoundException e) {
+ setMessage("EDAMNotFoundException: " +e.getMessage());
+ return;
}
// Split up notebooks into synchronized & non-synchronized
}
}
- IgnoreSync ignore = new IgnoreSync(notebooks, ignoredBooks, tags, ignoredTags);
+ // 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;
}
}
- conn.getNoteTable().expungeIgnoreSynchronizedNotes(newNotebooks, newTags);
+ // 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));
+ }
+
+ 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();
}
private void resourceErrorMessage() {
if (inkNote)
return;
+ waitCursor(false);
QMessageBox.information(this, tr("DOUGH!!!"), tr("Well, this is embarrassing."+
"\n\nSome attachments or images for this note appear to be missing from my database.\n"+
"In a perfect world this wouldn't happen, but it has.\n" +
"\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.setReadOnly(true);
+ waitCursor(true);
}
syncRunner.syncDeletedContent = Global.synchronizeDeletedContent();
if (syncThreadsReady > 0) {
- indexRunner.interrupt = true;
+ thumbnailRunner.interrupt = true;
saveNoteIndexWidth();
saveNoteColumnPositions();
if (syncRunner.addWork("SYNC")) {
refreshEvernoteNote(false);
scrollToGuid(currentNoteGuid);
waitCursor(false);
+
+ // Check to see if there were any shared notebook errors
+ if (syncRunner.error && syncRunner.errorSharedNotebooks.size() > 0) {
+ String guid = syncRunner.errorSharedNotebooks.get(0);
+ String notebookGuid = conn.getLinkedNotebookTable().getLocalNotebookGuid(guid);
+ String localName = listManager.getNotebookNameByGuid(notebookGuid);
+ SharedNotebookSyncError syncDialog = new SharedNotebookSyncError(localName);
+ syncDialog.exec();
+ if (syncDialog.okPressed()) {
+ if (syncDialog.doNothing.isChecked()) {
+ syncRunner.errorSharedNotebooksIgnored.put(guid, guid);
+ evernoteSync();
+ }
+ if (syncDialog.deleteNotebook.isChecked()) {
+ conn.getNoteTable().expungeNotesByNotebook(notebookGuid, true, false);
+ conn.getNotebookTable().expungeNotebook(notebookGuid, false);
+ conn.getLinkedNotebookTable().expungeNotebook(guid, false);
+ conn.getLinkedNotebookTable().expungeNotebook(guid, false);
+ evernoteSync();
+ }
+/* if (syncDialog.convertToLocal.isChecked()) {
+ conn.getNotebookTable().convertFromSharedNotebook(notebookGuid, true);
+ conn.getLinkedNotebookTable().expungeNotebook(guid, false);
+ evernoteSync();
+ }
+ if (syncDialog.convertToShared.isChecked()) {
+ conn.getLinkedNotebookTable().expungeNotebook(guid, false);
+ conn.getNotebookTable().convertFromSharedNotebook(notebookGuid, false);
+ evernoteSync();
+ } */
+ refreshLists();
+ return;
+ }
+ }
+
+ // Finalize the synchronization
if (!syncRunner.error)
setMessage(tr("Synchronization Complete"));
else
if (syncRunning)
return;
if (!indexDisabled && indexRunner.idle) {
+ thumbnailRunner.interrupt = true;
indexRunner.addWork("SCAN");
}
logger.log(logger.EXTREME, "Leaving neverNote index timer");
alive = listManager.threadCheck(Global.tagCounterThreadId);
if (!alive) {
tagDeadCount++;
- if (tagDeadCount > MAX)
- QMessageBox.information(this, tr("A thread his died."), tr("It appears as the tag counter thread has died. I recommend "+
+ if (tagDeadCount > MAX && !disableTagThreadCheck) {
+ QMessageBox.information(this, tr("A thread has 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 has 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 has 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 has 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 has 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 has 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() && conn.getNoteTable().getThumbnailNeededCount() > 1) {
- thumbnailTimer.setInterval(10*1000);
+ if (Global.enableThumbnails() && !syncRunning && indexRunner.idle) {
thumbnailRunner.addWork("SCAN");
- } else {
- thumbnailTimer.setInterval(60*1000);
}
}
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;
}
waitCursor(true);
- setMessage("Importing Notes");
+ setMessage(tr("Importing Notes"));
saveNote();
if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
ImportData noteReader = new ImportData(conn, false);
String fileName = fd.selectedFiles().get(0);
+// saveLastPath.substring(0,fileName.lastIndexOf("/"));
if (!fileName.endsWith(".nnex"))
fileName = fileName +".nnex";
setMessage(tr("Notes have been imported."));
waitCursor(false);
- setMessage("Import completed.");
+ setMessage(tr("Import completed."));
waitCursor(false);
duplicateNote(currentNoteGuid);
}
+ //**************************************************
+ //* Action from when a user clicks Copy As URL
+ //**************************************************
+ @SuppressWarnings("unused")
+ private void copyAsUrlClicked() {
+ QClipboard clipboard = QApplication.clipboard();
+ QMimeData mime = new QMimeData();
+ String url;
+ mime.setText(currentNoteGuid);
+ List<QUrl> urls = new ArrayList<QUrl>();
+
+ // Start building the URL
+ User user = Global.getUserInformation();
+
+ // Check that we have everything we need
+ if ((user.getShardId().equals("") || user.getId() == 0) && !Global.bypassSynchronizationWarning()) {
+ SynchronizationRequiredWarning warning = new SynchronizationRequiredWarning(this);
+ warning.exec();
+ if (!warning.neverSynchronize())
+ return;
+ else {
+ Global.setBypassSynchronizationWarning(true);
+ user.setShardId("s0");
+ user.setId(0);
+ }
+ }
+
+
+ // Start building a list of URLs based upon the selected notes
+ noteTableView.showColumn(Global.noteTableGuidPosition);
+
+ List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
+ if (!Global.isColumnVisible("guid"))
+ noteTableView.hideColumn(Global.noteTableGuidPosition);
+
+ // Check that the note is either synchronized, or in a local notebook
+ for (int i=0; i<selections.size(); i++) {
+ QModelIndex index;
+ int row = selections.get(i).row();
+ index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
+ SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
+ String selectedGuid = (String)ix.values().toArray()[0];
+
+ Note n = conn.getNoteTable().getNote(selectedGuid, false, false, false, false, false);
+ if (n.getUpdateSequenceNum() == 0 && !conn.getNotebookTable().isNotebookLocal(n.getNotebookGuid())) {
+ QMessageBox.critical(this, tr("Please Synchronize") ,tr("Please either synchronize or move any " +
+ "new notes to a local notebook."));
+ return;
+ }
+ }
+
+ // Start building the URLs
+ for (int i=0; i<selections.size(); i++) {
+ QModelIndex index;
+ int row = selections.get(i).row();
+ index = noteTableView.proxyModel.index(row, Global.noteTableGuidPosition);
+ SortedMap<Integer, Object> ix = noteTableView.proxyModel.itemData(index);
+ String selectedGuid = (String)ix.values().toArray()[0];
+ mime.setText(selectedGuid);
+
+ String lid;
+ String gid;
+ Note selectedNote = conn.getNoteTable().getNote(selectedGuid, false, false, false, false, false);
+ if (selectedNote.getUpdateSequenceNum() > 0) {
+ gid = selectedGuid;
+ lid = selectedGuid;
+ } else {
+ gid = "00000000-0000-0000-0000-000000000000";
+ lid = selectedGuid;
+ }
+ url = new String("evernote://///view/") + new String(user.getId() + "/" +user.getShardId() +"/"
+ +gid+"/"+lid +"/");
+ urls.add(new QUrl(url));
+ }
+ mime.setUrls(urls);
+ clipboard.setMimeData(mime);
+ }
//**************************************************
String content = browser.getContent().substring(0,position) +
newSegment +
browser.getContent().substring(endPos);
- browser.getBrowser().setContent(new QByteArray(content));;
+ browser.setContent(new QByteArray(content));;
}
position = browser.getContent().indexOf("en-tag=\"en-media\" guid=\""+guid+"\" type=", position+1);
return true;
}
+ //*************************************************
+ //* View / Hide source HTML for a note
+ //*************************************************
+ public void viewSource() {
+ browserWindow.showSource(menuBar.viewSource.isChecked());
+ }
+ //*************************************************
+ // Block the program. This is used for things
+ // like async web calls.
+ //*************************************************
+ @SuppressWarnings("unused")
+ private void blockApplication(BrowserWindow b) {
+ // Block all signals
+ waitCursor(true);
+ blockSignals(true);
+
+ blockTimer = new QTimer();
+ blockTimer.setSingleShot(true);
+ blockTimer.setInterval(15000);
+ blockTimer.timeout.connect(this, "unblockApplication()");
+ blockingWindow = b;
+ blockTimer.start();
+ }
+
+ @SuppressWarnings("unused")
+ private void unblockApplication() {
+ waitCursor(false);
+ if (blockingWindow != null && new GregorianCalendar().getTimeInMillis() > blockingWindow.unblockTime && blockingWindow.unblockTime != -1) {
+ QMessageBox.critical(null, tr("No Response from CodeCogs") ,tr("Unable to contact CodeCogs for LaTeX formula."));
+ blockingWindow.unblockTime = -1;
+ blockingWindow.awaitingHttpResponse = false;
+ }
+ blockingWindow = null;
+ blockSignals(false);
+ }
}
OSDN Git Service
