/*
- * This file is part of NeverNote
+ * This file is part of NixNote
* Copyright 2009 Randy Baumgarte
*
* This file may be licensed under the terms of of the
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 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.evernote.NoteMetadata;
import cx.fbn.nevernote.filters.FilterEditorNotebooks;
import cx.fbn.nevernote.filters.FilterEditorTags;
import cx.fbn.nevernote.gui.AttributeTreeWidget;
import cx.fbn.nevernote.utilities.SyncTimes;
import cx.fbn.nevernote.xml.ExportData;
import cx.fbn.nevernote.xml.ImportData;
+import cx.fbn.nevernote.xml.ImportEnex;
import cx.fbn.nevernote.xml.NoteFormatter;
boolean encryptOnShutdown; // should I encrypt when I close?
boolean decryptOnShutdown; // should I decrypt on shutdown;
String encryptCipher; // What cipher should I use?
- Signal0 minimizeToTray;
+ //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 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 long blockTime; // When the app. is blocked, this is the time to unblock it.
-
+ private QTimer blockTimer;
+ BrowserWindow blockingWindow;
String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
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."));
+ "is accessing the database or NixNote is already running.\n\n" +
+ "Please end any other process or shutdown the other NixNote before starting.\n\nExiting program."));
QMessageBox.critical(null, tr("Database Connection Error") ,msg);
System.exit(16);
QApplication.setStyle(Global.getStyle());
if (Global.useStandardPalette())
QApplication.setPalette(QApplication.style().standardPalette());
- setWindowTitle("NeverNote");
+ setWindowTitle(tr("NixNote"));
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);
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();
tagTree = new TagTreeWidget(conn);
savedSearchTree = new SavedSearchTreeWidget();
trashTree = new TrashTreeWidget();
- noteTableView = new TableView(logger, listManager);
-
+ noteTableView = new TableView(logger, listManager);
searchField = new QComboBox();
searchField.setObjectName("searchField");
emitLog = new ArrayList<String>();
tagTree.setDeleteAction(menuBar.tagDeleteAction);
+ tagTree.setMergeAction(menuBar.tagMergeAction);
tagTree.setEditAction(menuBar.tagEditAction);
tagTree.setAddAction(menuBar.tagAddAction);
tagTree.setIconAction(menuBar.tagIconAction);
noteTableView.setNoteDuplicateAction(menuBar.noteDuplicateAction);
noteTableView.setNoteHistoryAction(menuBar.noteOnlineHistoryAction);
noteTableView.noteSignal.titleColorChanged.connect(this, "titleColorChanged(Integer)");
+ noteTableView.noteSignal.notePinned.connect(this, "notePinned()");
noteTableView.setMergeNotesAction(menuBar.noteMergeAction);
+ noteTableView.setCopyAsUrlAction(menuBar.noteCopyAsUrlAction);
noteTableView.doubleClicked.connect(this, "listDoubleClick()");
listManager.trashSignal.countChanged.connect(trashTree, "updateCounts(Integer)");
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("NixNote"));
trayIcon.setContextMenu(trayMenu);
trayIcon.activated.connect(this, "trayActivated(com.trolltech.qt.gui.QSystemTrayIcon$ActivationReason)");
tagTree.showAllTags(true);
QIcon appIcon = new QIcon(iconPath+"nevernote.png");
- setWindowIcon(appIcon);
- trayIcon.setIcon(appIcon);
- if (Global.showTrayIcon())
- trayIcon.show();
- else
- trayIcon.hide();
+ if (QSystemTrayIcon.isSystemTrayAvailable()) {
+ setWindowIcon(appIcon);
+ trayIcon.setIcon(appIcon);
+ if (Global.showTrayIcon() || Global.minimizeOnClose())
+ trayIcon.show();
+ else
+ trayIcon.hide();
+ }
scrollToGuid(currentNoteGuid);
if (Global.automaticLogin()) {
int sortCol = Global.getSortColumn();
int sortOrder = Global.getSortOrder();
+ noteTableView.proxyModel.blocked = true;
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+ noteTableView.proxyModel.blocked = false;
+ noteTableView.proxyModel.sortChanged.connect(this, "tableSortOrderChanged(Integer,Integer)");
+
+ // Set the startup notebook
+ String defaultNotebook = Global.getStartupNotebook();
+ if (!defaultNotebook.equals("AllNotebooks") && !defaultNotebook.equals("")) {
+ for (int k=0; k<listManager.getNotebookIndex().size(); k++) {
+ if (listManager.getNotebookIndex().get(k).isDefaultNotebook()) {
+ notebookTree.clearSelection();
+ notebookTree.selectGuid(listManager.getNotebookIndex().get(k).getGuid());
+ notebookTree.selectionSignal.emit();
+ }
+ }
+ }
+
if (Global.checkVersionUpgrade())
checkForUpdates();
}
}
NeverNote application = new NeverNote(dbConn);
+ if (Global.syncOnly) {
+ System.out.println("Performing synchronization only.");
+ application.remoteConnect();
+ if (Global.isConnected) {
+ application.syncRunner.syncNeeded = true;
+ application.syncRunner.addWork("SYNC");
+ application.syncRunner.addWork("STOP");
+ while(!application.syncRunner.isIdle());
+ application.closeNeverNote();
+ }
+ return;
+ }
application.setAttribute(WidgetAttribute.WA_DeleteOnClose, true);
if (Global.startMinimized())
ApplicationLogger logger = new ApplicationLogger("nevernote-database.log");
File f = Global.getFileManager().getDbDirFile(Global.databaseName + ".h2.db");
- boolean dbExists = f.exists();
- if (!dbExists)
+ File fr = Global.getFileManager().getDbDirFile(Global.resourceDatabaseName + ".h2.db");
+ File fi = Global.getFileManager().getDbDirFile(Global.resourceDatabaseName + ".h2.db");
+ if (!f.exists())
Global.setDatabaseUrl("");
+ if (!fr.exists())
+ Global.setResourceDatabaseUrl("");
+ if (!fi.exists())
+ Global.setIndexDatabaseUrl("");
if (Global.getDatabaseUrl().toUpperCase().indexOf("CIPHER=") > -1) {
boolean goodCheck = false;
// 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");
+ st = conn.getResourceConnection().createStatement();
+ st.execute("shutdown");
+ st = conn.getIndexConnection().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);
+ ChangeFileEncryption.execute(dbPath, "NeverNote", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
+ ChangeFileEncryption.execute(dbPath, "Resources", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
+ ChangeFileEncryption.execute(dbPath, "Index", encryptCipher, null, Global.cipherPassword.toCharArray(), true);
Global.setDatabaseUrl(Global.getDatabaseUrl() + ";CIPHER="+encryptCipher);
- QMessageBox.information(this, "Encryption Complete", "Encryption is complete");
+ Global.setResourceDatabaseUrl(Global.getResourceDatabaseUrl() + ";CIPHER="+encryptCipher);
+ Global.setIndexDatabaseUrl(Global.getIndexDatabaseUrl() + ";CIPHER="+encryptCipher);
+
+ QMessageBox.information(this, tr("Encryption Complete"), tr("Encryption is complete"));
}
} catch (SQLException e) {
e.printStackTrace();
ChangeFileEncryption.execute(dbPath, dbName, encryptCipher, Global.cipherPassword.toCharArray(), null, true);
Global.setDatabaseUrl("");
+ Global.setResourceDatabaseUrl("");
+ Global.setIndexDatabaseUrl("");
QMessageBox.information(this, tr("Decryption Complete"), tr("Decryption is complete"));
}
} catch (SQLException e) {
}
} else {
DBEncryptDialog dialog = new DBEncryptDialog();
- dialog.setWindowTitle("Database Decryption");
+ dialog.setWindowTitle(tr("Database Decryption"));
dialog.hideEncryption();
dialog.exec();
if (dialog.okPressed()) {
startupConfig.setHomeDirPath(arg.substring(arg.indexOf('=') + 1));
if (lower.startsWith("--disable-viewing"))
startupConfig.setDisableViewing(true);
+ if (lower.startsWith("--sync-only=true"))
+ startupConfig.setSyncOnly(true);
}
- Global.setup(startupConfig);
+ Global.setup(startupConfig);
+
}
// Exit point
@Override
public void closeEvent(QCloseEvent event) {
- if (Global.minimizeOnClose() && !closeAction && Global.showTrayIcon()) {
+ if (Global.minimizeOnClose() && !closeAction) {
event.ignore();
hide();
return;
waitCursor(true);
if (currentNote!= null & browserWindow!=null) {
- if (!currentNote.getTitle().equals(browserWindow.getTitle()))
+ if (currentNote.getTitle() != null && browserWindow != null
+ && !currentNote.getTitle().equals(browserWindow.getTitle()))
conn.getNoteTable().updateNoteTitle(currentNote.getGuid(), browserWindow.getTitle());
}
saveNote();
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)");
}
//**************************************************
settings.exec();
indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
- if (Global.showTrayIcon())
+ indexRunner.indexNoteBody = Global.indexNoteBody();
+ indexRunner.indexNoteTitle = Global.indexNoteTitle();
+ indexRunner.specialIndexCharacters = Global.getSpecialIndexCharacters();
+ indexRunner.indexImageRecognition = Global.indexImageRecognition();
+ if (Global.showTrayIcon() || Global.minimizeOnClose())
trayIcon.show();
else
trayIcon.hide();
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
Global.setColumnPosition("noteTableGuidPosition", position);
position = noteTableView.header.visualIndex(Global.noteTableThumbnailPosition);
Global.setColumnPosition("noteTableThumbnailPosition", position);
+ position = noteTableView.header.visualIndex(Global.noteTablePinnedPosition);
+ Global.setColumnPosition("noteTablePinnedPosition", position);
}
// Save column widths for the next time
Global.setColumnWidth("noteTableThumbnailPosition", width);
width = noteTableView.getColumnWidth(Global.noteTableGuidPosition);
Global.setColumnWidth("noteTableGuidPosition", width);
+ width = noteTableView.getColumnWidth(Global.noteTablePinnedPosition);
+ Global.setColumnWidth("noteTablePinnedPosition", width);
}
@SuppressWarnings("unused")
// Listener when a notebook is selected
private void notebookTreeSelection() {
logger.log(logger.HIGH, "Entering NeverNote.notebookTreeSelection");
-
+ noteTableView.proxyModel.blocked = true;
+
clearTrashFilter();
clearAttributeFilter();
clearSavedSearchFilter();
refreshEvernoteNote(true);
listManager.refreshCounters = true;
listManager.refreshCounters();
+ if (selectedNotebookGUIDs.size() == 1) {
+ int col = conn.getNotebookTable().getSortColumn(selectedNotebookGUIDs.get(0));
+ int order = conn.getNotebookTable().getSortOrder(selectedNotebookGUIDs.get(0));
+ if (col != -1) {
+ noteTableView.proxyModel.blocked = true;
+ if (order == 1)
+ noteTableView.sortByColumn(col, Qt.SortOrder.DescendingOrder);
+ else
+ noteTableView.sortByColumn(col, Qt.SortOrder.AscendingOrder);
+ }
+ }
+ noteTableView.proxyModel.blocked = false;
logger.log(logger.HIGH, "Leaving NeverNote.notebookTreeSelection");
}
if (tagTree.selectedItems().size() > 0)
filter = true;
tagTree.showAllTags(!filter);
+ tagIndexUpdated(false);
logger.log(logger.HIGH, "Leaving NeverNote.reloadTagTree");
}
// Edit an existing tag
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);
tagTree.clearSelection();
menuBar.noteRestoreAction.setVisible(false);
menuBar.tagEditAction.setEnabled(false);
+ menuBar.tagMergeAction.setEnabled(false);
menuBar.tagDeleteAction.setEnabled(false);
menuBar.tagIconAction.setEnabled(false);
selectedTagGUIDs.clear();
}
}
+ // 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;
logger.log(logger.HIGH, "Entering NeverNote.compactDatabase");
if (QMessageBox.question(this, tr("Confirmation"), tr("This will free unused space in the database, "+
"but please be aware that depending upon the size of your database this can be time consuming " +
- "and NeverNote will be unresponsive until it is complete. Do you wish to continue?"),
+ "and NixNote 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;
QTextEdit textBox = new QTextEdit();
layout.addWidget(textBox);
textBox.setReadOnly(true);
- QFile file = new QFile(Global.getFileManager().getHomeDirPath("release.txt"));
+ QFile file = new QFile(Global.getFileManager().getProgramDirPath("release.txt"));
if (!file.open(new QIODevice.OpenMode(QIODevice.OpenModeFlag.ReadOnly,
QIODevice.OpenModeFlag.Text)))
return;
private void about() {
logger.log(logger.HIGH, "Entering NeverNote.about");
QMessageBox.about(this,
- tr("About NeverNote"),
- tr("<h4><center><b>NeverNote</b></center></h4><hr><center>Version ")
- +Global.version
- +tr("<hr></center>Evernote"
- +"An Open Source Evernote Client.<br><br>"
+ tr("About NixNote"),
+ tr("<h4><center><b>NixNote</b></center></h4><hr><center>Version ")
+ //+Global.version
+ +"1.2.120404"
+ +tr("<hr>"
+ +"Open Source Evernote Client.<br><br>"
+"Licensed under GPL v2. <br><hr><br>"
- +"Evernote is copyright 2001-2010 by Evernote Corporation<br>"
+ +"</center>Evernote is copyright 2001-2012 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>"
}
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.setEnSearch(text.trim());
listManager.loadNotesIndex();
noteIndexUpdated(false);
+
refreshEvernoteNote(true);
searchPerformed = true;
+ waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.searchFieldChanged");
}
// toolBar.addWidget(menuBar);
// menuBar.setSizePolicy(Policy.Minimum, Policy.Minimum);
// toolBar.addSeparator();
- prevButton = toolBar.addAction("Previous");
+ 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);
}
// Synchronize with Evernote
- @SuppressWarnings("unused")
+
private void evernoteSync() {
logger.log(logger.HIGH, "Entering NeverNote.evernoteSync");
if (!Global.isConnected)
menuBar.noteRestoreAction.setVisible(false);
}
else {
+ trashNoteGuid = tempGuid;
currentNoteGuid = trashNoteGuid;
- trashNoteGuid = tempGuid;
menuBar.noteRestoreAction.setEnabled(true);
menuBar.noteRestoreAction.setVisible(true);
Global.showDeleted = true;
@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();
@SuppressWarnings("unused")
private void noteTableSelection() {
logger.log(logger.HIGH, "Entering NeverNote.noteTableSelection");
+
saveNote();
+
+ // If we have more than one selection, then set the merge note action to true.
+ List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
+ if (selections.size() > 1)
+ menuBar.noteMergeAction.setEnabled(true);
+ else
+ menuBar.noteMergeAction.setEnabled(false);
+
+ // 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;
}
noteTableView.showColumn(Global.noteTableGuidPosition);
- List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
if (!Global.isColumnVisible("guid"))
noteTableView.hideColumn(Global.noteTableGuidPosition);
browserWindow.setDisabled(true);
}
+ if (Global.showDeleted && listManager.getNotebookIndex().size() > 0 && saveCurrentNoteGuid.equals("")) {
+ currentNoteGuid = listManager.getNoteIndex().get(0).getGuid();
+ saveCurrentNoteGuid = currentNoteGuid;
+ refreshEvernoteNote(true);
+ }
+
if (!saveCurrentNoteGuid.equals("")) {
refreshEvernoteNote(false);
} else {
- currentNoteGuid = "";
+ currentNoteGuid = "";
}
reloadTagTree(false);
noteTableView.setColumnHidden(Global.noteTableSynchronizedPosition, !Global.isColumnVisible("synchronized"));
noteTableView.setColumnHidden(Global.noteTableGuidPosition, !Global.isColumnVisible("guid"));
noteTableView.setColumnHidden(Global.noteTableThumbnailPosition, !Global.isColumnVisible("thumbnail"));
- noteTableView.setColumnHidden(Global.noteTableTitlePosition, !Global.isColumnVisible("title"));
+ noteTableView.setColumnHidden(Global.noteTableTitlePosition, !Global.isColumnVisible("title"));
+ noteTableView.setColumnHidden(Global.noteTablePinnedPosition, !Global.isColumnVisible("pinned"));
}
// Title color has changed
@SuppressWarnings("unused")
private void titleColorChanged(Integer color) {
- logger.log(logger.HIGH, "Entering NeverNote.updateListAuthor");
+ logger.log(logger.HIGH, "Entering NeverNote.titleColorChanged");
+ setNoteDirty();
QColor backgroundColor = new QColor();
QColor foregroundColor = new QColor(QColor.black);
backgroundColor.setRgb(color);
}
}
}
- logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
+ logger.log(logger.HIGH, "Leaving NeverNote.titleColorChanged");
+ }
+ // A note has been pinned or unpinned
+ @SuppressWarnings("unused")
+ private void notePinned() {
+ logger.log(logger.EXTREME, "Entering NeverNote.notePinned()");
+ setNoteDirty();
+
+ for (int j=0; j<selectedNoteGUIDs.size(); j++) {
+ NoteMetadata meta = listManager.getNoteMetadata().get(selectedNoteGUIDs.get(j));
+ boolean pinned = !meta.isPinned();
+ meta.setPinned(pinned); // Toggle the pinned/unpinned
+
+ // Update the list & table
+ listManager.updateNoteMetadata(meta);
+ noteTableView.proxyModel.addGuid(selectedNoteGUIDs.get(j), meta);
+ }
+
+ logger.log(logger.EXTREME, "Leaving NeverNote.setNoteDirty()");
}
// Wide list was chosen
public void narrowListView() {
sortCol = Global.getSortColumn();
sortOrder = Global.getSortOrder();
+ noteTableView.proxyModel.blocked = true;
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+ noteTableView.proxyModel.blocked = false;
+
showColumns();
noteTableView.load(false);
sortCol = Global.getSortColumn();
sortOrder = Global.getSortOrder();
+ noteTableView.proxyModel.blocked = true;
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
-
+ noteTableView.proxyModel.blocked = false;
+
showColumns();
noteTableView.load(false);
scrollToCurrentGuid();
}
+ // Sort order for the notebook has changed
+ public void tableSortOrderChanged(Integer column, Integer order) {
+
+ // Find what notebook (if any) is selected. We ignore stacks & the "All Notebooks".
+ List<QTreeWidgetItem> selectedNotebook = notebookTree.selectedItems();
+ if (selectedNotebook.size() > 0 && !selectedNotebook.get(0).text(0).equalsIgnoreCase("All Notebooks") && !selectedNotebook.get(0).text(2).equalsIgnoreCase("STACK")) {
+ QTreeWidgetItem currentSelectedNotebook = selectedNotebook.get(0);
+ String notebook;
+ notebook = currentSelectedNotebook.text(2);
+ conn.getNotebookTable().setSortOrder(notebook, column, order);
+ }
+ }
-
+ //***************************************************************
+ @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.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)");
browserWindow.noteSignal.notebookChanged.connect(newBrowser, "updateNotebook(String, String)");
- browserWindow.blockApplication.connect(this, "blockApplication(Long)");
- browserWindow.unblockApplication.connect(this, "unblockApplication()");
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);
private void externalWindowClosing(String guid) {
externalWindows.remove(guid);
}
-
+
//***************************************************************
//** These functions deal with Note specific things
//***************************************************************
//***************************************************************
- @SuppressWarnings("unused")
private void setNoteDirty() {
logger.log(logger.EXTREME, "Entering NeverNote.setNoteDirty()");
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.
// Set the note as dirty and check if its status is synchronized in the display table
noteDirty = true;
- for (int i=0; i<listManager.getUnsynchronizedNotes().size(); i++) {
- if (listManager.getUnsynchronizedNotes().get(i).equals(currentNoteGuid))
+ if (listManager.getNoteMetadata().containsKey(currentNoteGuid) &&
+ listManager.getNoteMetadata().get(currentNoteGuid).isDirty()) {
return;
}
// If this wasn't already marked as unsynchronized, then we need to update the table
listManager.getNoteTableModel().updateNoteSyncStatus(currentNoteGuid, false);
-/* listManager.getUnsynchronizedNotes().add(currentNoteGuid);
+// listManager.getUnsynchronizedNotes().add(currentNoteGuid);
for (int i=0; i<listManager.getNoteTableModel().rowCount(); i++) {
QModelIndex modelIndex = listManager.getNoteTableModel().index(i, Global.noteTableGuidPosition);
if (modelIndex != null) {
SortedMap<Integer, Object> ix = listManager.getNoteTableModel().itemData(modelIndex);
String tableGuid = (String)ix.values().toArray()[0];
if (tableGuid.equals(currentNoteGuid)) {
- listManager.getNoteTableModel().setData(i, Global.noteTableSynchronizedPosition, "false");
+ listManager.getNoteTableModel().proxyModel.setData(i, Global.noteTableSynchronizedPosition, "false");
return;
}
}
}
- */
+
logger.log(logger.EXTREME, "Leaving NeverNote.setNoteDirty()");
}
@SuppressWarnings("unused")
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");
Global.cryptCounter =0;
if (readOnly) {
browserWindow.setReadOnly(true);
- return;
}
if (!reload)
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 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> img { height:auto; width:auto; max-height:auto; max-width:100%; }</style>");
+ if (Global.displayRightToLeft())
+ js.append("<style> body { direction:rtl; }</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("NixNote 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)
+ if (readOnly || inkNote ||
+ (note.getAttributes() != null && note.getAttributes().getContentClass() != null && note.getAttributes().getContentClass() != ""))
browser.getBrowser().page().setContentEditable(false); // We don't allow editing of ink notes
else
browser.getBrowser().page().setContentEditable(true);
tagButton.setEnabled(!readOnly);
menuBar.noteDelete.setEnabled(!readOnly);
menuBar.noteTags.setEnabled(!readOnly);
- browser.setNote(currentNote);
+ browser.setNote(note);
- if (currentNote != null && currentNote.getNotebookGuid() != null &&
- 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.setTitle(note.getTitle());
+ browser.setTag(getTagNamesForNote(note));
+ browser.setAuthor(note.getAttributes().getAuthor());
- browser.setAltered(currentNote.getUpdated());
- browser.setCreation(currentNote.getCreated());
- if (currentNote.getAttributes().getSubjectDate() > 0)
- browser.setSubjectDate(currentNote.getAttributes().getSubjectDate());
+ 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");
String notebook = null;
listManager.getNotebookIndex().get(0).getGuid();
List<QTreeWidgetItem> selectedNotebook = notebookTree.selectedItems();
- if (selectedNotebook.size() > 0 && !selectedNotebook.get(0).text(0).equalsIgnoreCase("All Notebooks")) {
+ if (selectedNotebook.size() > 0 && !selectedNotebook.get(0).text(0).equalsIgnoreCase("All Notebooks") && !selectedNotebook.get(0).text(2).equalsIgnoreCase("STACK")) {
QTreeWidgetItem currentSelectedNotebook = selectedNotebook.get(0);
notebook = currentSelectedNotebook.text(2);
} else {
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());
}
conn.getNoteTable().addNote(newNote, true);
- listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- listManager.addNote(newNote);
+ NoteMetadata metadata = new NoteMetadata();
+ metadata.setGuid(newNote.getGuid());
+ metadata.setDirty(true);
+ listManager.addNote(newNote, metadata);
// noteTableView.insertRow(newNote, true, -1);
currentNote = newNote;
// 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;
@SuppressWarnings("unused")
private void updateNoteTitle(String guid, String title) {
listManager.setNoteSynchronized(guid, false);
+
+ // We do this manually because if we've edited the note in an
+ // external window we run into the possibility of signal recursion
+ // looping.
+ if (guid.equals(currentNoteGuid)) {
+ browserWindow.titleLabel.blockSignals(true);
+ browserWindow.titleLabel.setText(title);
+ browserWindow.titleLabel.blockSignals(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 (guid.equals(currentNoteGuid) && !noteDirty)
- refreshEvernoteNote(true);
+ noteCache.remove(guid);
+ refreshEvernoteNote(true);
}
// Signal received that a note guid has changed
@SuppressWarnings("unused")
for (int i=0; i<listManager.getNoteIndex().size(); i++) {
if (listManager.getNoteIndex().get(i).getGuid().equals(newGuid)) {
- noteTableView.proxyModel.addGuid(newGuid);
+ noteTableView.proxyModel.addGuid(newGuid, listManager.getNoteMetadata().get(newGuid));
i=listManager.getNoteIndex().size();
}
}
- if (listManager.getNoteTableModel().titleColors.containsKey(oldGuid)) {
- int color = listManager.getNoteTableModel().titleColors.get(oldGuid);
- listManager.getNoteTableModel().titleColors.put(newGuid, color);
- listManager.getNoteTableModel().titleColors.remove(oldGuid);
+ if (listManager.getNoteTableModel().metaData.containsKey(oldGuid)) {
+ NoteMetadata meta = listManager.getNoteTableModel().metaData.get(oldGuid);
+ listManager.getNoteTableModel().metaData.put(newGuid, meta);
+ listManager.getNoteTableModel().metaData.remove(oldGuid);
}
}
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.setContent(conn.getNoteTable().getNoteContentNoUTFConversion(guid));
oldNote.setResources(resList);
duplicateNote(oldNote);
}
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);
+ NoteMetadata metaData = new NoteMetadata();
+ NoteMetadata oldMeta = listManager.getNoteMetadata().get(oldNote.getGuid());
+ metaData.copy(oldMeta);
+ metaData.setGuid(newNote.getGuid());
+ listManager.addNote(newNote, metaData);
+ noteTableView.insertRow(newNote, metaData, true, -1);
currentNoteGuid = newNote.getGuid();
currentNote = newNote;
refreshEvernoteNote(true);
// 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 NixNote 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));
}
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());
n.getResources().get(i).setActive(true);
conn.getNoteTable().noteResourceTable.saveNoteResource(n.getResources().get(i), true);
}
- listManager.addNote(n);
+ NoteMetadata metadata = new NoteMetadata();
+ metadata.setGuid(n.getGuid());
+ listManager.addNote(n, metadata);
conn.getNoteTable().addNote(n, true);
refreshEvernoteNote(true);
setMessage(tr("Note has been restored."));
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);
}
if (currentNote == null) {
currentNote = conn.getNoteTable().getNote(currentNoteGuid, false, false, false, false, true);
}
- listManager.setUnsynchronizedNotes(conn.getNoteTable().getUnsynchronizedGUIDs());
- noteIndexUpdated(false);
+ listManager.refreshNoteMetadata();
+ noteIndexUpdated(true);
noteTableView.selectionModel().blockSignals(true);
scrollToGuid(currentNoteGuid);
noteTableView.selectionModel().blockSignals(false);
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();
+ }
+ refreshLists();
+ return;
+ }
+ }
+
+ // Finalize the synchronization
if (!syncRunner.error)
setMessage(tr("Synchronization Complete"));
else
}
public void refreshLists() {
logger.log(logger.EXTREME, "Entering NeverNote.refreshLists");
- System.out.println("<><><><><><><><><><><><><><><><><><><><>");
updateQuotaBar();
listManager.refreshLists(currentNote, noteDirty, browserWindow.getContent());
tagIndexUpdated(true);
thumbnailRunner.interrupt = true;
indexRunner.addWork("SCAN");
}
- logger.log(logger.EXTREME, "Leaving neverNote index timer");
+ logger.log(logger.EXTREME, "Leaving NixNote index timer");
}
@SuppressWarnings("unused")
if (!alive) {
tagDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), tr("It appears as the tag counter thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableTagThreadCheck = true;
}
} else
if (!alive) {
notebookThreadDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), tr("It appears as the notebook counter thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableNotebookThreadCheck=true;
}
} else
if (!alive) {
trashDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), ("It appears as the trash counter thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableTrashThreadCheck = true;
}
} else
if (!alive) {
saveThreadDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), tr("It appears as the note saver thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableSaveThreadCheck = true;
}
} else
if (!syncThread.isAlive()) {
syncThreadDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), tr("It appears as the synchronization thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableSyncThreadCheck = true;
}
} else
if (!indexThread.isAlive()) {
indexThreadDeadCount++;
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."));
+ QMessageBox.information(this, tr("A thread has died."), tr("It appears as the index thread has died. I recommend "+
+ "checking stopping NixNote, saving the logs for later viewing, and restarting. Sorry."));
disableIndexThreadCheck = true;
}
} else
fd.setFileMode(FileMode.AnyFile);
fd.setConfirmOverwrite(true);
fd.setWindowTitle(tr("Backup Database"));
- fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
+ fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptSave);
if (saveLastPath == null || saveLastPath.equals(""))
fd.setDirectory(System.getProperty("user.home"));
fd.setFileMode(FileMode.ExistingFile);
fd.setConfirmOverwrite(true);
fd.setWindowTitle(tr("Restore Database"));
- fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
+ fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
if (saveLastPath == null || saveLastPath.equals(""))
fd.setDirectory(System.getProperty("user.home"));
fd.setFileMode(FileMode.AnyFile);
fd.setConfirmOverwrite(true);
fd.setWindowTitle(tr("Backup Database"));
- fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
+ fd.setFilter(tr("NixNote Export (*.nnex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptSave);
fd.setDirectory(System.getProperty("user.home"));
if (fd.exec() == 0 || fd.selectedFiles().size() == 0) {
fd.setFileMode(FileMode.ExistingFile);
fd.setConfirmOverwrite(true);
fd.setWindowTitle(tr("Import Notes"));
- fd.setFilter(tr("NeverNote Export (*.nnex);;All Files (*.*)"));
+ fd.setFilter(tr("NixNote Export (*.nnex);;Evernote Export (*.enex);;All Files (*.*)"));
fd.setAcceptMode(AcceptMode.AcceptOpen);
if (saveLastPath == null || saveLastPath.equals(""))
fd.setDirectory(System.getProperty("user.home"));
waitCursor(true);
- setMessage("Importing Notes");
+ setMessage(tr("Importing Notes"));
saveNote();
if (selectedNoteGUIDs.size() == 0 && !currentNoteGuid.equals(""))
selectedNoteGUIDs.add(currentNoteGuid);
- ImportData noteReader = new ImportData(conn, false);
String fileName = fd.selectedFiles().get(0);
// saveLastPath.substring(0,fileName.lastIndexOf("/"));
- if (!fileName.endsWith(".nnex"))
- fileName = fileName +".nnex";
- if (selectedNotebookGUIDs != null && selectedNotebookGUIDs.size() > 0)
- noteReader.setNotebookGuid(selectedNotebookGUIDs.get(0));
- else
- noteReader.setNotebookGuid(listManager.getNotebookIndex().get(0).getGuid());
+ if (fileName.endsWith(".nnex")) {
+ ImportData noteReader = new ImportData(conn, false);
+ if (selectedNotebookGUIDs != null && selectedNotebookGUIDs.size() > 0)
+ noteReader.setNotebookGuid(selectedNotebookGUIDs.get(0));
+ else
+ noteReader.setNotebookGuid(listManager.getNotebookIndex().get(0).getGuid());
- noteReader.importData(fileName);
+ noteReader.importData(fileName);
- if (noteReader.lastError != 0) {
- setMessage(noteReader.getErrorMessage());
- logger.log(logger.LOW, "Import problem: " +noteReader.lastError);
- waitCursor(false);
- return;
+ if (noteReader.lastError != 0) {
+ setMessage(noteReader.getErrorMessage());
+ logger.log(logger.LOW, "Import problem: " +noteReader.lastError);
+ waitCursor(false);
+ return;
+ }
+ } else {
+ if (fileName.endsWith(".enex")) {
+ ImportEnex noteReader = new ImportEnex(conn, false);
+ if (selectedNotebookGUIDs != null && selectedNotebookGUIDs.size() > 0)
+ noteReader.setNotebookGuid(selectedNotebookGUIDs.get(0));
+ else
+ noteReader.setNotebookGuid(listManager.getNotebookIndex().get(0).getGuid());
+
+ waitCursor(false);
+ if (QMessageBox.question(this, tr("Confirmation"),
+ tr("Create new tags from import?"),
+ QMessageBox.StandardButton.Yes,
+ QMessageBox.StandardButton.No) == StandardButton.Yes.value()) {
+ noteReader.createNewTags = true;
+ } else
+ noteReader.createNewTags = false;
+ waitCursor(true);
+ noteReader.importData(fileName);
+
+ if (noteReader.lastError != 0) {
+ setMessage(noteReader.getErrorMessage());
+ logger.log(logger.LOW, "Import problem: " +noteReader.lastError);
+ waitCursor(false);
+ return;
+ }
+ }
}
listManager.loadNoteTitleColors();
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);
+ }
//**************************************************
Note newNote = importer.getNote();
newNote.setNotebookGuid(notebook);
newNote.setTitle(dir.at(i));
- listManager.addNote(newNote);
+ NoteMetadata metadata = new NoteMetadata();
+ metadata.setDirty(true);
+ metadata.setGuid(newNote.getGuid());
+ listManager.addNote(newNote, metadata);
conn.getNoteTable().addNote(newNote, true);
- listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(newNote, true, -1);
+ noteTableView.insertRow(newNote, metadata, true, -1);
listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
listManager.countNotebookResults(listManager.getNoteIndex());
importedFiles.add(list.get(i).absoluteFilePath());
Note newNote = importer.getNote();
newNote.setNotebookGuid(notebook);
newNote.setTitle(dir.at(i));
- listManager.addNote(newNote);
+ NoteMetadata metadata = new NoteMetadata();
+ metadata.setDirty(true);
+ metadata.setGuid(newNote.getGuid());
+ listManager.addNote(newNote, metadata);
conn.getNoteTable().addNote(newNote, true);
- listManager.getUnsynchronizedNotes().add(newNote.getGuid());
- noteTableView.insertRow(newNote, true, -1);
+ noteTableView.insertRow(newNote, metadata, true, -1);
listManager.updateNoteContent(newNote.getGuid(), importer.getNoteContent());
listManager.countNotebookResults(listManager.getNoteIndex());
dir.remove(dir.at(i));
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);
@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 (QSystemTrayIcon.isSystemTrayAvailable()) {
+ if (isMinimized() && (Global.showTrayIcon() || Global.showTrayIcon())) {
+ e.accept();
+ QTimer.singleShot(10, this, "hide()");
+ return;
+ }
+ if (isMaximized())
+ windowMaximized = true;
+ else
+ windowMaximized = false;
}
- if (isMaximized())
- windowMaximized = true;
- else
- windowMaximized = false;
}
}
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(Long time) {
- Calendar currentTime = new GregorianCalendar();
+ private void blockApplication(BrowserWindow b) {
+ // Block all signals
waitCursor(true);
- blockTime = new Long(currentTime.getTimeInMillis())+time;
-
- for (;currentTime.getTimeInMillis()>blockTime;) {
- try {
- wait(1);
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- waitCursor(false);
- }
-
+ 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() {
- blockTime = -1;
+ 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
