import java.util.SortedMap;
import java.util.Vector;
+import org.apache.log4j.Level;
+import org.apache.log4j.Logger;
import org.apache.thrift.TException;
import org.h2.tools.ChangeFileEncryption;
import com.evernote.edam.notestore.NoteFilter;
import com.evernote.edam.notestore.NoteVersionId;
import com.evernote.edam.type.Data;
+import com.evernote.edam.type.LinkedNotebook;
import com.evernote.edam.type.Note;
import com.evernote.edam.type.NoteAttributes;
import com.evernote.edam.type.Notebook;
+import com.evernote.edam.type.Publishing;
import com.evernote.edam.type.QueryFormat;
import com.evernote.edam.type.Resource;
import com.evernote.edam.type.SavedSearch;
import com.trolltech.qt.gui.QTextEdit;
import com.trolltech.qt.gui.QToolBar;
import com.trolltech.qt.gui.QTreeWidgetItem;
+import com.trolltech.qt.network.QNetworkAccessManager;
+import com.trolltech.qt.network.QNetworkReply;
+import com.trolltech.qt.network.QNetworkRequest;
import com.trolltech.qt.webkit.QWebPage.WebAction;
import com.trolltech.qt.webkit.QWebSettings;
import cx.fbn.nevernote.dialog.DatabaseLoginDialog;
import cx.fbn.nevernote.dialog.DatabaseStatus;
import cx.fbn.nevernote.dialog.FindDialog;
+import cx.fbn.nevernote.dialog.IgnoreSync;
import cx.fbn.nevernote.dialog.LoginDialog;
import cx.fbn.nevernote.dialog.NotebookArchive;
import cx.fbn.nevernote.dialog.NotebookEdit;
import cx.fbn.nevernote.dialog.OnlineNoteHistory;
+import cx.fbn.nevernote.dialog.PublishNotebook;
import cx.fbn.nevernote.dialog.SavedSearchEdit;
import cx.fbn.nevernote.dialog.SetIcon;
+import cx.fbn.nevernote.dialog.ShareNotebook;
import cx.fbn.nevernote.dialog.StackNotebook;
import cx.fbn.nevernote.dialog.TagEdit;
import cx.fbn.nevernote.dialog.ThumbnailViewer;
+import cx.fbn.nevernote.dialog.UpgradeAvailableDialog;
import cx.fbn.nevernote.dialog.WatchFolder;
+import cx.fbn.nevernote.filters.FilterEditorNotebooks;
+import cx.fbn.nevernote.filters.FilterEditorTags;
import cx.fbn.nevernote.gui.AttributeTreeWidget;
import cx.fbn.nevernote.gui.BrowserWindow;
import cx.fbn.nevernote.gui.DateAttributeFilterTable;
QAction trayExitAction; // Exit the application
QAction trayShowAction; // toggle the show/hide action
QAction trayAddNoteAction; // Add a note from the system tray
+ QNetworkAccessManager versionChecker; // Used when checking for new versions
NotebookTreeWidget notebookTree; // List of notebooks
AttributeTreeWidget attributeTree; // List of note attributes
ApplicationLogger logger;
List<String> selectedNotebookGUIDs; // List of notebook GUIDs
List<String> selectedTagGUIDs; // List of selected tag GUIDs
- String previousSelectedTag; // Tag that was selected last time
List<String> selectedNoteGUIDs; // List of selected notes
- String previousSelectedNotebook; // Notebook selected last time
String selectedSavedSearchGUID; // Currently selected saved searches
private final HashMap<String, ExternalBrowse> externalWindows; // Notes being edited by an external window;
String currentNoteGuid; // GUID of the current note
Note currentNote; // The currently viewed note
boolean noteDirty; // Has the note been changed?
- boolean inkNote; // if this is an ink note, it is read only
+ boolean inkNote; // if this is an ink note, it is read only
+ boolean readOnly; // Is this note read-only?
+
ListManager listManager; // DB runnable task
QAction synchronizeButton; // Synchronize with Evernote
QAction allNotesButton; // Reset & view all notes
QTimer synchronizeAnimationTimer; // Timer to change animation button
- double synchronizeIconAngle; // Used to rotate sync icon
+ int synchronizeIconAngle; // Used to rotate sync icon
QAction printButton; // Print Button
QAction tagButton; // Tag edit button
QAction attributeButton; // Attribute information button
int saveThreadDeadCount=0; // number of consecutive dead times for the save thread
HashMap<String, String> noteCache; // Cash of note content
+ HashMap<String, Boolean> readOnlyCache; // List of cashe notes that are read-only
+ HashMap<String, Boolean> inkNoteCache; // List of cache notes that are ink notes
List<String> historyGuids; // GUIDs of previously viewed items
int historyPosition; // Position within the viewed items
boolean fromHistory; // Is this from the history queue?
Signal0 minimizeToTray;
boolean windowMaximized = false; // Keep track of the window state for restores
List<String> pdfReadyQueue; // Queue of PDFs that are ready to be rendered.
+ List<QPixmap> syncIcons; // Array of icons used in sync animation
+ private boolean closeAction = false; // Used to say when to close or when to minimize
+ private static Logger log = Logger.getLogger(NeverNote.class);
String iconPath = new String("classpath:cx/fbn/nevernote/icons/");
//***************************************************************
//***************************************************************
// Application Constructor
+ @SuppressWarnings("static-access")
public NeverNote(DatabaseConnection dbConn) {
conn = dbConn;
if (conn.getConnection() == null) {
logger.log(logger.EXTREME, "Building index runners & timers");
indexRunner = new IndexRunner("indexRunner.log", Global.getDatabaseUrl(), Global.getDatabaseUserid(), Global.getDatabaseUserPassword(), Global.cipherPassword);
indexThread = new QThread(indexRunner, "Index Thread");
+ indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
indexThread.start();
synchronizeAnimationTimer = new QTimer();
// Setup the browser window
noteCache = new HashMap<String,String>();
+ readOnlyCache = new HashMap<String, Boolean>();
+ inkNoteCache = new HashMap<String, Boolean>();
browserWindow = new BrowserWindow(conn);
mainLeftRightSplitter.addWidget(leftSplitter1);
notebookTree.setAddAction(menuBar.notebookAddAction);
notebookTree.setIconAction(menuBar.notebookIconAction);
notebookTree.setStackAction(menuBar.notebookStackAction);
+ notebookTree.setPublishAction(menuBar.notebookPublishAction);
+ notebookTree.setShareAction(menuBar.notebookShareAction);
notebookTree.setVisible(Global.isWindowVisible("notebookTree"));
notebookTree.noteSignal.notebookChanged.connect(this, "updateNoteNotebook(String, String)");
+ notebookTree.noteSignal.tagsChanged.connect(this, "updateNoteTags(String, List)");
+ notebookTree.noteSignal.tagsChanged.connect(this, "updateListTags(String, List)");
menuBar.hideNotebooks.setChecked(Global.isWindowVisible("notebookTree"));
savedSearchTree.setAddAction(menuBar.savedSearchAddAction);
trayExitAction = new QAction("Exit", this);
trayAddNoteAction = new QAction("Add Note", this);
- trayExitAction.triggered.connect(this, "close()");
+ trayExitAction.triggered.connect(this, "closeNeverNote()");
trayAddNoteAction.triggered.connect(this, "addNote()");
trayShowAction.triggered.connect(this, "trayToggleVisible()");
historyGuids.add(currentNoteGuid);
historyPosition = 1;
+ menuBar.blockSignals(true);
+ menuBar.narrowListView.blockSignals(true);
+ menuBar.wideListView.blockSignals(true);
if (Global.getListView() == Global.View_List_Narrow) {
menuBar.narrowListView.setChecked(true);
-// narrowListView();
}
else{
menuBar.wideListView.setChecked(true);
-// wideListView();
}
+ menuBar.blockSignals(false);
+ menuBar.narrowListView.blockSignals(false);
+ menuBar.wideListView.blockSignals(false);
if (Global.getListView() == Global.View_List_Wide) {
browserIndexSplitter.addWidget(noteTableView);
int sortCol = Global.getSortColumn();
int sortOrder = Global.getSortOrder();
noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
-
+ if (Global.checkVersionUpgrade())
+ checkForUpdates();
}
-
-
+
// Main entry point
public static void main(String[] args) {
+ log.setLevel(Level.FATAL);
QApplication.initialize(args);
QPixmap pixmap = new QPixmap("classpath:cx/fbn/nevernote/icons/splash_logo.png");
QSplashScreen splash = new QSplashScreen(pixmap);
dbConn = setupDatabaseConnection();
// Must be last stage of setup - only safe once DB is open hence we know we are the only instance running
- Global.getFileManager().purgeResDirectory();
+ Global.getFileManager().purgeResDirectory(true);
} catch (InitializationException e) {
// Fatal
// Exit point
@Override
public void closeEvent(QCloseEvent event) {
+ if (Global.minimizeOnClose() && !closeAction && Global.showTrayIcon()) {
+ event.ignore();
+ hide();
+ return;
+ }
logger.log(logger.HIGH, "Entering NeverNote.closeEvent");
waitCursor(true);
Global.keepRunning = false;
try {
logger.log(logger.MEDIUM, "Waiting for indexThread to stop");
- indexRunner.thread().join(50);
- logger.log(logger.MEDIUM, "Index thread has stopped");
+ if (indexRunner.thread().isAlive())
+ indexRunner.thread().join(50);
+ if (!indexRunner.thread().isAlive())
+ logger.log(logger.MEDIUM, "Index thread has stopped");
+ else
+ logger.log(logger.MEDIUM, "Index thread still running - bypassing");
} catch (InterruptedException e1) {
e1.printStackTrace();
}
logger.log(logger.HIGH, "Leaving NeverNote.closeEvent");
}
+ @SuppressWarnings("unused")
+ private void closeNeverNote() {
+ closeAction = true;
+ close();
+ }
public void setMessage(String s) {
logger.log(logger.HIGH, "Entering NeverNote.setMessage");
logger.log(logger.HIGH, "Message: " +s);
}
private void setupIndexListeners() {
- indexRunner.noteSignal.noteIndexed.connect(this, "indexThreadComplete(String)");
- indexRunner.resourceSignal.resourceIndexed.connect(this, "indexThreadComplete(String)");
-// indexRunner.threadSignal.indexNeeded.connect(listManager, "setIndexNeeded(String, String, Boolean)");
+// indexRunner.noteSignal.noteIndexed.connect(this, "indexThreadComplete(String)");
+// indexRunner.resourceSignal.resourceIndexed.connect(this, "indexThreadComplete(String)");
+ indexRunner.signal.indexStarted.connect(this, "indexStarted()");
+ indexRunner.signal.indexFinished.connect(this, "indexComplete()");
}
private void setupSyncSignalListeners() {
syncRunner.tagSignal.listChanged.connect(this, "tagIndexUpdated()");
indexTimer.start(indexTime); // reset indexing timer
settings.exec();
+ indexRunner.indexAttachmentsLocally = Global.indexAttachmentsLocally();
if (Global.showTrayIcon())
trayIcon.show();
else
// if (!dateFormat.equals(Global.getDateFormat()) ||
// !timeFormat.equals(Global.getTimeFormat())) {
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.clear();
noteIndexUpdated(true);
// }
// Setup the tree containing the user's notebooks.
private void initializeNotebookTree() {
logger.log(logger.HIGH, "Entering NeverNote.initializeNotebookTree");
- notebookTree.itemClicked.connect(this, "notebookTreeSelection()");
+// notebookTree.itemClicked.connect(this, "notebookTreeSelection()");
+ notebookTree.selectionSignal.connect(this, "notebookTreeSelection()");
listManager.notebookSignal.refreshNotebookTreeCounts.connect(notebookTree, "updateCounts(List, List)");
logger.log(logger.HIGH, "Leaving NeverNote.initializeNotebookTree");
}
menuBar.noteRestoreAction.setVisible(false);
menuBar.notebookEditAction.setEnabled(true);
menuBar.notebookDeleteAction.setEnabled(true);
+ menuBar.notebookPublishAction.setEnabled(true);
+ menuBar.notebookShareAction.setEnabled(true);
menuBar.notebookIconAction.setEnabled(true);
menuBar.notebookStackAction.setEnabled(true);
List<QTreeWidgetItem> selections = notebookTree.selectedItems();
- QTreeWidgetItem currentSelection;
selectedNotebookGUIDs.clear();
- if (!Global.mimicEvernoteInterface) {
- for (int i=0; i<selections.size(); i++) {
- currentSelection = selections.get(i);
- if (!currentSelection.text(2).equals("STACK"))
- selectedNotebookGUIDs.add(currentSelection.text(2));
- else {
- String stackName = currentSelection.text(0);
- for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
- Notebook book = listManager.getNotebookIndex().get(j);
- if (book.getStack()!=null && book.getStack().equalsIgnoreCase(stackName))
- selectedNotebookGUIDs.add(book.getGuid());
- }
- }
- }
-
-
- // There is the potential for no notebooks to be selected if this
- // happens then we make it look like all notebooks were selecetd.
- // If that happens, just select the "all notebooks"
- selections = notebookTree.selectedItems();
- if (selections.size()==0) {
- selectedNotebookGUIDs.clear();
- menuBar.notebookEditAction.setEnabled(false);
- menuBar.notebookDeleteAction.setEnabled(false);
- menuBar.notebookIconAction.setEnabled(false);
- menuBar.notebookStackAction.setEnabled(false);
- }
- if (selectedNotebookGUIDs.size() == 1 && selectedNotebookGUIDs.get(0).equals(previousSelectedNotebook)) {
- previousSelectedNotebook = selectedNotebookGUIDs.get(0);
- previousSelectedNotebook = "";
- notebookTree.clearSelection();
- notebookTreeSelection();
- return;
- }
- if (selectedNotebookGUIDs.size() == 1)
- previousSelectedNotebook = selectedNotebookGUIDs.get(0);
- if (selectedNotebookGUIDs.size() > 1)
- previousSelectedNotebook = "";
+ String guid = "";
+ String stackName = "";
+ if (selections.size() > 0) {
+ guid = (selections.get(0).text(2));
+ stackName = selections.get(0).text(0);
+ }
+ if (!Global.mimicEvernoteInterface) {
+ // If no notebooks are selected, we make it look like the "all notebooks" one was selected
+ if (selections.size()==0) {
+ selectedNotebookGUIDs.clear();
+ for (int i=0; i < listManager.getNotebookIndex().size(); i++) {
+ selectedNotebookGUIDs.add(listManager.getNotebookIndex().get(i).getGuid());
+ }
+ menuBar.notebookEditAction.setEnabled(false);
+ menuBar.notebookDeleteAction.setEnabled(false);
+ menuBar.notebookStackAction.setEnabled(false);
+ menuBar.notebookIconAction.setEnabled(false);
+ }
+ }
+ if (!guid.equals("") && !guid.equals("STACK")) {
+ selectedNotebookGUIDs.add(guid);
+ menuBar.notebookIconAction.setEnabled(true);
} else {
- String guid = "";
- String stackName = "";
- if (selections.size() > 0) {
- guid = (selections.get(0).text(2));
- stackName = selections.get(0).text(0);
- }
- if (!guid.equals("") && !guid.equals("STACK")) {
- selectedNotebookGUIDs.add(guid);
- menuBar.notebookIconAction.setEnabled(true);
- }
- else {
- menuBar.notebookIconAction.setEnabled(true);
- for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
- Notebook book = listManager.getNotebookIndex().get(j);
- if (book.getStack() != null && book.getStack().equalsIgnoreCase(stackName))
- selectedNotebookGUIDs.add(book.getGuid());
- }
- }
+ menuBar.notebookIconAction.setEnabled(true);
+ for (int j=0; j<listManager.getNotebookIndex().size(); j++) {
+ Notebook book = listManager.getNotebookIndex().get(j);
+ if (book.getStack() != null && book.getStack().equalsIgnoreCase(stackName))
+ selectedNotebookGUIDs.add(book.getGuid());
+ }
}
listManager.setSelectedNotebooks(selectedNotebookGUIDs);
listManager.loadNotesIndex();
conn.getNotebookTable().setDefaultNotebook(listManager.getNotebookIndex().get(i).getGuid());
}
conn.getNotebookTable().updateNotebook(listManager.getNotebookIndex().get(i), true);
+ if (conn.getNotebookTable().isLinked(listManager.getNotebookIndex().get(i).getGuid())) {
+ LinkedNotebook linkedNotebook = conn.getLinkedNotebookTable().getByNotebookGuid(listManager.getNotebookIndex().get(i).getGuid());
+ linkedNotebook.setShareName(edit.getNotebook());
+ conn.getLinkedNotebookTable().updateNotebook(linkedNotebook, true);
+ }
i=listManager.getNotebookIndex().size();
}
}
nbooks.add(listManager.getNotebookIndex().get(i));
}
- browserWindow.setNotebookList(nbooks);
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
+ browserWindow.setNotebookList(filteredBooks);
+ Iterator<String> set = externalWindows.keySet().iterator();
+ while(set.hasNext())
+ externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
logger.log(logger.HIGH, "Leaving NeverNote.editNotebook");
}
+ // Publish a notebook
+ @SuppressWarnings("unused")
+ private void publishNotebook() {
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+
+ if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
+ return;
+
+ Notebook n = null;
+ int position = 0;
+ for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
+ if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
+ n = listManager.getNotebookIndex().get(i);
+ position = i;
+ i = listManager.getNotebookIndex().size();
+ }
+ }
+ if (n == null)
+ return;
+
+ PublishNotebook publish = new PublishNotebook(Global.username, Global.getServer(), n);
+ publish.exec();
+
+ if (!publish.okClicked())
+ return;
+
+ Publishing p = publish.getPublishing();
+ boolean isPublished = !publish.isStopPressed();
+ conn.getNotebookTable().setPublishing(n.getGuid(), isPublished, p);
+ n.setPublished(isPublished);
+ n.setPublishing(p);
+ listManager.getNotebookIndex().set(position, n);
+ notebookIndexUpdated();
+ }
+ // Publish a notebook
+ @SuppressWarnings("unused")
+ private void shareNotebook() {
+ List<QTreeWidgetItem> selections = notebookTree.selectedItems();
+ QTreeWidgetItem currentSelection;
+ currentSelection = selections.get(0);
+ String guid = currentSelection.text(2);
+
+ if (guid.equalsIgnoreCase("STACK") || guid.equalsIgnoreCase(""))
+ return;
+
+ Notebook n = null;;
+ for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
+ if (guid.equals(listManager.getNotebookIndex().get(i).getGuid())) {
+ n = listManager.getNotebookIndex().get(i);
+ i = listManager.getNotebookIndex().size();
+ }
+ }
+
+ String authToken = null;
+ if (syncRunner.isConnected)
+ authToken = syncRunner.authToken;
+ ShareNotebook share = new ShareNotebook(n.getName(), conn, n, syncRunner);
+ share.exec();
+
+ }
+
// Delete an existing notebook
@SuppressWarnings("unused")
private void deleteNotebook() {
}
}
- notebookTreeSelection();
- notebookTree.load(listManager.getNotebookIndex(), listManager.getLocalNotebooks());
- listManager.countNotebookResults(listManager.getNoteIndex());
+ notebookIndexUpdated();
+// notebookTreeSelection();
+// notebookTree.load(listManager.getNotebookIndex(), listManager.getLocalNotebooks());
+// listManager.countNotebookResults(listManager.getNoteIndex());
logger.log(logger.HIGH, "Entering NeverNote.deleteNotebook");
}
// A note's notebook has been updated
listManager.loadNotesIndex();
notebookIndexUpdated();
noteIndexUpdated(false);
+ reloadTagTree(true);
// noteIndexUpdated(false);
// Build a list of non-closed notebooks
if (!found)
nbooks.add(listManager.getNotebookIndex().get(i));
}
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ List<Notebook> filteredBooks = notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex());
+ browserWindow.setNotebookList(filteredBooks);
+
+ // Update any external windows
+ Iterator<String> set = externalWindows.keySet().iterator();
+ while(set.hasNext())
+ externalWindows.get(set.next()).getBrowserWindow().setNotebookList(filteredBooks);
+
waitCursor(false);
- browserWindow.setNotebookList(nbooks);
}
// Change the notebook's icon
+ @SuppressWarnings("unused")
private void setNotebookIcon() {
boolean stackSelected = false;
boolean allNotebookSelected = false;
logger.log(logger.HIGH, "Leaving NeverNote.addTag");
}
+ @SuppressWarnings("unused")
private void reloadTagTree() {
reloadTagTree(false);
}
private void initializeTagTree() {
logger.log(logger.HIGH, "Entering NeverNote.initializeTagTree");
// tagTree.itemSelectionChanged.connect(this, "tagTreeSelection()");
- tagTree.itemClicked.connect(this, "tagTreeSelection()");
+// tagTree.itemClicked.connect(this, "tagTreeSelection()");
+ tagTree.selectionSignal.connect(this, "tagTreeSelection()");
listManager.tagSignal.refreshTagTreeCounts.connect(tagTree, "updateCounts(List)");
logger.log(logger.HIGH, "Leaving NeverNote.initializeTagTree");
}
menuBar.tagDeleteAction.setEnabled(false);
menuBar.tagIconAction.setEnabled(true);
}
- if (selectedTagGUIDs.size() == 1 && selectedTagGUIDs.get(0).equals(previousSelectedTag)) {
- previousSelectedTag = selectedTagGUIDs.get(0);
- previousSelectedTag = "";
- tagTree.clearSelection();
- tagTreeSelection();
- return;
- }
- if (selectedTagGUIDs.size() == 1)
- previousSelectedTag = selectedTagGUIDs.get(0);
- if (selectedTagGUIDs.size() > 1)
- previousSelectedTag = "";
listManager.setSelectedTags(selectedTagGUIDs);
listManager.loadNotesIndex();
noteIndexUpdated(false);
logger.log(logger.HIGH, "Entering NeverNote.tagIndexUpdated");
if (selectedTagGUIDs == null)
selectedTagGUIDs = new ArrayList<String>();
-// selectedTagGUIDs.clear(); // clear out old entries
+ if (reload)
+ listManager.reloadTagIndex();
tagTree.blockSignals(true);
if (reload) {
tagTree.blockSignals(false);
}
// Change the icon for a tag
+ @SuppressWarnings("unused")
private void setTagIcon() {
QTreeWidgetItem currentSelection;
List<QTreeWidgetItem> selections = tagTree.selectedItems();
logger.log(logger.HIGH, "Leaving NeverNote.toggleSavedSearchWindow");
}
// Change the icon for a saved search
+ @SuppressWarnings("unused")
private void setSavedSearchIcon() {
QTreeWidgetItem currentSelection;
List<QTreeWidgetItem> selections = savedSearchTree.selectedItems();
status.setUnindexed(unindexed);
status.setNoteCount(conn.getNoteTable().getNoteCount());
status.setNotebookCount(listManager.getNotebookIndex().size());
+ status.setUnindexedResourceCount(conn.getNoteTable().noteResourceTable.getUnindexedCount());
status.setSavedSearchCount(listManager.getSavedSearchIndex().size());
status.setTagCount(listManager.getTagIndex().size());
status.setResourceCount(conn.getNoteTable().noteResourceTable.getResourceCount());
Global.saveWindowVisible("leftPanel", hidden);
}
+ public void checkForUpdates() {
+ // Send off thread to check for a new version
+ versionChecker = new QNetworkAccessManager(this);
+ versionChecker.finished.connect(this, "upgradeFileRead(QNetworkReply)");
+ QNetworkRequest request = new QNetworkRequest();
+ request.setUrl(new QUrl(Global.getUpdatesAvailableUrl()));
+ versionChecker.get(request);
+ }
+ @SuppressWarnings("unused")
+ private void upgradeFileRead(QNetworkReply reply) {
+ if (!reply.isReadable())
+ return;
+
+ String winVersion = Global.version;
+ String osxVersion = Global.version;
+ String linuxVersion = Global.version;
+ String linux64Version = Global.version;
+ String version = Global.version;
+
+ // Determine the versions available
+ QByteArray data = reply.readLine();
+ while (data != null && !reply.atEnd()) {
+ String line = data.toString();
+ String lineVersion;
+ if (line.contains(":"))
+ lineVersion = line.substring(line.indexOf(":")+1).replace(" ", "").replace("\n", "");
+ else
+ lineVersion = "";
+ if (line.toLowerCase().contains("windows"))
+ winVersion = lineVersion;
+ else if (line.toLowerCase().contains("os-x"))
+ osxVersion = lineVersion;
+ else if (line.toLowerCase().contains("linux amd64"))
+ linux64Version = lineVersion;
+ else if (line.toLowerCase().contains("linux i386"))
+ linuxVersion = lineVersion;
+ else if (line.toLowerCase().contains("default"))
+ version = lineVersion;
+ // Read the next line
+ data = reply.readLine();
+ }
+
+ // Now we need to determine what system we are on.
+ if (System.getProperty("os.name").toLowerCase().contains("windows"))
+ version = winVersion;
+ if (System.getProperty("os.name").toLowerCase().contains("mac os"))
+ version = osxVersion;
+ if (System.getProperty("os.name").toLowerCase().contains("Linux")) {
+ if (System.getProperty("os.arch").contains("amd64") ||
+ System.getProperty("os.arch").contains("x86_64") ||
+ System.getProperty("os.arch").contains("i686"))
+ version = linux64Version;
+ else
+ version = linuxVersion;
+ }
+
+
+ if (Global.version.equals(version))
+ return;
+
+ UpgradeAvailableDialog dialog = new UpgradeAvailableDialog();
+ dialog.exec();
+ if (dialog.remindMe())
+ Global.setCheckVersionUpgrade(true);
+ else
+ Global.setCheckVersionUpgrade(false);
+ }
+
//***************************************************************
//***************************************************************
//***************************************************************
// Text in the search bar has been cleared
private void searchFieldCleared() {
+ saveNote();
+
+ // This is done because we want to force a reload of
+ // images. Some images we may want to highlight the text.
+ readOnlyCache.clear();
+ inkNoteCache.clear();
+ noteCache.clear();
+ QWebSettings.setMaximumPagesInCache(0);
+ QWebSettings.setObjectCacheCapacities(0, 0, 0);
+
searchField.setEditText("");
saveNoteColumnPositions();
saveNoteIndexWidth();
+ noteIndexUpdated(true);
+ if (currentNote == null && listManager.getNoteIndex().size() > 0) {
+ currentNote = listManager.getNoteIndex().get(0);
+ currentNoteGuid = currentNote.getGuid();
+ }
+ if (currentNote != null)
+ loadNoteBrowserInformation(browserWindow);
}
// text in the search bar changed. We only use this to tell if it was cleared,
// otherwise we trigger off searchFieldChanged.
@SuppressWarnings("unused")
private void searchFieldTextChanged(String text) {
+ QWebSettings.setMaximumPagesInCache(0);
+ QWebSettings.setObjectCacheCapacities(0, 0, 0);
+
if (text.trim().equals("")) {
searchFieldCleared();
if (searchPerformed) {
+
+ // This is done because we want to force a reload of
+ // images. Some images we may want to highlight the text.
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.clear();
+
listManager.setEnSearch("");
-///// listManager.clearNoteIndexSearch();
- //noteIndexUpdated(true);
listManager.loadNotesIndex();
refreshEvernoteNote(true);
noteIndexUpdated(false);
private void searchFieldChanged() {
logger.log(logger.HIGH, "Entering NeverNote.searchFieldChanged");
noteCache.clear();
+ readOnlyCache.clear();
+ inkNoteCache.clear();
saveNoteColumnPositions();
saveNoteIndexWidth();
String text = searchField.currentText();
@SuppressWarnings("unused")
private void updateSyncButton() {
- /* synchronizeFrame++;
- if (synchronizeFrame == 4)
- synchronizeFrame = 0;
- synchronizeButton.setIcon(synchronizeAnimation.get(synchronizeFrame));
- */
-/*
- QPixmap pix = new QPixmap(iconPath+"synchronize.png");
- QMatrix matrix = new QMatrix();
- synchronizeIconAngle = synchronizeIconAngle + 1.0;
- if (synchronizeIconAngle >= 365.0)
- synchronizeIconAngle = 0.0;
- matrix.translate(pix.size().width()/2, pix.size().height()/2);
- matrix.rotate( synchronizeIconAngle );
- matrix.translate(-pix.size().width()/2, -pix.size().height()/2);
- pix = pix.transformed(matrix, TransformationMode.SmoothTransformation);
- synchronizeButton.setIcon(pix);
-*/
-
-
- QPixmap pix = new QPixmap(iconPath+"synchronize.png");
- QPixmap rotatedPix = new QPixmap(pix.size());
- QPainter p = new QPainter(rotatedPix);
-
- rotatedPix.fill(toolBar.palette().color(ColorRole.Button));
- QSize size = pix.size();
- p.translate(size.width()/2, size.height()/2);
- synchronizeIconAngle = synchronizeIconAngle+1.0;
- if (synchronizeIconAngle >= 359.0)
- synchronizeIconAngle = 0.0;
- p.rotate(synchronizeIconAngle);
- p.setBackgroundMode(BGMode.OpaqueMode);
- p.translate(-size.width()/2, -size.height()/2);
- p.drawPixmap(0,0, pix);
- p.end();
- synchronizeButton.setIcon(rotatedPix);
+
+ if (syncIcons == null) {
+ syncIcons = new ArrayList<QPixmap>();
+ double angle = 0.0;
+ synchronizeIconAngle = 0;
+ QPixmap pix = new QPixmap(iconPath+"synchronize.png");
+ syncIcons.add(pix);
+ for (int i=0; i<=360; i++) {
+ QPixmap rotatedPix = new QPixmap(pix.size());
+ QPainter p = new QPainter(rotatedPix);
+ rotatedPix.fill(toolBar.palette().color(ColorRole.Button));
+ QSize size = pix.size();
+ p.translate(size.width()/2, size.height()/2);
+ angle = angle+1.0;
+ p.rotate(angle);
+ p.setBackgroundMode(BGMode.OpaqueMode);
+ p.translate(-size.width()/2, -size.height()/2);
+ p.drawPixmap(0,0, pix);
+ p.end();
+ syncIcons.add(rotatedPix);
+ }
+ }
+
+ synchronizeIconAngle++;
+ if (synchronizeIconAngle > 359)
+ synchronizeIconAngle=0;
+ synchronizeButton.setIcon(syncIcons.get(synchronizeIconAngle));
}
// Synchronize with Evernote
if (!Global.isConnected)
remoteConnect();
if (Global.isConnected)
- synchronizeAnimationTimer.start(10);
+ synchronizeAnimationTimer.start(5);
// synchronizeAnimationTimer.start(200);
syncTimer();
logger.log(logger.HIGH, "Leaving NeverNote.evernoteSync");
menuBar.connectAction.setText(tr("Connect"));
menuBar.connectAction.setToolTip(tr("Connect to Evernote"));
menuBar.synchronizeAction.setEnabled(false);
+ Global.isConnected = false;
synchronizeAnimationTimer.stop();
return;
}
@SuppressWarnings("unused")
private void attributeTreeClicked(QTreeWidgetItem item, Integer integer) {
- clearTagFilter();
- clearNotebookFilter();
+// clearTagFilter();
+// clearNotebookFilter();
clearTrashFilter();
- clearSavedSearchFilter();
+// clearSavedSearchFilter();
if (attributeTreeSelected == null || item.nativeId() != attributeTreeSelected.nativeId()) {
if (item.childCount() > 0) {
refreshEvernoteNote(true);
} else {
//we can reload if note not dirty
- refreshEvernoteNote(!noteDirty);
+// refreshEvernoteNote(!noteDirty);
+ refreshEvernoteNote(false);
}
reloadTagTree(false);
}
logger.log(logger.HIGH, "Leaving NeverNote.updateListAuthor");
}
+ @SuppressWarnings("unused")
private void updateListGuid(String oldGuid, String newGuid) {
logger.log(logger.HIGH, "Entering NeverNote.updateListTitle");
}
logger.log(logger.HIGH, "Leaving NeverNote.updateListDateCreated");
}
- @SuppressWarnings("unused")
private void updateListDateChanged(String guid, QDateTime date) {
logger.log(logger.HIGH, "Entering NeverNote.updateListDateChanged");
logger.log(logger.HIGH, "Leaving NeverNote.updateListDateChanged");
}
// Redo scroll
- @SuppressWarnings("unused")
private void scrollToCurrentGuid() {
//scrollToGuid(currentNoteGuid);
List<QModelIndex> selections = noteTableView.selectionModel().selectedRows();
saveNoteColumnPositions();
saveNoteIndexWidth();
saveWindowState();
- Global.setListView(Global.View_List_Narrow);
+ int sortCol = noteTableView.proxyModel.sortColumn();
+ int sortOrder = noteTableView.proxyModel.sortOrder().value();
+ Global.setSortColumn(sortCol);
+ Global.setSortOrder(sortOrder);
+
+ Global.setListView(Global.View_List_Narrow);
menuBar.wideListView.blockSignals(true);
menuBar.narrowListView.blockSignals(true);
noteTableView.repositionColumns();
noteTableView.resizeColumnWidths();
noteTableView.resizeRowHeights();
+
+ sortCol = Global.getSortColumn();
+ sortOrder = Global.getSortOrder();
+ noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+
showColumns();
noteTableView.load(false);
scrollToCurrentGuid();
}
public void wideListView() {
- saveWindowState();
+ int sortCol = noteTableView.proxyModel.sortColumn();
+ int sortOrder = noteTableView.proxyModel.sortOrder().value();
+ Global.setSortColumn(sortCol);
+ Global.setSortOrder(sortOrder);
+
+ saveWindowState();
saveNoteColumnPositions();
saveNoteIndexWidth();
Global.setListView(Global.View_List_Wide);
noteTableView.repositionColumns();
noteTableView.resizeColumnWidths();
noteTableView.resizeRowHeights();
+
+ sortCol = Global.getSortColumn();
+ sortOrder = Global.getSortOrder();
+ noteTableView.sortByColumn(sortCol, SortOrder.resolve(sortOrder));
+
showColumns();
noteTableView.load(false);
scrollToCurrentGuid();
//** External editor window functions
//***************************************************************
//***************************************************************
- @SuppressWarnings("unused")
private void listDoubleClick() {
saveNote();
if (externalWindows.containsKey(currentNoteGuid)) {
browserWindow.setTitle(text);
}
}
- @SuppressWarnings("unused")
+ @SuppressWarnings({ "rawtypes", "unused" })
private void externalWindowTagsEdited(String guid, List values) {
StringBuffer line = new StringBuffer(100);
for (int i=0; i<values.size(); i++) {
// Get a note from Evernote (and put it in the browser)
private void refreshEvernoteNote(boolean reload) {
logger.log(logger.HIGH, "Entering NeverNote.refreshEvernoteNote");
+
if (Global.disableViewing) {
browserWindow.setEnabled(false);
return;
}
inkNote = false;
- if (!Global.showDeleted)
- browserWindow.setReadOnly(false);
+ readOnly = false;
+ if (Global.showDeleted)
+ readOnly = true;
Global.cryptCounter =0;
if (currentNoteGuid.equals("")) {
browserWindow.setReadOnly(true);
}
private void loadNoteBrowserInformation(BrowserWindow browser) {
- NoteFormatter formatter = new NoteFormatter(logger, conn, tempFiles);
+ NoteFormatter formatter = new NoteFormatter(logger, conn, tempFiles);
formatter.setNote(currentNote, Global.pdfPreview());
formatter.setHighlight(listManager.getEnSearch());
QByteArray js;
js.replace("<?xml version='1.0' encoding='UTF-8'?>", "");
browser.getBrowser().setContent(js);
noteCache.put(currentNoteGuid, js.toString());
+
+ if (formatter.resourceError)
+ resourceErrorMessage();
+ readOnly = formatter.readOnly;
+ inkNote = formatter.inkNote;
+ if (readOnly)
+ readOnlyCache.put(currentNoteGuid, true);
+ if (inkNote)
+ inkNoteCache.put(currentNoteGuid, true);
} else {
logger.log(logger.HIGH, "Note content is being pulled from the cache");
String cachedContent = formatter.modifyCachedTodoTags(noteCache.get(currentNoteGuid));
js = new QByteArray(cachedContent);
browser.getBrowser().setContent(js);
+ if (readOnlyCache.containsKey(currentNoteGuid))
+ readOnly = true;
+ if (inkNoteCache.containsKey(currentNoteGuid))
+ inkNote = true;
}
if (conn.getNoteTable().isThumbnailNeeded(currentNoteGuid)) {
thumbnailHTMLReady(currentNoteGuid, js, Global.calculateThumbnailZoom(js.toString()));
}
- if (formatter.resourceError)
- resourceErrorMessage();
- inkNote = formatter.readOnly;
-
- browser.getBrowser().page().setContentEditable(!inkNote); // We don't allow editing of ink notes
+ if (readOnly || inkNote)
+ browser.getBrowser().page().setContentEditable(false); // We don't allow editing of ink notes
+ else
+ browser.getBrowser().page().setContentEditable(true);
+ browser.setReadOnly(readOnly);
+ deleteButton.setEnabled(!readOnly);
+ tagButton.setEnabled(!readOnly);
+ menuBar.noteDelete.setEnabled(!readOnly);
+ menuBar.noteTags.setEnabled(!readOnly);
browser.setNote(currentNote);
+ if (conn.getNotebookTable().isLinked(currentNote.getNotebookGuid())) {
+ deleteButton.setEnabled(false);
+ menuBar.notebookDeleteAction.setEnabled(false);
+ } else {
+ deleteButton.setEnabled(true);
+ menuBar.notebookDeleteAction.setEnabled(true);
+ }
+
// Build a list of non-closed notebooks
List<Notebook> nbooks = new ArrayList<Notebook>();
for (int i=0; i<listManager.getNotebookIndex().size(); i++) {
nbooks.add(listManager.getNotebookIndex().get(i));
}
- browser.setNotebookList(nbooks);
browser.setTitle(currentNote.getTitle());
browser.setTag(getTagNamesForNote(currentNote));
browser.setAuthor(currentNote.getAttributes().getAuthor());
else
browser.setSubjectDate(currentNote.getCreated());
browser.setUrl(currentNote.getAttributes().getSourceURL());
- browser.setAllTags(listManager.getTagIndex());
+
+ FilterEditorTags tagFilter = new FilterEditorTags(conn, logger);
+ List<Tag> tagList = tagFilter.getValidTags(currentNote);
+ browser.setAllTags(tagList);
+
browser.setCurrentTags(currentNote.getTagNames());
noteDirty = false;
scrollToGuid(currentNoteGuid);
browser.loadingData(false);
if (thumbnailViewer.isActiveWindow())
thumbnailView();
+
+ FilterEditorNotebooks notebookFilter = new FilterEditorNotebooks(conn, logger);
+ browser.setNotebookList(notebookFilter.getValidNotebooks(currentNote, listManager.getNotebookIndex()));
+
waitCursor(false);
logger.log(logger.HIGH, "Leaving NeverNote.refreshEvernoteNote");
}
@SuppressWarnings("unused")
private void fullReindex() {
logger.log(logger.HIGH, "Entering NeverNote.fullReindex");
- // If we are deleting non-trash notes
- if (currentNote == null) return;
- if (currentNote.getDeleted() == 0) {
- if (QMessageBox.question(this, tr("Confirmation"), tr("This will cause all notes & attachments to be reindexed, "+
- "but please be aware that depending upon the size of your database updating all these records " +
- "can be time consuming and NeverNote will be unresponsive until it is complete. Do you wish to continue?"),
- QMessageBox.StandardButton.Yes,
- QMessageBox.StandardButton.No)==StandardButton.No.value() && Global.verifyDelete() == true) {
- return;
- }
- }
- waitCursor(true);
- setMessage(tr("Marking notes for reindex."));
- conn.getNoteTable().reindexAllNotes();
- conn.getNoteTable().noteResourceTable.reindexAll();
+ indexRunner.addWork("REINDEXALL");
setMessage(tr("Database will be reindexed."));
- waitCursor(false);
- logger.log(logger.HIGH, "Leaving NeverNote.fullRefresh");
+ logger.log(logger.HIGH, "Leaving NeverNote.fullReindex");
}
// Listener when a user wants to reindex a specific note
@SuppressWarnings("unused")
private void reindexNote() {
logger.log(logger.HIGH, "Entering NeverNote.reindexNote");
for (int i=0; i<selectedNoteGUIDs.size(); i++) {
- conn.getNoteTable().setIndexNeeded(selectedNoteGUIDs.get(i), true);
+ indexRunner.addWork("REINDEXNOTE "+selectedNoteGUIDs.get(i));
}
if (selectedNotebookGUIDs.size() > 1)
setMessage(tr("Notes will be reindexed."));
browserWindow.getBrowser().page().findText(find.getText(), find.getFlags());
find.setFocus();
}
- private void updateNoteTitle(String guid, String title) {
+ @SuppressWarnings("unused")
+ private void updateNoteTitle(String guid, String title) {
listManager.setNoteSynchronized(guid, false);
}
// Signal received that note content has changed. Normally we just need the guid to remove
@SuppressWarnings("unused")
private void invalidateNoteCache(String guid, String content) {
String v = noteCache.remove(guid);
- if (content != null) {
- //noteCache.put(guid, content);
- }
+// if (guid.equals(currentNoteGuid) && !noteDirty)
+ refreshEvernoteNote(true);
}
// Signal received that a note guid has changed
@SuppressWarnings("unused")
private void noteGuidChanged(String oldGuid, String newGuid) {
if (noteCache.containsKey(oldGuid)) {
- String cache = noteCache.get(oldGuid);
- noteCache.put(newGuid, cache);
- noteCache.remove(oldGuid);
+ if (!oldGuid.equals(currentNoteGuid)) {
+ String cache = noteCache.get(oldGuid);
+ noteCache.put(newGuid, cache);
+ noteCache.remove(oldGuid);
+ } else {
+ noteCache.remove(oldGuid);
+ noteCache.put(newGuid, browserWindow.getContent());
+ }
}
+
listManager.updateNoteGuid(oldGuid, newGuid, false);
if (currentNoteGuid.equals(oldGuid)) {
if (currentNote != null)
currentNote.setGuid(newGuid);
currentNoteGuid = newGuid;
}
- if (externalWindows.containsKey(oldGuid)) {
+
+ if (externalWindows.containsKey(oldGuid)) {
ExternalBrowse b = externalWindows.get(oldGuid);
externalWindows.remove(oldGuid);
b.getBrowserWindow().getNote().setGuid(newGuid);
externalWindows.put(newGuid, b);
}
+
for (int i=0; i<listManager.getNoteIndex().size(); i++) {
if (listManager.getNoteIndex().get(i).getGuid().equals(newGuid)) {
noteTableView.proxyModel.addGuid(newGuid);
i=listManager.getNoteIndex().size();
}
}
+
if (listManager.getNoteTableModel().titleColors.containsKey(oldGuid)) {
int color = listManager.getNoteTableModel().titleColors.get(oldGuid);
listManager.getNoteTableModel().titleColors.put(newGuid, color);
waitCursor(false);
}
// View all notes
+ @SuppressWarnings("unused")
private void allNotes() {
clearAttributeFilter();
clearNotebookFilter();
private void setupOnlineMenu() {
if (!Global.isConnected) {
menuBar.noteOnlineHistoryAction.setEnabled(false);
+ menuBar.selectiveSyncAction.setEnabled(false);
return;
} else {
menuBar.noteOnlineHistoryAction.setEnabled(true);
+ menuBar.selectiveSyncAction.setEnabled(true);
}
}
@SuppressWarnings("unused")
refreshEvernoteNote(true);
setMessage(tr("Note has been restored."));
}
-
+ @SuppressWarnings("unused")
+ private void setupSelectiveSync() {
+
+ // Get a list of valid notebooks
+ List<Notebook> notebooks = null;
+ List<Tag> tags = null;
+ try {
+ notebooks = syncRunner.noteStore.listNotebooks(syncRunner.authToken);
+ tags = syncRunner.noteStore.listTags(syncRunner.authToken);
+ } catch (EDAMUserException e) {
+ setMessage("EDAMUserException: " +e.getMessage());
+ return;
+ } catch (EDAMSystemException e) {
+ setMessage("EDAMSystemException: " +e.getMessage());
+ return;
+ } catch (TException e) {
+ setMessage("EDAMTransactionException: " +e.getMessage());
+ return;
+ }
+
+ // Split up notebooks into synchronized & non-synchronized
+ List<Notebook> ignoredBooks = new ArrayList<Notebook>();
+ List<String> dbIgnoredNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
+
+ for (int i=notebooks.size()-1; i>=0; i--) {
+ for (int j=0; j<dbIgnoredNotebooks.size(); j++) {
+ if (notebooks.get(i).getGuid().equalsIgnoreCase(dbIgnoredNotebooks.get(j))) {
+ ignoredBooks.add(notebooks.get(i));
+ j=dbIgnoredNotebooks.size();
+ }
+ }
+ }
+
+ // split up tags into synchronized & non-synchronized
+ List<Tag> ignoredTags = new ArrayList<Tag>();
+ List<String> dbIgnoredTags = conn.getSyncTable().getIgnoreRecords("TAG");
+
+ for (int i=tags.size()-1; i>=0; i--) {
+ for (int j=0; j<dbIgnoredTags.size(); j++) {
+ if (tags.get(i).getGuid().equalsIgnoreCase(dbIgnoredTags.get(j))) {
+ ignoredTags.add(tags.get(i));
+ j=dbIgnoredTags.size();
+ }
+ }
+ }
+
+ IgnoreSync ignore = new IgnoreSync(notebooks, ignoredBooks, tags, ignoredTags);
+ ignore.exec();
+ if (!ignore.okClicked())
+ return;
+
+ waitCursor(true);
+
+ // Clear out old notebooks & add the new ones
+ List<String> oldIgnoreNotebooks = conn.getSyncTable().getIgnoreRecords("NOTEBOOK");
+ for (int i=0; i<oldIgnoreNotebooks.size(); i++) {
+ conn.getSyncTable().deleteRecord("IGNORENOTEBOOK-"+oldIgnoreNotebooks.get(i));
+ }
+
+ List<String> newNotebooks = new ArrayList<String>();
+ for (int i=ignore.getIgnoredBookList().count()-1; i>=0; i--) {
+ String text = ignore.getIgnoredBookList().takeItem(i).text();
+ for (int j=0; j<notebooks.size(); j++) {
+ if (notebooks.get(j).getName().equalsIgnoreCase(text)) {
+ Notebook n = notebooks.get(j);
+ conn.getSyncTable().addRecord("IGNORENOTEBOOK-"+n.getGuid(), n.getGuid());
+ j=notebooks.size();
+ newNotebooks.add(n.getGuid());
+ }
+ }
+ }
+
+ // Clear out old tags & add new ones
+ List<String> oldIgnoreTags = conn.getSyncTable().getIgnoreRecords("TAG");
+ for (int i=0; i<oldIgnoreTags.size(); i++) {
+ conn.getSyncTable().deleteRecord("IGNORETAG-"+oldIgnoreTags.get(i));
+ }
+
+ List<String> newTags = new ArrayList<String>();
+ for (int i=ignore.getIgnoredTagList().count()-1; i>=0; i--) {
+ String text = ignore.getIgnoredTagList().takeItem(i).text();
+ for (int j=0; j<tags.size(); j++) {
+ if (tags.get(j).getName().equalsIgnoreCase(text)) {
+ Tag t = tags.get(j);
+ conn.getSyncTable().addRecord("IGNORETAG-"+t.getGuid(), t.getGuid());
+ newTags.add(t.getGuid());
+ j=tags.size();
+ }
+ }
+ }
+
+ conn.getNoteTable().expungeIgnoreSynchronizedNotes(newNotebooks, newTags);
+ waitCursor(false);
+ refreshLists();
+ }
//**********************************************************
syncRunner.syncDeletedContent = Global.synchronizeDeletedContent();
if (syncThreadsReady > 0) {
+ indexRunner.interrupt = true;
saveNoteIndexWidth();
saveNoteColumnPositions();
if (syncRunner.addWork("SYNC")) {
logger.log(logger.EXTREME, "Index timer activated. Sync running="+syncRunning);
if (syncRunning)
return;
- // Look for any unindexed notes. We only refresh occasionally
- // and do one at a time to keep overhead down.
- if (!indexDisabled && indexRunner.getWorkQueueSize() == 0) {
- List<String> notes = conn.getNoteTable().getNextUnindexed(1);
- String unindexedNote = null;
- if (notes.size() > 0)
- unindexedNote = notes.get(0);
- if (unindexedNote != null && Global.keepRunning) {
- indexNoteContent(unindexedNote);
- }
- if (notes.size()>0) {
- indexTimer.setInterval(100);
- return;
- }
- List<String> unindexedResources = conn.getNoteTable().noteResourceTable.getNextUnindexed(1);
- if (unindexedResources.size() > 0 && indexRunner.getWorkQueueSize() == 0) {
- String unindexedResource = unindexedResources.get(0);
- if (unindexedResource != null && Global.keepRunning) {
- indexNoteResource(unindexedResource);
- }
- }
- if (unindexedResources.size() > 0) {
- indexTimer.setInterval(100);
- return;
- } else {
- indexTimer.setInterval(indexTime);
- }
- if (indexRunning) {
- setMessage(tr("Index completed."));
- logger.log(logger.LOW, "Indexing has completed.");
- indexRunning = false;
- indexTimer.setInterval(indexTime);
- }
+ if (!indexDisabled && indexRunner.idle) {
+ indexRunner.addWork("SCAN");
}
logger.log(logger.EXTREME, "Leaving neverNote index timer");
}
- private synchronized void indexNoteContent(String unindexedNote) {
- logger.log(logger.EXTREME, "Entering NeverNote.indexNoteContent()");
- logger.log(logger.MEDIUM, "Unindexed Note found: "+unindexedNote);
- indexRunner.setIndexType(indexRunner.CONTENT);
- indexRunner.addWork("CONTENT "+unindexedNote);
- if (!indexRunning) {
- setMessage(tr("Indexing notes."));
- logger.log(logger.LOW, "Beginning to index note contents.");
- indexRunning = true;
- }
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteContent()");
- }
- private synchronized void indexNoteResource(String unindexedResource) {
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
- indexRunner.addWork(new String("RESOURCE "+unindexedResource));
- if (!indexRunning) {
- setMessage(tr("Indexing notes."));
- indexRunning = true;
- }
- logger.log(logger.EXTREME, "Leaving NeverNote.indexNoteResource()");
+
+ @SuppressWarnings("unused")
+ private void indexStarted() {
+ setMessage(tr("Indexing notes"));
}
@SuppressWarnings("unused")
- private void indexThreadComplete(String guid) {
- logger.log(logger.MEDIUM, "Index complete for "+guid);
+ private void indexComplete() {
+ setMessage(tr("Index complete"));
}
@SuppressWarnings("unused")
private synchronized void toggleNoteIndexing() {
OSDN Git Service
