", pos);
contents.insert(endPos+1, Qt::escape(note)+"
");
}
text->setHtml(contents);
message->addPart(text);
// Add all the images
for (int i=0; isetContentName(ra.fileName);
}
file->setContentId("file"+QString::number(i+1));
file->setContentType(mime);
message->addPart(file);
}
// Add all the attachments
for (int i=0; isetContentName(ra.fileName);
}
file->setContentType(mime);
message->addPart(file);
}
return;
}
// Strip the contents from the current webview in preparation for printing.
QString EmailNote::stripContentsForPrint(QString contents) {
int pos = contents.indexOf("", pos);
QString lidString = contents.mid(contents.indexOf("lid=", pos)+5);
lidString = lidString.mid(0,lidString.indexOf("\" "));
contents = contents.mid(0,pos) + "![](\"file://")
")+contents.mid(endPos+1);
pos = contents.indexOf("beginGroup("Email");
QString server = global.settings->value("smtpServer", "").toString();
int port = global.settings->value("smtpPort", 25).toInt();
QString smtpConnectionType = global.settings->value("smtpConnectionType", "TcpConnection").toString();
QString userid = global.settings->value("userid", "").toString();
QString password = global.settings->value("password", "").toString();
QString senderEmail = global.settings->value("senderEmail", "").toString();
QString senderName = global.settings->value("senderName", "").toString();
global.settings->endGroup();
if (senderEmail.trimmed() == "" || server.trimmed() == "") {
errorMessage = tr("SMTP Server has not been setup.\nPlease specify server settings in the Preferences menu.");
return 8;
}
QStringList toAddresses = tokenizeString(to);
QStringList ccAddresses = tokenizeString(cc);
QStringList bccAddresses = tokenizeString(bcc);
if (senderName.trimmed() == "")
senderName = senderEmail;
SmtpClient::ConnectionType type = SmtpClient::TcpConnection;
if (smtpConnectionType == "SslConnection")
type = SmtpClient::SslConnection;
if (smtpConnectionType == "TlsConnection")
type = SmtpClient::TlsConnection;
SmtpClient smtp(server, port, type);
smtp.setResponseTimeout(-1);
// We need to set the username (your email address) and password
// for smtp authentification.
smtp.setUser(userid);
smtp.setPassword(password);
// Now we create a MimeMessage object. This is the email.
MimeMessage message;
EmailAddress sender(senderEmail, senderName);
message.setSender(&sender);
for (int i=0; i
#include "email/smtpclient.h"
#include "email/mimemessage.h"
class EmailNote : public QObject
{
Q_OBJECT
private:
public:
explicit EmailNote(QObject *parent = 0);
QString to;
QString cc;
QString bcc;
QString comments;
QString subject;
QString note;
bool ccSelf;
int lastError;
qint32 lid;
QString errorMessage;
QString contents;
void unwrap(QString data);
QString wrap();
QStringList tokenizeString(QString value);
void prepareEmailMessage(MimeMessage *message, QString note, QString body);
QString stripContentsForPrint(QString contents);
int sendEmail();
signals:
public slots:
};
#endif // EMAILNOTE_H
nixnote2-2.0-beta11/cmdtools/extractnotes.cpp 0000664 0000000 0000000 00000005331 13031043266 0021247 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "extractnotes.h"
#include "xml/exportdata.h"
#include "global.h"
#include "filters/filtercriteria.h"
#include "filters/filterengine.h"
#include "sql/notetable.h"
extern Global global;
ExtractNotes::ExtractNotes(QObject *parent) :
QObject(parent)
{
this->deleteAfterExtract=false;
this->verifyDelete=true;
}
void ExtractNotes::extract() {
if (outputFile.trimmed() == "") {
std::cout << QString(tr("Output file not specified.")).toStdString() << endl;
return;
}
if (query != "") {
FilterCriteria *filter = new FilterCriteria();
global.filterCriteria.append(filter);
global.filterPosition = 0;
FilterEngine engine;
filter->setSearchString(query);
QList lids;
engine.filter(filter, &lids);
this->lids.append(lids);
}
ExportData exports(backup, true, this);
if (!backup) {
exports.lids.append(this->lids);
}
exports.backupData(this->outputFile);
if (deleteAfterExtract) {
if (verifyDelete) {
std::string verify;
std::cout << QString(tr("Deleting notes:")).toStdString() << endl;
std::cout << QString(tr("Type DELETE to very: ")).toStdString();
std::cin >> verify;
QString qVerify = QString::fromStdString(verify);
if (qVerify.toLower() != "delete")
return;
}
NoteTable ntable(global.db);
for (int i=0; ioutputFile);
}
nixnote2-2.0-beta11/cmdtools/extractnotes.h 0000664 0000000 0000000 00000002516 13031043266 0020716 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef EXTRACTNOTES_H
#define EXTRACTNOTES_H
#include
class ExtractNotes : public QObject
{
Q_OBJECT
public:
explicit ExtractNotes(QObject *parent = 0);
QList lids;
QString query;
QString outputFile;
bool backup;
bool deleteAfterExtract;
bool verifyDelete;
void extract();
void backupDB();
signals:
public slots:
};
#endif // EXTRACTNOTES_H
nixnote2-2.0-beta11/cmdtools/extractnotetext.cpp 0000664 0000000 0000000 00000010002 13031043266 0021760 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "global.h"
#include
#include "extractnotetext.h"
extern Global global;
ExtractNoteText::ExtractNoteText(QObject *parent) :
QObject(parent)
{
}
QString ExtractNoteText::wrap() {
QString returnValue;
QXmlStreamWriter *writer = new QXmlStreamWriter(&returnValue);
writer->setAutoFormatting(true);
writer->setCodec("UTF-8");
writer->writeStartDocument();
writer->writeDTD("");
writer->writeStartElement("nixnote-text-extract");
writer->writeAttribute("version", "2");
writer->writeAttribute("application", "NixNote");
writer->writeAttribute("applicationVersion", "2.x");
writer->writeStartElement("NoteExtract");
writer->writeTextElement("ReturnUuid", this->returnUuid);
if (this->text.trimmed() != "")
writer->writeTextElement("ReturnText", this->text);
writer->writeTextElement("Lid", QString::number(this->lid));
writer->writeEndElement();
writer->writeEndElement();
writer->writeEndDocument();
return returnValue;
}
void ExtractNoteText::unwrap(QString data) {
lastError = 0;
QXmlStreamReader reader(data);
while (!reader.atEnd()) {
reader.readNext();
if (reader.hasError()) {
errorMessage = reader.errorString();
QLOG_ERROR() << "************************* ERROR READING IMPORT " << errorMessage;
lastError = 16;
return;
}
if (reader.name().toString().toLower() == "nixnote-text-extract" && !reader.isEndElement()) {
reader.readNext();
while(reader.name().toString().toLower() != "nixnote-text-extract") {
if (reader.name().toString().toLower() == "returnuuid" && reader.isStartElement()) {
reader.readNext();
returnUuid = reader.text().toString();
} else if (reader.name().toString().toLower() == "lid" && reader.isStartElement()) {
reader.readNext();
lid = reader.text().toString().toInt();
} else if (reader.name().toString().toLower() == "returntext" && reader.isStartElement()) {
reader.readNext();
text = reader.text().toString();
} else
reader.readNext();
}
}
}
}
QString ExtractNoteText::stripTags(QString content) {
// Start looking through the note
qint32 startPos =content.indexOf(QChar('<'));
qint32 endPos = content.indexOf(QChar('>'),startPos)+1;
content.remove(startPos,endPos-startPos);
// Remove encrypted text
while (content.contains("") + 11;
content = content.mid(0,startPos)+content.mid(endPos);
}
// Get the content as an HTML doc. This will strip any
// remaining tags out, but will also return it as a formatted
// string that preserves things like a newline.
QTextDocument textDocument;
textDocument.setHtml(content);
return textDocument.toPlainText();
}
nixnote2-2.0-beta11/cmdtools/extractnotetext.h 0000664 0000000 0000000 00000002551 13031043266 0021437 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef EXTRACTNOTETEXT_H
#define EXTRACTNOTETEXT_H
#include
class ExtractNoteText : public QObject
{
Q_OBJECT
public:
explicit ExtractNoteText(QObject *parent = 0);
qint32 lid;
QString text;
QString wrap();
int lastError;
QString errorMessage;
QString returnUuid;
void unwrap(QString data);
QString stripTags(QString content);
signals:
public slots:
};
#endif // EXTRACTNOTETEXT_H
nixnote2-2.0-beta11/cmdtools/importnotes.cpp 0000664 0000000 0000000 00000001430 13031043266 0021103 0 ustar 00root root 0000000 0000000 #include "importnotes.h"
#include
#include
#include "xml/importdata.h"
ImportNotes::ImportNotes(QObject *parent) :
QObject(parent)
{
inputFile = "";
}
// Perform the import via the command line
int ImportNotes::import() {
if (inputFile.trimmed() == "") {
std::cout << QString(tr("Input file not specified.")).toStdString() << std::endl;
return 16;
}
QFile f(inputFile);
if (!f.exists()) {
std::cout << QString(tr("Input file not found.")).toStdString() << std::endl;
return 16;
}
ImportData importData(false,true,0);
importData.import(inputFile);
if (importData.lastError != 0) {
std::cout << importData.errorMessage.toStdString() << std::endl;
return 16;
}
return 0;
}
nixnote2-2.0-beta11/cmdtools/importnotes.h 0000664 0000000 0000000 00000000411 13031043266 0020546 0 ustar 00root root 0000000 0000000 #ifndef IMPORTNOTES_H
#define IMPORTNOTES_H
#include
class ImportNotes : public QObject
{
Q_OBJECT
public:
explicit ImportNotes(QObject *parent = 0);
QString inputFile;
int import();
signals:
public slots:
};
#endif // IMPORTNOTES_H
nixnote2-2.0-beta11/cmdtools/signalgui.cpp 0000664 0000000 0000000 00000000437 13031043266 0020510 0 ustar 00root root 0000000 0000000 #include "signalgui.h"
SignalGui::SignalGui()
{
takeScreenshot = false;
openNote= false;
newExternalNote = false;
newNote = false;
shutdown = false;
synchronize = false;
openExternalNote = false;
openNoteNewTab = false;
show = false;
lid = 0;
}
nixnote2-2.0-beta11/cmdtools/signalgui.h 0000664 0000000 0000000 00000000564 13031043266 0020156 0 ustar 00root root 0000000 0000000 #ifndef SIGNALGUI_H
#define SIGNALGUI_H
#include
class SignalGui : public QObject
{
Q_OBJECT
public:
SignalGui();
bool takeScreenshot;
bool openNote;
bool openExternalNote;
bool openNoteNewTab;
bool newExternalNote;
bool newNote;
bool shutdown;
bool synchronize;
bool show;
qint32 lid;
};
#endif // SIGNALGUI_H
nixnote2-2.0-beta11/colors.txt 0000664 0000000 0000000 00000000560 13031043266 0016235 0 ustar 00root root 0000000 0000000 # This file is used to add custom colors to the background color options for a note.
# All lines are in the value of "text name"="color value". The "text name" is the
# display name that appears in the title. The "color value" is either the color
# name or the hex value of the color.
#
# All lines beginning with a # are treated as a comment.
#
#Light Gray=cccccc
nixnote2-2.0-beta11/communication/ 0000775 0000000 0000000 00000000000 13031043266 0017037 5 ustar 00root root 0000000 0000000 nixnote2-2.0-beta11/communication/communicationerror.cpp 0000664 0000000 0000000 00000002640 13031043266 0023464 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "communicationerror.h"
// Default constructor
CommunicationError::CommunicationError(QObject *parent) :
QObject(parent)
{
this->reset();
}
// Reset the last communication error messages
void CommunicationError::reset() {
retryCount = 0;
maxRetryCount = 3;
code = 0;
message = "";
type = None;
}
// Retry after the last error
bool CommunicationError::retry() {
if (retryCount < maxRetryCount)
return true;
else
return false;
}
nixnote2-2.0-beta11/communication/communicationerror.h 0000664 0000000 0000000 00000004321 13031043266 0023127 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef COMMUNICATIONERROR_H
#define COMMUNICATIONERROR_H
#include
//************************************************
//* This class is used to let the user know
//* about any errors when doing a sync.
//************************************************
class CommunicationError : public QObject
{
Q_OBJECT
public:
// The type of errors possible
enum CommunicationErrorType {
None = 0,
Unknown = 1,
EDAMSystemException = 2,
EDAMUserException = 3,
TTransportException = 4,
EDAMNotFoundException = 5,
StdException = 6,
TSSLException = 7,
TException = 8,
RateLimitExceeded = 9,
ThriftException = 10
};
explicit CommunicationError(QObject *parent = 0); // Constructor
CommunicationErrorType type; // The last error type we encountered
QString message; // The last error message from Evernote
int code; // The EDAM error code
void reset(); // Reset all values
bool retry(); // Retry after the last error
int retryCount; // Current retry count
int maxRetryCount; // Maximum number of times to retry
signals:
public slots:
};
#endif // COMMUNICATIONERROR_H
nixnote2-2.0-beta11/communication/communicationmanager.cpp 0000664 0000000 0000000 00000122316 13031043266 0023750 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "communicationmanager.h"
#include "oauth/oauthtokenizer.h"
#include "global.h"
// Windows Check
#ifndef _WIN32
#include
#endif // end windows check
#include
#include
#include
#include "sql/resourcetable.h"
#include "sql/tagtable.h"
#include
#include
#include
#include
#include
#include
#include
// Windows Check
#ifndef _WIN32
#include
#include
#include
#include
#include
#include
#endif // End windows check
#include "utilities/debugtool.h"
extern Global global;
// Generic constructor
CommunicationManager::CommunicationManager(DatabaseConnection *db)
{
this->db = db;
evernoteHost = global.server;
userStorePath = "/edam/user";
clientName = "NixNote/Linux";
inkNoteList = new QList< QPair* >();
thumbnailList = new QList< QPair* >();
postData = new QUrl();
tagGuidMap = new QHash;
initComplete = false;
noteStore = NULL;
myNoteStore = NULL;
linkedNoteStore = NULL;
if (networkAccessManager == NULL) {
networkAccessManager = new QNetworkAccessManager(this);
// connect(networkAccessManager, SIGNAL(finished(QNetworkReply*)), this, SLOT(inkNoteFinished(QNetworkReply*)));
}
}
// Destructor
CommunicationManager::~CommunicationManager() {
delete postData;
delete tagGuidMap;
}
//***********************************************************************
//***********************************************************************
//*** Init & default user connection routines ***
//***********************************************************************
//***********************************************************************
// Connect to Evernote
bool CommunicationManager::enConnect() {
// Get the oAuth token
OAuthTokenizer tokenizer;
QString data = global.accountsManager->getOAuthToken();
tokenizer.tokenize(data);
authToken = tokenizer.oauth_token;
// authToken = global.accountsManager->getOAuthToken();
return init();
}
// start the communication session
bool CommunicationManager::init() {
if (initComplete)
return true;
if (!initNoteStore())
return false;
initComplete = true;
return true;
}
// Initialize the note store
bool CommunicationManager::initNoteStore() {
using namespace qevercloud;
QLOG_DEBUG() << "Inside CommunicationManager::initNoteStore()";
User user;
if (!getUserInfo(user))
return false;
noteStorePath = "/edam/note/" +user.shardId;
QString noteStoreUrl = QString("https://")+evernoteHost+noteStorePath;
myNoteStore = new NoteStore(noteStoreUrl, authToken, this);
noteStore = myNoteStore;
return true;
}
// Disconnect from Evernote's servers (for private notebooks)
void CommunicationManager::enDisconnect() {
//noteStore->disconnect();
userStore->disconnect();
if (linkedNoteStore != NULL)
linkedNoteStore->disconnect();
if (myNoteStore != NULL)
myNoteStore->disconnect();
}
// Get a user's information
bool CommunicationManager::getUserInfo(User &user) {
QLOG_DEBUG() << "Inside CommunicationManager::getUserInfo";
userStore = new UserStore(evernoteHost, authToken);
try {
User u = userStore->getUser();
user = u;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.type = CommunicationError::EDAMUserException;
error.code = e.errorCode;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
} catch (const std::exception &e) {
QLOG_DEBUG() << "Std exception: " << e.what();
handleStdException(e);
return false;
}
return true;
}
//***********************************************************************
//***********************************************************************
//*** Sync state & sync functions - non linked ***
//***********************************************************************
//***********************************************************************
// Get the current sync state
bool CommunicationManager::getSyncState(QString token, SyncState &syncState) {
if (token == "")
token = authToken;
try {
if (token == authToken)
noteStore = myNoteStore;
else
noteStore = linkedNoteStore;
syncState = noteStore->getSyncState(authToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.type = CommunicationError::EDAMUserException;
error.code = e.errorCode;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
}
return true;
}
// Get a sync chunk
bool CommunicationManager::getSyncChunk(SyncChunk &chunk, int start, int chunkSize, int type, bool fullSync, QString token) {
if (token == "")
token = authToken;
noteStore = myNoteStore;
// Get rid of old stuff from last chunk
while(inkNoteList->size() > 0) {
QPair *pair = inkNoteList->takeLast();
delete pair->second;
delete pair;
}
inkNoteList->empty();
bool notebooks = false;
bool searches = false;
bool tags = false;
bool linkedNotebooks = false;
bool notes = false;
bool resources = false;
bool expunged = false;
notebooks = ((type & SYNC_CHUNK_NOTEBOOKS)>0);
searches = ((type & SYNC_CHUNK_SEARCHES)>0);
tags = ((type & SYNC_CHUNK_TAGS)>0);
linkedNotebooks = ((type & SYNC_CHUNK_LINKED_NOTEBOOKS)>0);
notes = ((type & SYNC_CHUNK_NOTES)>0);
expunged = ((type & SYNC_CHUNK_NOTES) && (!fullSync)>0) | (SYNC_CHUNK_EXPUNGED && (!fullSync));
resources = ((type & SYNC_CHUNK_RESOURCES) && (!fullSync)>0);
// Try to get the chunk
SyncChunkFilter filter;
filter.includeExpunged = expunged;
filter.includeNotes = notes;
filter.includeNoteResources = fullSync;
filter.includeNoteAttributes = notes;
filter.includeNotebooks = notebooks;
filter.includeTags = tags;
filter.includeSearches = searches;
filter.includeResources = resources;
filter.includeLinkedNotebooks = linkedNotebooks;
filter.includeNoteApplicationDataFullMap = false;
filter.includeNoteResourceApplicationDataFullMap = false;
filter.includeNoteResourceApplicationDataFullMap = false;
// This is a failsafe to prevnt loops if nothing passes the filter
chunk.chunkHighUSN = chunk.updateCount;
try {
chunk = myNoteStore->getFilteredSyncChunk(start, chunkSize, filter, token);
processSyncChunk(chunk, token);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
// Upload a new/changed saved search
qint32 CommunicationManager::uploadSavedSearch(SavedSearch &search) {
try {
if (search.updateSequenceNum > 0)
return myNoteStore->updateSearch(search, authToken);
else
search = myNoteStore->createSearch(search, authToken);
return search.updateSequenceNum;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
DebugTool d;
d.dumpSavedSearch(search);
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
DebugTool d;
d.dumpSavedSearch(search);
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
DebugTool d;
d.dumpSavedSearch(search);
return 0;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
DebugTool d;
d.dumpSavedSearch(search);
return false;
}
}
// Permanently delete a saved search
qint32 CommunicationManager::expungeSavedSearch(Guid guid) {
try {
return myNoteStore->expungeSearch(guid, authToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return 0;
} catch (EDAMNotFoundException) {
return 1;
}
}
// Upload a new/changed tag to Evernote
qint32 CommunicationManager::uploadTag(Tag &tag) {
try {
if (tag.updateSequenceNum > 0)
return myNoteStore->updateTag(tag, authToken);
else {
tag = myNoteStore->createTag(tag, authToken);
return tag.updateSequenceNum;
}
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR().maybeSpace() << "Exception Type:" << e.type();
QLOG_ERROR().maybeSpace() << "Exception Msg:" << e.what() << endl;
QLOG_ERROR() << "Tag name: " << tag.name << endl;
DebugTool d;
d.dumpTag(tag);
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
QLOG_ERROR().maybeSpace() << "Tag name: " << tag.name << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
DebugTool d;
d.dumpTag(tag);
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
QLOG_ERROR().maybeSpace() << "Tag name: " << tag.name << endl;
DebugTool d;
d.dumpTag(tag);
handleEDAMSystemException(e);
return 0;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
QLOG_ERROR().maybeSpace() << "Tag name: " << tag.name << endl;
DebugTool d;
d.dumpTag(tag);
handleEDAMNotFoundException(e);
return 0;
}
}
// Permanently delete a tag from Evernote
qint32 CommunicationManager::expungeTag(Guid guid) {
try {
return myNoteStore->expungeTag(guid, authToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return 0;
} catch (EDAMNotFoundException) {
return 1;
}
}
// Upload a notebook to Evernote
qint32 CommunicationManager::uploadNotebook(Notebook ¬ebook) {
try {
if (notebook.updateSequenceNum > 0)
return myNoteStore->updateNotebook(notebook, authToken);
else {
notebook = myNoteStore->createNotebook(notebook, authToken);
return notebook.updateSequenceNum;
}
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
DebugTool d;
d.dumpNotebook(notebook);
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
DebugTool d;
d.dumpNotebook(notebook);
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
DebugTool d;
d.dumpNotebook(notebook);
return 0;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
DebugTool d;
d.dumpNotebook(notebook);
handleEDAMNotFoundException(e);
return false;
}
}
// Permanently delete a notebook from Evernote
qint32 CommunicationManager::expungeNotebook(Guid guid) {
try {
return myNoteStore->expungeNotebook(guid, authToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMNotFoundException) {
return 1;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return 0;
}
}
// Upload a note to Evernote
qint32 CommunicationManager::uploadNote(Note ¬e, QString token) {
if (token == "")
token = authToken;
if (token == authToken)
noteStore = myNoteStore;
else
noteStore = linkedNoteStore;
try {
if (note.updateSequenceNum.isSet() && note.updateSequenceNum > 0)
note = noteStore->updateNote(note, token);
else
note = noteStore->createNote(note, token);
return note.updateSequenceNum;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR().maybeSpace() << "Exception Type:" << e.type();
QLOG_ERROR().maybeSpace() << "Exception Msg:" << e.what() << endl;
DebugTool d;
d.dumpNote(note);
error.message = errorWhat(e.what());
error.type = CommunicationError::ThriftException;
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode;
DebugTool d;
d.dumpNote(note);
error.code = e.errorCode;
error.message = errorWhat(e.what());
error.type = CommunicationError::EDAMUserException;
return 0;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
QLOG_ERROR().maybeSpace() << "Note title: " << note.title << endl;
DebugTool d;
d.dumpNote(note);
handleEDAMSystemException(e);
return 0;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
QLOG_ERROR().maybeSpace() << "Note title: " << note.title << endl;
DebugTool d;
d.dumpNote(note);
handleEDAMNotFoundException(e);
return false;
}
}
// delete a note in Evernote
qint32 CommunicationManager::deleteNote(Guid note, QString token) {
if (token == "")
token = authToken;
if (token == authToken)
noteStore = myNoteStore;
else
noteStore = linkedNoteStore;
try {
return noteStore->deleteNote(note, token);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.message = errorWhat(e.what());
error.type = CommunicationError::ThriftException;
return 0;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.message = errorWhat(e.what());
error.type = CommunicationError::EDAMUserException;
return 0;
} catch (EDAMNotFoundException) {
return 1;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return 0;
}
}
//***********************************************************************
//***********************************************************************
//*** Linked Notebook function ***
//***********************************************************************
//***********************************************************************
// delete a note in Evernote
qint32 CommunicationManager::deleteLinkedNote(Guid note) {
return deleteNote(note, linkedAuthToken);
}
// Upload a note to Evernote
qint32 CommunicationManager::uploadLinkedNote(Note ¬e) {
return uploadNote(note, linkedAuthToken);
}
// Get a shared notebook by authentication token
bool CommunicationManager::getSharedNotebookByAuth(SharedNotebook &sharedNotebook) {
try {
sharedNotebook = noteStore->getSharedNotebookByAuth(linkedAuthToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.message = errorWhat(e.what());
error.type = CommunicationError::EDAMUserException;
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
// Authenticate to a linked notebook
bool CommunicationManager::authenticateToLinkedNotebookShard(LinkedNotebook &book) {
if (!book.noteStoreUrl.isSet()) {
QLOG_ERROR() << tr("Linked notebook notestore URL missing.");
return false;
}
try {
if (linkedNoteStore != NULL)
delete linkedNoteStore;
// Connect to the proper shard
linkedNoteStore = new NoteStore(book.noteStoreUrl, authToken);
linkedAuthToken = "";
noteStore = linkedNoteStore;
// Now, authenticate to the book. Books
// without a sharekey are public, so authentication
// isn't needed
if (!book.shareKey.isSet())
return true;
// We have a share key, so authenticate
linkedAuth = noteStore->authenticateToSharedNotebook(book.shareKey, authToken);
linkedAuthToken = linkedAuth.authenticationToken;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.message = errorWhat(e.what());
error.type = CommunicationError::ThriftException;
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
// If it is a linked noteboook & it isn't found, then we can just expunge it
return false;
//handleEDAMNotFoundException(e);
return false;
}
return true;
}
// Get a linked notebook's sync state
bool CommunicationManager::getLinkedNotebookSyncState(SyncState &syncState, LinkedNotebook &linkedNotebook) {
try {
syncState = linkedNoteStore->getLinkedNotebookSyncState(linkedNotebook, linkedAuthToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
// Get a linked notebook's sync chunk
bool CommunicationManager::getLinkedNotebookSyncChunk(SyncChunk &chunk, LinkedNotebook &book, int start, int chunkSize, bool fullSync) {
try {
chunk = linkedNoteStore->getLinkedNotebookSyncChunk(book, start, chunkSize, fullSync, authToken);
processSyncChunk(chunk, linkedAuthToken);
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.message = errorWhat(e.what());
error.type = CommunicationError::ThriftException;
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
//***********************************************************************
//***********************************************************************
//*** Get earlier versions of a note ***
//***********************************************************************
//***********************************************************************
// get a list of all prior versions of a note
bool CommunicationManager::listNoteVersions(QList &list, QString guid) {
try {
list = noteStore->listNoteVersions(guid, authToken);
return true;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
}
// Get a prior version of a notebook
bool CommunicationManager::getNoteVersion(Note ¬e, QString guid, qint32 usn, bool withResourceData, bool withResourceRecognition, bool withResourceAlternateData) {
try {
note = noteStore->getNoteVersion(guid, usn,
withResourceData, withResourceRecognition, withResourceAlternateData, authToken);
return true;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.message = errorWhat(e.what());
error.type = CommunicationError::EDAMUserException;
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
}
// Get a prior version of a notebook
bool CommunicationManager::getNote(Note ¬e, QString guid, bool withResource, bool withResourceRecognition, bool withResourceAlternateData) {
try {
note = noteStore->getNote(guid,true,withResource,withResourceRecognition,withResourceAlternateData,authToken);
return true;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.message = errorWhat(e.what());
error.type = CommunicationError::EDAMUserException;
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
}
//***********************************************************************
//***********************************************************************
//*** General listing functions. Get notebooks & tags ***
//***********************************************************************
//***********************************************************************
// get a list of all notebooks
bool CommunicationManager::getNotebookList(QList &list) {
QList retval;
try {
retval = noteStore->listNotebooks(authToken);
list = retval;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
error.code = e.errorCode;
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
// get a list of all Tags
bool CommunicationManager::getTagList(QList &list) {
QList retval;
try {
retval = noteStore->listTags(authToken);
list = retval;
} catch (ThriftException e) {
QLOG_ERROR() << "ThriftException:";
QLOG_ERROR() << "Exception Type:" << e.type();
QLOG_ERROR() << "Exception Msg:" << e.what();
error.type = CommunicationError::ThriftException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMUserException e) {
QLOG_ERROR() << "EDAMUserException:" << e.errorCode << endl;
error.code = e.errorCode;
error.type = CommunicationError::EDAMUserException;
error.message = errorWhat(e.what());
return false;
} catch (EDAMSystemException e) {
QLOG_ERROR() << "EDAMSystemException";
handleEDAMSystemException(e);
return false;
} catch (EDAMNotFoundException e) {
QLOG_ERROR() << "EDAMNotFoundException";
handleEDAMNotFoundException(e);
return false;
}
return true;
}
//***********************************************************************
//***********************************************************************
//*** Ink note routines ***
//***********************************************************************
//***********************************************************************
// See if there are any ink notes in this list of resources
void CommunicationManager::checkForInkNotes(QList &resources, QString shard, QString authToken) {
for (int i=0; imime.isSet())
mime = r->mime;
if (mime == "application/vnd.evernote.ink") {
downloadInkNoteImage(r->guid, r, shard, authToken);
}
}
}
// Writer function called when curl has an image ready
size_t curlWriter(void *ptr, size_t size, size_t nmemb, FILE *stream) {
size_t written;
written = fwrite(ptr, size, nmemb, stream);
return written;
}
// Download an ink note image
void CommunicationManager::downloadInkNoteImage(QString guid, Resource *r, QString shard, QString authToken) {
// Windows Check
#ifndef _WIN32
UserTable userTable(db);
QImage *newImage = NULL;
User u;
userTable.getUser(u);
if (shard == "")
shard = u.shardId;
QString urlBase = QString("https://")+evernoteHost
+QString("/shard/")
+shard
+QString("/res/")
+guid +QString(".ink?slice=");
int sliceCount = 1+((r->height-1)/600);
QSize size;
size.setHeight(r->height);
size.setWidth(r->width);
#if QT_VERSION < 0x050000
QUrl postData;
#else
QUrlQuery postData;
#endif
postData.clear();
postData.addQueryItem("auth", authToken);
CURL *curl;
FILE *fp;
CURLcode res;
curl = curl_easy_init();
if (curl) {
int position = 0;
for (int i=0; i=0; i++) {
QTemporaryFile tempFile;
tempFile.open();
tempFile.close();
fp = fopen(tempFile.fileName().toStdString().c_str(), "wb");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlWriter);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
#if QT_VERSION < 0x050000
QString url = urlBase+QString::number(i+1)+"&"+postData.encodedQuery();
#else
QString url = urlBase+QString::number(i+1)+"&"+postData.query();
#endif
curl_easy_setopt(curl, CURLOPT_URL, url.toStdString().c_str());
res = curl_easy_perform(curl);
QLOG_DEBUG() << "curl inknote result " << res;
fclose(fp);
// Now we have the file, let's read it and add it to the final image
QImage replyImage;
replyImage.load(tempFile.fileName(), "PNG");
tempFile.remove();
if (newImage == NULL) {
newImage = new QImage(size, replyImage.format());
}
position = inkNoteReady(newImage, &replyImage, position);
}
// Cleanup
curl_easy_cleanup(curl);
// Start writing the resource
QPair *newPair = new QPair();
newPair->first = guid;
newPair->second = newImage;
inkNoteList->append(newPair);
}
#endif // End windows check
}
// An ink note image is ready for retrieval
int CommunicationManager::inkNoteReady(QImage *img, QImage *replyImage, int position) {
int priorPosition = position;
position = position+replyImage->height();
if (!replyImage->isNull()) {
QPainter p(img);
// p.drawImage(QRect(0,priorPosition, replyImage->width(), position), *replyImage);
p.drawImage(QRect(0,priorPosition, replyImage->width(), replyImage->height()), *replyImage);
p.end();
return position;
}
return -1;
}
//***********************************************************************
//***********************************************************************
//* Take a sync chunk & get all the missing stuff
//***********************************************************************
//***********************************************************************
void CommunicationManager::processSyncChunk(SyncChunk &chunk, QString token) {
QHash noteList;
QList notes;
if (chunk.notes.isSet())
notes = chunk.notes;
for (int i=0; igetNote(notes[i].guid, true, true, true, true, token);
QLOG_TRACE() << "Note Retrieved";
// Load up the tag names because Evernote doesn't give them.
QList tagNames;
QList tagGuids;
if (n.tagGuids.isSet())
tagGuids = n.tagGuids;
for (int j=0; jcontains(tagGuid)) {
QString tagName = tagGuidMap->value(tagGuid);
tagNames.append(tagName);
}
n.tagNames = tagNames;
}
QList resources;
if (n.resources.isSet())
resources = n.resources;
if (resources.size() > 0) {
QLOG_TRACE() << "Checking for ink note";
checkForInkNotes(n.resources, "", authToken);
}
notes[i] = n;
}
if (chunk.notes.isSet())
chunk.notes = notes;
QList resourceData;
QLOG_DEBUG() << "All notes retrieved. Getting resources";
QList resources;
if (chunk.resources.isSet())
resources = chunk.resources;
for (int i=0; igetResource(resources[i].guid, true, true, true, true, token);
QLOG_TRACE() << "Resource retrieved";
resourceData.append(r);
}
if (chunk.resources.isSet())
chunk.resources = resourceData;
QLOG_DEBUG() << "Getting ink notes";
if (resources.size()>0) {
QLOG_TRACE() << "Checking for ink notes";
checkForInkNotes(resources,"", token);
}
}
//***********************************************************************
//***********************************************************************
//*** Exception Handling. Print trace information & return ***
//***********************************************************************
//***********************************************************************
void CommunicationManager::handleEDAMSystemException(EDAMSystemException e) {
void *array[30];
size_t size;
// Windows Check
#ifndef _WIN32
// get void*'s for all entries on the stack
size = backtrace(array, 30);
// print out all the frames to stderr
fprintf(stderr, "EDAM System Exception backtrace");
backtrace_symbols_fd(array, size, 2);
#endif // End windows check
if (e.message.isSet()) {
QLOG_ERROR() << "EDAMSystemException:" << e.message << endl;
}
QLOG_ERROR() << "EDAMSystemException Error Code:" << e.errorCode << endl;
if (e.rateLimitDuration.isSet()) {
QLOG_ERROR() << "EDAMSystemException Rate Limit:" << e.rateLimitDuration << endl;
}
if (e.errorCode == EDAMErrorCode::RATE_LIMIT_REACHED) {
int duration = e.rateLimitDuration/60+1;
error.type = CommunicationError::RateLimitExceeded;
if (duration > 1)
error.message = tr("API rate limit exceeded. Please try again in ") +QString::number(duration)+ tr(" minutes.");
else
error.message = tr("API rate limit exceeded. Please try again in ") +QString::number(duration)+ tr(" minute.");
return;
}
if (e.message.isSet())
error.message = tr("EDAMSystemException ") + e.message + errorWhat(e.what());
else
error.message = tr("EDAMSystemException: Unknown error") + errorWhat(e.what());
error.type = CommunicationError::EDAMSystemException;
error.code = e.errorCode;
}
void CommunicationManager::handleEDAMNotFoundException(EDAMNotFoundException e) {
Q_UNUSED(e); // suppress unused variable message
void *array[30];
size_t size;
// Windows Check
#ifndef _WIN32
// get void*'s for all entries on the stack
size = backtrace(array, 30);
// print out all the frames to stderr
fprintf(stderr, "EDAM Not Found Exception backtrace");
backtrace_symbols_fd(array, size, 2);
#endif
QLOG_ERROR() << "EDAMNotFoundException:" << endl;
error.message = tr("EDAMNotFoundException: Note not found") + errorWhat(e.what());
error.type = CommunicationError::EDAMNotFoundException;
error.code = 16;
}
void CommunicationManager::handleStdException(const std::exception &ex) {
error.message = QString(ex.what());
error.type = CommunicationError::StdException;
error.code = 16;
}
void CommunicationManager::loadTagGuidMap() {
TagTable tagTable(db);
tagTable.getGuidMap(*this->tagGuidMap);
}
QString CommunicationManager::errorWhat(QString what) {
if (what.trimmed() != "") {
return ":" + what;
}
return "";
}
nixnote2-2.0-beta11/communication/communicationmanager.h 0000664 0000000 0000000 00000020516 13031043266 0023414 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef COMMUNICATIONMANAGER_H
#define COMMUNICATIONMANAGER_H
//***************************************************************************
//* This class is used to manage communications between Evernote and
//* NixNote. A lot of this is done with QEvercloud.
//***************************************************************************
#include "qevercloud/include/QEverCloud.h"
#include "global.h"
#include
#include "communication/communicationerror.h"
#include
#include
// Windows Check
#ifndef _WIN32
#include
#endif
#include
#include
#include
#include
#include "qevercloud/include/QEverCloud.h"
using namespace qevercloud;
typedef unsigned int SOCKET;
using namespace std;
//* Userid/password key & secret
//* OAuth key & secret
#define EDAM_CONSUMER_KEY = "baumgarr-3523"
#define EDAM_CONSUMER_SECRET = "8d5ee175f8a5d3ec"
#define SYNC_CHUNK_NOTEBOOKS 0x0001
#define SYNC_CHUNK_TAGS 0x0002
#define SYNC_CHUNK_LINKED_NOTEBOOKS 0x0004
#define SYNC_CHUNK_EXPUNGED 0x0008
#define SYNC_CHUNK_SEARCHES 0x0010
#define SYNC_CHUNK_NOTES 0x0020
#define SYNC_CHUNK_RESOURCES 0x0040
class CommunicationManager : public QObject
{
Q_OBJECT
private:
bool inkNoteImageDownloaded; // Is an inknote download ready?
bool initComplete; // Has the class been properly initialized?
DatabaseConnection *db; // Database connection
bool initNoteStore(); // Initialize the Notestore connection
QUrl *postData; // URL used to communicate with Evernote
QString userStorePath; // Userstore URL path.
QString noteStorePath; // Notestore URL path.
QString clientName; // Client name
QString evernoteHost; // Evernote server URL.
QString linkedNoteStorePath; // URL for linked notebook.
AuthenticationResult linkedAuth; // Linked notebook authorization key
QString linkedAuthToken; // linked notebook authorization token
void downloadInkNoteImage(QString guid, Resource *r, QString shard, QString authToken); // Function to download ink notes
void checkForInkNotes(QList &resources, QString shard, QString authToken); // Check if a resource list has any ink notes
QString authToken; // Authorization token.
bool init(); // Init function. Run after the thread has started & after first call.
QNetworkAccessManager *networkAccessManager; // Network connection to download inknotes
void handleEDAMSystemException(EDAMSystemException e); // Error handler EDAM System Exception
void handleEDAMNotFoundException(EDAMNotFoundException e); // Error handler EDAM Not Found exception.
void handleStdException(const exception &ex); // Handle std exception messages
UserStore *userStore; // UserStore class
NoteStore *noteStore; // Notestore class
NoteStore *linkedNoteStore; // Linked notestore class
NoteStore *myNoteStore; // local account notestore class
void processSyncChunk(SyncChunk &chunk, QString token); // Deal with a sync chunk.
void debugTag(Tag tag); // Dump a tag to the log
void debugNote(Note note);
void debugField(Optional field, QString name);
void debugField(Optional field, QString name);
public:
CommunicationManager(DatabaseConnection *db); // Constructor
~CommunicationManager(); // Destructor
CommunicationError error; // Used to report back errors
bool enConnect(); // Connect to Evernote
bool getSyncState(QString authToken, SyncState &syncState); // Download the last sync state
bool getSyncChunk(SyncChunk &chunk, int start, int chunkSize, int type, bool fullSync, QString token=""); // Download a sync chunk
bool getLinkedNotebookSyncState(SyncState &syncState, LinkedNotebook &book); // Get the sync state of a linked notebook
bool getLinkedNotebookSyncChunk(SyncChunk &chunk, LinkedNotebook &book, int start, int chunkSize, bool fullSync); // Get linked notebook sync chunk
void enDisconnect(); // Disconnect from evernote
bool authenticateToLinkedNotebookShard(LinkedNotebook &book); // Authenticate to a linked notebook account owner shard
bool authenticateToLinkedNotebook(AuthenticationResult &authResult, LinkedNotebook &book); // Authenticate to linked notebook account
bool getUserInfo(User &user); // Get user information
bool getNote(Note &n, QString guid, bool wthResource, bool withRecognition, bool withResource);
QList< QPair* > *inkNoteList; // List to store inknotes downloaded from account.
QList< QPair* > *thumbnailList; // List to store thumbnails from account (not used)
QHash *tagGuidMap; // Temporary hashmap used to store tags. Keeps from repetitive DB lookups filling in tag names
bool getSharedNotebookByAuth(SharedNotebook &sharedNotebook); // Get a shared notebook by authorization key
qint32 uploadSavedSearch(SavedSearch &search); // Upload a saved search to Evernote
qint32 expungeSavedSearch(Guid guid); // Expunge/delete a saved search
qint32 uploadTag(Tag &tag); // Upload a tag to Evernote
qint32 expungeTag(Guid guid); // Expunge/delete a tag
qint32 uploadNotebook(Notebook ¬ebook); // Upload a notebook to Evernote
qint32 expungeNotebook(Guid guid); // Expunge/delete a notebook
qint32 uploadNote(Note ¬e, QString token=""); // Upload a note to Evernote
qint32 uploadLinkedNote(Note ¬e); // Upload a note to a linked account
qint32 deleteNote(Guid guid, QString token=""); // Mark a note as deleted (we don't actually expunge)
qint32 deleteLinkedNote(Guid guid); // Mark a note in a linked notebook as deleted
bool getNotebookList(QList &list); // Get a list of available notebooks
bool getTagList(QList &list); // Get a list of all tags
bool listNoteVersions(QList &list, QString guid); // Get a list of note revisions
bool getNoteVersion(Note ¬e, QString guid, qint32 usn, bool withResourceData=true, bool withResourceRecognition=true, bool withResourceAlternateData=true); // Download a past version of a note from a linked account
void loadTagGuidMap(); // Load the tag hashmap.
QString errorWhat(QString what); // help build error string
public slots:
int inkNoteReady(QImage *newImage, QImage *replyImage, int position); // An inknote has been downloaded.
};
#endif // COMMUNICATIONMANAGER_H
nixnote2-2.0-beta11/copyright 0000664 0000000 0000000 00000002404 13031043266 0016125 0 ustar 00root root 0000000 0000000 Format-Specification: http://svn.debian.org/wsvn/dep/web/deps/dep5.mdwn?op=file&rev=135
Name: NixNote
Maintainer: Randy Baumgarte
Source: http://github.com/baumgarr/Nixnote2/
Copyright: 2006-2015 Randy Baumgarte
License: GPL-2+
Files: icons/*
Copyright: 2006-2015 Randy Baumgarte
License: GPL-2+
Files: debian/*
Copyright: 2006-2015 Randy Baumgarte
License: GPL-2+
License: GPL-2+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
.
You should have received a copy of the GNU General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
.
On Debian systems, the full text of the GNU General Public
License version 2 can be found in the file
`/usr/share/common-licenses/GPL-2'.
nixnote2-2.0-beta11/dialog/ 0000775 0000000 0000000 00000000000 13031043266 0015431 5 ustar 00root root 0000000 0000000 nixnote2-2.0-beta11/dialog/aboutdialog.cpp 0000664 0000000 0000000 00000006025 13031043266 0020432 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "aboutdialog.h"
#include
#include
#include
#include
#include "global.h"
extern Global global;
AboutDialog::AboutDialog(QDialog *parent) :
QDialog(parent)
{
QVBoxLayout *mainLayout = new QVBoxLayout();
this->setLayout(mainLayout);
QWebView *page = new QWebView();
QPushButton *okButton = new QPushButton();
okButton->setText(tr("OK"));
mainLayout->addWidget(page);
QHBoxLayout *buttonLayout = new QHBoxLayout();
QSpacerItem *spacer1 = new QSpacerItem(100000,1, QSizePolicy::Maximum);
QSpacerItem *spacer2 = new QSpacerItem(100000,1, QSizePolicy::Maximum);
buttonLayout->addSpacerItem(spacer1);
buttonLayout->addWidget(okButton);
buttonLayout->addSpacerItem(spacer2);
mainLayout->addLayout(buttonLayout);
this->setLayout(mainLayout);
QString file = global.fileManager.getProgramDirPath("") + "/help/about.html";
QFile f(file);
if(!f.open(QFile::ReadOnly))
return;
QTextStream is(&f);
QString data = is.readAll();
QString translationInformation =
tr("Note to translators: For translation credit, change this message to your name & contact information and it will appear in the About dialog box. HTML Formatting is available.");
QString translationStaticInformation =
"Note to translators: For translation credit, change this message to your name & contact information and it will appear in the About dialog box. HTML Formatting is available.";
if (translationInformation == translationStaticInformation) {
data.replace("__TRANSLATION__", "");
} else {
data = data.replace("__TRANSLATION__", translationInformation);
}
#ifndef _WIN32
data = data.replace("__LOGO__", "file://"+global.fileManager.getImageDirPath("")+"splash_logo.png");
#else
data = data.replace("__LOGO__", "file:///"+global.fileManager.getImageDirPath("").replace("\\","/")+"splash_logo.png");
#endif
page->setHtml(data);
connect(okButton, SIGNAL(clicked()), this, SLOT(close()));
this->resize(600,500);
this->setFont(global.getGuiFont(font()));
}
nixnote2-2.0-beta11/dialog/aboutdialog.h 0000664 0000000 0000000 00000002246 13031043266 0020100 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef ABOUTDIALOG_H
#define ABOUTDIALOG_H
#include
#include
class AboutDialog : public QDialog
{
Q_OBJECT
public:
explicit AboutDialog(QDialog *parent = 0);
signals:
public slots:
};
#endif // ABOUTDIALOG_H
nixnote2-2.0-beta11/dialog/accountdialog.cpp 0000664 0000000 0000000 00000010457 13031043266 0020760 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "accountdialog.h"
#include "sql/usertable.h"
#include "global.h"
#include
#include
#include
#include
#include
extern Global global;
AccountDialog::AccountDialog(QWidget *parent) :
QDialog(parent)
{
// Setup window layout, title, & icon
this->setWindowTitle(tr("Account Information"));
QGridLayout *grid = new QGridLayout();
setLayout(grid);
QLabel *premium = new QLabel(tr("Normal"));
User user;
UserTable userTable(global.db);
userTable.getUser(user);
if (user.privilege.isSet()) {
if (user.privilege == PrivilegeLevel::PREMIUM)
premium->setText(tr("Premium"));
if (user.privilege == PrivilegeLevel::VIP)
premium->setText(tr("VIP"));
if (user.privilege == PrivilegeLevel::MANAGER)
premium->setText(tr("Manager"));
if (user.privilege == PrivilegeLevel::SUPPORT)
premium->setText(tr("Support"));
if (user.privilege == PrivilegeLevel::ADMIN)
premium->setText(tr("Admin"));
}
QString username = "*unknown*";
if (user.username.isSet())
username = user.username;
qlonglong uploadAmt = 0;
qlonglong uploadLimit = 0;
qlonglong uploadLimitEnd = 0;
int pct;
Accounting accounting;
if (user.accounting.isSet())
accounting = user.accounting;
if (accounting.uploadLimit.isSet())
uploadLimit = accounting.uploadLimit;
if (accounting.uploadLimitEnd.isSet())
uploadLimitEnd = accounting.uploadLimitEnd;
uploadAmt = userTable.getUploadAmt();
if (uploadLimit > 0)
pct = uploadAmt*100/uploadLimit;
else
pct = 0;
QString unit = tr(" Bytes");
if (uploadAmt >= 1024) {
uploadAmt = uploadAmt/1024;
unit = tr(" KB");
}
if (uploadAmt >= 1024) {
uploadAmt = uploadAmt / 1024;
unit = tr(" MB");
}
QDateTime dt;
dt = QDateTime::fromMSecsSinceEpoch(uploadLimitEnd);
QString ds = dt.toString();
// // Show limits
QGroupBox *limitGroup = new QGroupBox(tr("Account:"));
QGridLayout *textGrid = new QGridLayout();
textGrid->addWidget(new QLabel(tr("User Name:")),1,1);
textGrid->addWidget(new QLabel(username), 1,2);
textGrid->addWidget(new QLabel(tr("Account Type:")), 2,1);
textGrid->addWidget(premium, 2, 2);
textGrid->addWidget(new QLabel(tr("Limit:")), 3,1);
textGrid->addWidget(new QLabel(QString::number(uploadLimit/1024/1024) +QString(" MB")),3,2);
textGrid->addWidget(new QLabel(tr("Uploaded In This Period:")), 4,1);
if (uploadAmt > 0)
textGrid->addWidget(new QLabel(QString::number(uploadAmt)+unit +" ("+QString::number(pct)+"%)"),4,2);
else
textGrid->addWidget(new QLabel(tr("Less than 1MB")),4,2);
textGrid->addWidget(new QLabel(tr("Current Cycle Ends:")), 5,1);
textGrid->addWidget(new QLabel(ds),5,2);
limitGroup->setLayout(textGrid);
grid->addWidget(limitGroup, 1, 1);
QHBoxLayout *buttonLayout = new QHBoxLayout();
ok = new QPushButton(tr("OK"),this);
connect(ok, SIGNAL(clicked()), this, SLOT(okPushed()));
buttonLayout->addStretch();
buttonLayout->addWidget(ok);
buttonLayout->addStretch();
grid->addLayout(buttonLayout,3,1);
this->setFont(global.getGuiFont(font()));
}
// OK button pushed, close the window
void AccountDialog::okPushed() {
this->close();
}
nixnote2-2.0-beta11/dialog/accountdialog.h 0000664 0000000 0000000 00000002323 13031043266 0020416 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef ACCOUNTDIALOG_H
#define ACCOUNTDIALOG_H
#include
class AccountDialog : public QDialog
{
Q_OBJECT
public:
explicit AccountDialog(QWidget *parent = 0);
QPushButton *ok;
signals:
public slots:
void okPushed();
};
#endif // ACCOUNTDIALOG_H
nixnote2-2.0-beta11/dialog/accountmaintenancedialog.cpp 0000664 0000000 0000000 00000020675 13031043266 0023166 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "accountmaintenancedialog.h"
#include
#include
#include
#include "global.h"
#include "dialog/adduseraccountdialog.h"
extern Global global;
AccountMaintenanceDialog::AccountMaintenanceDialog(NMainMenuBar *menubar, QWidget *parent) :
QDialog(parent)
{
this->parent = parent;
this->menuBar = menubar;
okButton = new QPushButton(tr("OK"), this);
closeButton = new QPushButton(tr("Close"),this);
addButton = new QPushButton(tr("Add"),this);
renameButton = new QPushButton(tr("Rename"));
deleteButton = new QPushButton(tr("Delete"));
removeAuthButton = new QPushButton("Remove Authorization");
nameList = new QListWidget(this);
buttonLayout1 = new QVBoxLayout();
buttonLayout2 = new QHBoxLayout();
displayLayout = new QHBoxLayout();
mainLayout = new QVBoxLayout();
displayLayout->addWidget(nameList);
displayLayout->addLayout(buttonLayout1);
buttonLayout1->addWidget(addButton);
buttonLayout1->addWidget(renameButton);
buttonLayout1->addWidget(removeAuthButton);
buttonLayout1->addWidget(deleteButton);
buttonLayout1->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Minimum, QSizePolicy::Maximum));
buttonLayout1->setStretch(4,100);
mainLayout->addLayout(displayLayout);
mainLayout->addLayout(buttonLayout2);
buttonLayout2->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum, QSizePolicy::Minimum));
buttonLayout2->addWidget(okButton);
buttonLayout2->addWidget(closeButton);
buttonLayout2->addSpacerItem(new QSpacerItem(0,0,QSizePolicy::Maximum, QSizePolicy::Minimum));
buttonLayout2->setStretch(0,100);
buttonLayout2->setStretch(3,100);
this->setLayout(mainLayout);
this->setWindowTitle(tr("User Account Maintenance"));
connect(okButton, SIGNAL(clicked()), this, SLOT(close()));
connect(closeButton, SIGNAL(clicked()), this, SLOT(close()));
connect(addButton, SIGNAL(clicked()), this, SLOT(addAccount()));
connect(removeAuthButton, SIGNAL(clicked()), this, SLOT(removeOAuth()));
connect(deleteButton,SIGNAL(clicked()), this, SLOT(deleteAccount()));
connect(renameButton, SIGNAL(clicked()), this, SLOT(renameAccount()));
this->loadData();
this->setFont(global.getGuiFont(font()));
}
void AccountMaintenanceDialog::loadData() {
names.clear();
ids.clear();
nameList->clear();
deleteButton->setEnabled(false);
names = global.accountsManager->nameList();
ids = global.accountsManager->idList();
for (int i=0; iaddItem(names[i]);
if (ids.size() >= 2) {
deleteButton->setEnabled(true);
}
nameList->sortItems();
if (ids.size() >= 1) {
nameList->item(0)->setSelected(true);
}
}
void AccountMaintenanceDialog::deleteAccount() {
QMessageBox msgBox;
msgBox.setIcon(QMessageBox::Question);
msgBox.setText(tr("Are you sure you want to delete this account?"));
msgBox.setWindowTitle(tr("Verify Delete"));
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
int ret = msgBox.exec();
if (ret == QMessageBox::No)
return;
int id = -1;
QString name = nameList->selectedItems()[0]->text();
for (int i=0; icurrentId) {
msgBox.setIcon(QMessageBox::Information);
msgBox.setText(tr("You cannot delete the active account."));
msgBox.setWindowTitle("Error deleting account");
msgBox.setStandardButtons(QMessageBox::Ok);
msgBox.exec();
return;
}
global.accountsManager->removeId(ids[i]);
id = ids[i];
i=names.size();
}
}
loadData();
if (id>-1) {
for (int i=0; iuserAccountActions.size(); i++) {
QAction *action = menuBar->userAccountActions[i];
if (action->data().toInt() == id) {
action = menuBar->userAccountActions.takeAt(i);
action->disconnect();
menuBar->removeAction(action);
delete action;
}
}
}
QFile configFile(global.fileManager.getHomeDirPath("")+"nixnote-"+QString::number(id) +".conf");
configFile.remove();
removeDir(global.fileManager.getHomeDirPath("")+QString("db-")+QString::number(id));
}
void AccountMaintenanceDialog::renameAccount() {
int id = -1;
bool activeId = false;
QString name = nameList->selectedItems()[0]->text();
QString newName;
for (int i=0; icurrentId)
activeId = true;
else
activeId = false;
AddUserAccountDialog userDialog;
userDialog.newAccountName->setText(name);
userDialog.newAccountServer->setVisible(false);
userDialog.newAccountServerLabel->setVisible(false);
userDialog.exec();
if (!userDialog.okPushed)
return;
newName = userDialog.newAccountName->text();
global.accountsManager->setName(newName, ids[i]);
id = ids[i];
i=names.size();
}
}
if (!activeId)
newName = tr("Switch to ") + newName;
if (id>-1) {
for (int i=0; iuserAccountActions.size(); i++) {
QAction *action = menuBar->userAccountActions[i];
if (action->data().toInt() == id) {
action = menuBar->userAccountActions.at(i);
action->setText(newName);
}
}
}
loadData();
}
void AccountMaintenanceDialog::addAccount() {
AddUserAccountDialog dialog;
dialog.exec();
if (!dialog.okPushed)
return;
QString name = dialog.newAccountName->text().trimmed();
int six = dialog.newAccountServer->currentIndex();
QString server = dialog.newAccountServer->itemData(six, Qt::UserRole).toString();
int newid = global.accountsManager->addId(-1, name, "", server);
QAction *newAction = new QAction(menuBar);
newAction->setText(tr("Switch to ") +name);
newAction->setCheckable(true);
newAction->setData(newid);
menuBar->addUserAccount(newAction);
connect(newAction, SIGNAL(triggered()), (NixNote*)parent, SLOT(switchUser()));
loadData();
}
bool AccountMaintenanceDialog:: removeDir(const QString & dirName) {
bool result = false;
QDir dir(dirName);
if (dir.exists(dirName)) {
Q_FOREACH(QFileInfo info, dir.entryInfoList(QDir::NoDotAndDotDot | QDir::System | QDir::Hidden | QDir::AllDirs | QDir::Files, QDir::DirsFirst)) {
if (info.isDir()) {
result = removeDir(info.absoluteFilePath());
}
else {
result = QFile::remove(info.absoluteFilePath());
}
if (!result) {
return result;
}
}
result = dir.rmdir(dirName);
}
return result;
}
void AccountMaintenanceDialog::removeOAuth() {
if (nameList->selectedItems().count() <= 0)
return;
QString name = nameList->selectedItems()[0]->text();
QString currentName = global.accountsManager->getName();
for (int i=0; isetOAuthToken(ids[i], "");
if (currentName == names[i])
global.accountsManager->setOAuthToken("");
}
}
loadData();
}
nixnote2-2.0-beta11/dialog/accountmaintenancedialog.h 0000664 0000000 0000000 00000003764 13031043266 0022633 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef ACCOUNTMAINTENANCEDIALOG_H
#define ACCOUNTMAINTENANCEDIALOG_H
#include
#include
#include
#include
#include
#include
#include
#include "gui/nmainmenubar.h"
class AccountMaintenanceDialog : public QDialog
{
Q_OBJECT
private:
NMainMenuBar *menuBar;
QPushButton *okButton;
QPushButton *closeButton;
QPushButton *addButton;
QPushButton *renameButton;
QPushButton *removeAuthButton;
QPushButton *deleteButton;
QListWidget *nameList;
QVBoxLayout *buttonLayout1;
QHBoxLayout *buttonLayout2;
QHBoxLayout *displayLayout;
QVBoxLayout *mainLayout;
void loadData();
QList names;
QList ids;
bool removeDir(const QString & dirName);
QWidget *parent;
public:
explicit AccountMaintenanceDialog(NMainMenuBar *menuBar, QWidget *parent = 0);
signals:
public slots:
void addAccount();
void deleteAccount();
void renameAccount();
void removeOAuth();
};
#endif // ACCOUNTMAINTENANCEDIALOG_H
nixnote2-2.0-beta11/dialog/adduseraccountdialog.cpp 0000664 0000000 0000000 00000007051 13031043266 0022324 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "adduseraccountdialog.h"
#include "global.h"
#include
extern Global global;
AddUserAccountDialog::AddUserAccountDialog(QWidget *parent) :
QDialog(parent)
{
okPushed = false;
okButton = new QPushButton(this);
cancelButton = new QPushButton(this);
buttonLayout = new QHBoxLayout();
mainLayout = new QVBoxLayout();
labelLayout = new QGridLayout();
newAccountLabel = new QLabel();
newAccountServer = new QComboBox();
newAccountServerLabel = new QLabel();
newAccountServerLabel->setText(tr("Server"));
okButton->setText(tr("OK"));
okButton->setEnabled(false);
cancelButton->setText(tr("Cancel"));
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelClicked()));
connect(okButton, SIGNAL(clicked()), this, SLOT(okClicked()));
setLayout(mainLayout);
newAccountLabel = new QLabel(tr("Account Name"));
newAccountName = new QLineEdit();
connect(newAccountName, SIGNAL(textChanged(QString)), this, SLOT(textChanged(QString)));
labelLayout->addWidget(newAccountLabel,0,0);
labelLayout->addWidget(newAccountName, 0, 1);
labelLayout->addWidget(newAccountServerLabel, 1,0);;
labelLayout->addWidget(newAccountServer,1,1);
QSpacerItem *spacer1 = new QSpacerItem(10,10,QSizePolicy::Maximum, QSizePolicy::Minimum);
QSpacerItem *spacer2= new QSpacerItem(10,10,QSizePolicy::Maximum, QSizePolicy::Minimum);
buttonLayout->addSpacerItem(spacer1);
buttonLayout->setStretch(0,100);
buttonLayout->setStretch(3,100);
buttonLayout->addWidget(okButton);
buttonLayout->addWidget(cancelButton);
buttonLayout->addSpacerItem(spacer2);
mainLayout->addLayout(labelLayout);
mainLayout->addLayout(buttonLayout);
accountNames = global.accountsManager->nameList();
newAccountServer->addItem(tr("Evernote"), "www.evernote.com");
newAccountServer->addItem(tr("Yinxiang Biji"), "app.yinxiang.com");
newAccountServer->addItem(tr("Evernote Sandbox"), "sandbox.evernote.com");
this->setFont(global.getGuiFont(font()));
}
AddUserAccountDialog::~AddUserAccountDialog() {
delete okButton;
delete cancelButton;
delete buttonLayout;
delete mainLayout;
}
void AddUserAccountDialog::cancelClicked() {
okPushed = false;
close();
}
void AddUserAccountDialog::okClicked() {
okPushed = true;
close();
}
void AddUserAccountDialog::textChanged(QString text) {
if (text.trimmed() == "") {
okButton->setEnabled(false);
return;
}
if (accountNames.contains(text, Qt::CaseInsensitive)) {
okButton->setEnabled(false);
return;
}
okButton->setEnabled(true);
}
nixnote2-2.0-beta11/dialog/adduseraccountdialog.h 0000664 0000000 0000000 00000003451 13031043266 0021771 0 ustar 00root root 0000000 0000000 #ifndef ADDUSERACCOUNTDIALOG_H
#define ADDUSERACCOUNTDIALOG_H
#include
#include
#include
#include
/*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include
#include
#include
#include
#include
class AddUserAccountDialog : public QDialog
{
Q_OBJECT
public:
explicit AddUserAccountDialog(QWidget *parent = 0);
~AddUserAccountDialog();
QPushButton *okButton;
QPushButton *cancelButton;
bool okPushed;
QVBoxLayout *mainLayout;
QHBoxLayout *buttonLayout;
QGridLayout *labelLayout;
QLabel *newAccountLabel;
QLineEdit *newAccountName;
QLabel *newAccountServerLabel;
QComboBox *newAccountServer;
QStringList accountNames;
signals:
public slots:
void okClicked();
void cancelClicked();
void textChanged(QString text);
};
#endif // ADDUSERACCOUNTDIALOG_H
nixnote2-2.0-beta11/dialog/closenotebookdialog.cpp 0000664 0000000 0000000 00000015153 13031043266 0022170 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2014 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "closenotebookdialog.h"
#include
#include
#include
#include
#include "sql/notebooktable.h"
#include "global.h"
extern Global global;
// Constructor
CloseNotebookDialog::CloseNotebookDialog(QWidget *parent) :
QDialog(parent)
{
this->setWindowTitle(tr("Open/Close Notebooks"));
this->setWindowIcon(global.getIconResource(":notebookSmallIcon"));
okPressed = false;
openButton.setEnabled(false);
closeButton.setEnabled(false);
okButton.setText(tr("OK"));
cancelButton.setText(tr("Cancel"));
connect(&openNotebooks, SIGNAL(itemSelectionChanged()), this, SLOT(openListSelection()));
connect(&closeNotebooks, SIGNAL(itemSelectionChanged()), this, SLOT(closeListSelection()));
connect(&okButton, SIGNAL(clicked()), this, SLOT(okButtonPressed()));
connect(&cancelButton, SIGNAL(clicked()), this, SLOT(cancelButtonPressed()));
connect(&closeButton, SIGNAL(clicked()), this, SLOT(closeButtonClicked()));
connect(&openButton, SIGNAL(clicked()), this, SLOT(openButtonClicked()));
openNotebooks.setSelectionMode(QAbstractItemView::MultiSelection);
closeNotebooks.setSelectionMode(QAbstractItemView::MultiSelection);
QVBoxLayout *mainLayout = new QVBoxLayout(this);
QGridLayout *topLayout = new QGridLayout(this);
openLabel.setText(tr("Open Notebooks"));
closeLabel.setText(tr("Closed Notebooks"));
openButton.setText(tr("Open"));
closeButton.setText(tr("Close"));
topLayout->addWidget(&openLabel, 0,0);
topLayout->addWidget(&openNotebooks, 1,0);
QVBoxLayout *middleButtonLayout =new QVBoxLayout(this);
middleButtonLayout->addWidget(&openButton);
middleButtonLayout->addWidget(&closeButton);
topLayout->addLayout(middleButtonLayout, 1,1);
topLayout->addWidget(&closeLabel, 0,2);
topLayout->addWidget(&closeNotebooks,1,2);
QHBoxLayout *buttonLayout = new QHBoxLayout(this);
buttonLayout->addSpacerItem(new QSpacerItem(100,1));
buttonLayout->addWidget(&okButton);
buttonLayout->addSpacerItem(new QSpacerItem(100,1));
buttonLayout->addWidget(&cancelButton);
buttonLayout->addSpacerItem(new QSpacerItem(100,1));
this->setLayout(mainLayout);
mainLayout->addLayout(topLayout);
mainLayout->addLayout(buttonLayout);
NotebookTable bookTable(global.db);
QList openLids;
QList closedLids;
bookTable.getOpenNotebooks(openLids);
bookTable.getClosedNotebooks(closedLids);
for (int i=0; isetData(Qt::UserRole, openLids[i]);
item->setText(notebook.name);
openNotebooks.addItem(item);
}
openNotebooks.sortItems();
for (int i=0; isetData(Qt::UserRole, closedLids[i]);
item->setText(notebook.name);
closeNotebooks.addItem(item);
}
closeNotebooks.sortItems();
this->setFont(global.getGuiFont(font()));
}
// OK button was pressed. Mark specified notebooks
// as closed.
void CloseNotebookDialog::okButtonPressed() {
NotebookTable bookTable(global.db);
bookTable.openAllNotebooks();
for (int i=0; idata(Qt::UserRole).toInt();
bookTable.closeNotebook(lid);
}
okPressed = true;
this->close();
}
// Cancel was pressed. Close the dialog & go home.
void CloseNotebookDialog::cancelButtonPressed() {
okPressed = false;
this->close();
}
// The "open" button was pressed. Move the notebook
// to the open list.
void CloseNotebookDialog::openButtonClicked() {
QList< QListWidgetItem *> items = closeNotebooks.selectedItems();
for (int i=items.size()-1; i>=0; i--) {
QListWidgetItem *newItem = items[i]->clone();
openNotebooks.addItem(newItem);
delete items[i];
}
openNotebooks.sortItems();
if (closeNotebooks.count() == 0)
openButton.setEnabled(false);
}
// The "closed" button was pressed. Move the notebook
// to the closed list.
void CloseNotebookDialog::closeButtonClicked() {
QList< QListWidgetItem *> items = openNotebooks.selectedItems();
for (int i=items.size()-1; i>=0; i--) {
QListWidgetItem *newItem = items[i]->clone();
closeNotebooks.addItem(newItem);
delete items[i];
}
closeNotebooks.sortItems();
if (openNotebooks.count() <= 1)
closeButton.setEnabled(false);
}
// An item in the open list was selected. We enable
// the close button if an item was selected AND if
// there is more than one item in the open list that is not
// selected. You must always have at least one notebook open.
void CloseNotebookDialog::openListSelection() {
closeButton.setEnabled(true);
if (openNotebooks.count() <= 1)
closeButton.setEnabled(false);
if (openNotebooks.selectedItems().size() == 0)
closeButton.setEnabled(false);
if (openNotebooks.selectedItems().size() == openNotebooks.count())
closeButton.setEnabled(false);
}
// An item in the closed list was either selected
// or deselected. If an item is selected we enable
// the open button. If nothing is selected we disable
// the open button.
void CloseNotebookDialog::closeListSelection() {
openButton.setEnabled(true);
if (closeNotebooks.count() <= 0)
openButton.setEnabled(false);
if (closeNotebooks.selectedItems().size() == 0)
openButton.setEnabled(false);
}
nixnote2-2.0-beta11/dialog/closenotebookdialog.h 0000664 0000000 0000000 00000003277 13031043266 0021641 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2014 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef CLOSENOTEBOOKDIALOG_H
#define CLOSENOTEBOOKDIALOG_H
#include
#include
#include
#include
#include
class CloseNotebookDialog : public QDialog
{
Q_OBJECT
public:
explicit CloseNotebookDialog(QWidget *parent = 0);
bool okPressed;
QPushButton openButton;
QPushButton closeButton;
QPushButton cancelButton;
QPushButton okButton;
QListWidget openNotebooks;
QListWidget closeNotebooks;
QLabel openLabel;
QLabel closeLabel;
signals:
public slots:
void openButtonClicked();
void closeButtonClicked();
void okButtonPressed();
void cancelButtonPressed();
void closeListSelection();
void openListSelection();
};
#endif // CLOSENOTEBOOKDIALOG_H
nixnote2-2.0-beta11/dialog/databasestatus.cpp 0000664 0000000 0000000 00000005610 13031043266 0021147 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "databasestatus.h"
#include
#include
#include
#include "sql/notetable.h"
#include "sql/resourcetable.h"
#include "global.h"
extern Global global;
DatabaseStatus::DatabaseStatus(QWidget *parent) :
QDialog(parent)
{
QVBoxLayout *vBoxLayout = new QVBoxLayout(this);
// Setup window layout, title, & icon
this->setWindowTitle(tr("Database Status"));
QGridLayout *textGrid = new QGridLayout();
setLayout(vBoxLayout);
NoteTable ntable(global.db);
ResourceTable rtable(global.db);
qint32 totalNotes = ntable.getCount();
qint32 totalResources = rtable.getCount();
qint32 unindexedNotes = ntable.getUnindexedCount();
qint32 unindexedResources = rtable.getUnindexedCount();
qint32 thumbnailsNeeded = ntable.getThumbnailsNeededCount();
textGrid->addWidget(new QLabel(tr("Total Notes:")),1,1);
textGrid->addWidget(new QLabel(QString::number(totalNotes)), 1,2);
textGrid->addWidget(new QLabel(tr("Total Resources:")), 2,1);
textGrid->addWidget(new QLabel(QString::number(totalResources)), 2, 2);
textGrid->addWidget(new QLabel(tr("Unindexed Notes:")), 3,1);
textGrid->addWidget(new QLabel(QString::number(unindexedNotes)),3,2);
textGrid->addWidget(new QLabel(tr("Unindexed Resources:")), 4,1);
textGrid->addWidget(new QLabel(QString::number(unindexedResources)),4,2);
textGrid->addWidget(new QLabel(tr("Thumbnails Needed:")), 5,1);
textGrid->addWidget(new QLabel(QString::number(thumbnailsNeeded)),5,2);
QHBoxLayout *buttonLayout = new QHBoxLayout();
ok = new QPushButton(tr("OK"),this);
connect(ok, SIGNAL(clicked()), this, SLOT(okPushed()));
buttonLayout->addStretch();
buttonLayout->addWidget(ok);
buttonLayout->addStretch();
vBoxLayout->addLayout(textGrid);
vBoxLayout->addLayout(buttonLayout);
this->setFont(global.getGuiFont(font()));
}
// OK button pushed, close the window
void DatabaseStatus::okPushed() {
this->close();
}
nixnote2-2.0-beta11/dialog/databasestatus.h 0000664 0000000 0000000 00000002327 13031043266 0020616 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef DATABASESTATUS_H
#define DATABASESTATUS_H
#include
class DatabaseStatus : public QDialog
{
Q_OBJECT
public:
explicit DatabaseStatus(QWidget *parent = 0);
QPushButton *ok;
signals:
public slots:
void okPushed();
};
#endif // DATABASESTATUS_H
nixnote2-2.0-beta11/dialog/emaildialog.cpp 0000664 0000000 0000000 00000013750 13031043266 0020412 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "emaildialog.h"
#include
#include
#include
#include
#include "global.h"
extern Global global;
EmailDialog::EmailDialog(QWidget *parent) :
QDialog(parent)
{
setWindowIcon(global.getIconResource(":emailIcon"));
sendPressed = false;
cancelPressed = true;
setWindowTitle(tr("Send Email"));
sendButton = new QPushButton(tr("Send"));
cancelButton = new QPushButton(tr("Cancel"));
QGridLayout *grid = new QGridLayout(this);
setLayout(grid);
QGridLayout *addressGrid = new QGridLayout();
QGridLayout *noteGrid = new QGridLayout();
QGridLayout *buttonGrid = new QGridLayout();
grid->addLayout(addressGrid, 0,0);
grid->addLayout(noteGrid, 1,0);
grid->addLayout(buttonGrid,2,0);
toLabel = new QLabel(this);
toLabel->setText(tr("To:"));
bccLabel = new QLabel(this);
bccLabel->setText(tr("BCC:"));
ccLabel = new QLabel(this);
ccLabel->setText(tr("CC:"));
subjectLabel = new QLabel(this);
subjectLabel->setText(tr("Subject:"));
noteLabel = new QLabel(this);
noteLabel->setText(tr("Note:"));
ccSelf = new QCheckBox(this);
toAddress = new QLineEdit(this);
ccAddress = new QLineEdit(this);
bccAddress = new QLineEdit(this);
subject = new QLineEdit(this);
note = new QPlainTextEdit(this);
int row = 0;
addressGrid->addWidget(toLabel, row, 0);
addressGrid->addWidget(toAddress, row++, 1);
addressGrid->addWidget(ccLabel, row, 0);
addressGrid->addWidget(ccAddress, row++, 1);
addressGrid->addWidget(bccLabel, row, 0);
addressGrid->addWidget(bccAddress, row++, 1);
ccSelf->setText(tr("CC me on this email"));
noteGrid->addWidget(ccSelf, 0,0);
addressGrid->addWidget(subjectLabel, row, 0);
addressGrid->addWidget(subject, row++,1);
noteGrid->addWidget(noteLabel, 1, 0);
noteGrid->addWidget(note, 2,0);
buttonGrid->addWidget(cancelButton, 0,0);
buttonGrid->addWidget(sendButton, 0,1);
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelButtonPressed()));
connect(sendButton, SIGNAL(clicked()), this, SLOT(sendButtonPressed()));
connect(toAddress, SIGNAL(textChanged(QString)), this, SLOT(toAddressChanged()));
connect(ccAddress, SIGNAL(textChanged(QString)), this, SLOT(toAddressChanged()));
connect(bccAddress, SIGNAL(textChanged(QString)), this, SLOT(toAddressChanged()));
connect(ccSelf, SIGNAL(toggled(bool)), this, SLOT(toAddressChanged()));
cancelButton->setAutoDefault(false);
sendButton->setEnabled(false);
sendButton->setAutoDefault(true);
sendButton->setAutoExclusive(true);
toAddress->setFocus();
}
void EmailDialog::sendButtonPressed() {
sendPressed = true;
cancelPressed = false;
close();
}
void EmailDialog::cancelButtonPressed() {
cancelPressed = true;
sendPressed = false;
close();
}
void EmailDialog::toAddressChanged() {
QString to, bcc, cc;
to = toAddress->text().trimmed();
bcc = bccAddress->text().trimmed();
cc = ccAddress->text().trimmed();
// Setup regular expression to test email addresses
QRegExp mailREX("\\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,4}\\b");
mailREX.setCaseSensitivity(Qt::CaseInsensitive);
mailREX.setPatternSyntax(QRegExp::RegExp);
// Check if "to" address is valid
bool validTo = true;
QStringList toList = tokenizeString(to);
for (int i=0; iisChecked())
sendButton->setEnabled(true);
else
sendButton->setEnabled(false);
// If no emails are specified and we are not going to cc oursel,
// then we can't send.
if (to == "" && cc == "" && bcc == "" && !ccSelf->isChecked())
sendButton->setEnabled(false);
}
QStringList EmailDialog::tokenizeString(QString value) {
QStringList values = value.split(QRegExp(",|;|\\s+"), QString::SkipEmptyParts);
// There is probably an easier way to do this with regular expressions, but
// I am horrible at regular expressions.
for (int i=0; itext().trimmed());
}
QStringList EmailDialog::getCcAddresses() {
return tokenizeString(ccAddress->text().trimmed());
}
QStringList EmailDialog::getBccAddresses() {
return tokenizeString(bccAddress->text().trimmed());
}
nixnote2-2.0-beta11/dialog/emaildialog.h 0000664 0000000 0000000 00000003737 13031043266 0020063 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2015 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef EMAILDIALOG_H
#define EMAILDIALOG_H
#include
#include
#include
#include
#include
#include
#include
class EmailDialog : public QDialog
{
Q_OBJECT
private:
QLabel *toLabel;
QLabel *bccLabel;
QLabel *ccLabel;
QLabel *subjectLabel;
QLabel *noteLabel;
QStringList tokenizeString(QString);
public:
explicit EmailDialog(QWidget *parent = 0);
bool sendPressed;
bool cancelPressed;
QCheckBox *ccSelf;
QLineEdit *toAddress;
QLineEdit *bccAddress;
QLineEdit *ccAddress;
QLineEdit *subject;
QPushButton *sendButton;
QPushButton *cancelButton;
QPlainTextEdit *note;
QStringList getToAddresses();
QStringList getCcAddresses();
QStringList getBccAddresses();
signals:
public slots:
void cancelButtonPressed();
void sendButtonPressed();
void toAddressChanged();
};
#endif // EMAILDIALOG_H
nixnote2-2.0-beta11/dialog/encryptdialog.cpp 0000664 0000000 0000000 00000007563 13031043266 0021014 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "encryptdialog.h"
#include "global.h"
#include
extern Global global;
EnCryptDialog::EnCryptDialog(QWidget *parent) :
QDialog(parent)
{
wasOkPressed = false;
setWindowTitle(tr("Encrypt Text"));
//setWindowIcon(new QIcon(iconPath+"password.png"));
QGridLayout *grid = new QGridLayout(this);
QGridLayout *input = new QGridLayout(this);
QGridLayout *msgGrid = new QGridLayout(this);
QGridLayout *button = new QGridLayout(this);
setLayout(grid);
hint.setText("");
password.setText("");
password.setEchoMode(QLineEdit::Password);
password2.setText("");
password2.setEchoMode(QLineEdit::Password);
input->addWidget(new QLabel(tr("Password"), this), 1,1);
input->addWidget(&password, 1, 2);
input->addWidget(new QLabel(tr("Verify"), this), 2,1);
input->addWidget(&password2, 2, 2);
input->addWidget(new QLabel(tr("Hint"), this), 3,1);
input->addWidget(&hint, 3, 2);
input->addWidget(new QLabel(tr("Remember Password")), 4,1);
input->addWidget(&rememberPassword, 4,2);
input->setContentsMargins(10, 10, -10, -10);
grid->addLayout(input, 1,1);
msgGrid->addWidget(&error, 1, 1);
grid->addLayout(msgGrid, 2, 1);
ok.setText(tr("OK"));
connect(&ok, SIGNAL(clicked()), this, SLOT(okButtonPressed()));
ok.setEnabled(false);
QPushButton *cancel = new QPushButton(tr("Cancel"), this);
connect(cancel, SIGNAL(clicked()), this, SLOT(cancelButtonPressed()));
button->addWidget(&ok, 1, 1);
button->addWidget(cancel, 1,2);
grid->addLayout(button, 3, 1);
connect(&password, SIGNAL(textChanged(QString)), this, SLOT(validateInput()));
connect(&password2, SIGNAL(textChanged(QString)), this, SLOT(validateInput()));
connect(&hint, SIGNAL(textChanged(QString)), this, SLOT(validateInput()));
this->setFont(global.getGuiFont(font()));
}
// The OK button was pressed
void EnCryptDialog::okButtonPressed() {
wasOkPressed = true;
close();
}
// The CANCEL button was pressed
void EnCryptDialog::cancelButtonPressed() {
wasOkPressed = false;
close();
}
// Get the the validated password from the field
QString EnCryptDialog::getPasswordVerify() {
return password2.text();
}
// Get the password
QString EnCryptDialog::getPassword() {
return password.text();
}
// Get the password hint
QString EnCryptDialog::getHint() {
return hint.text();
}
// Check if proper input was input
void EnCryptDialog::validateInput() {
ok.setEnabled(false);
error.setText("");
if (password.text().length()<4) {
error.setText(tr("Password must be at least 4 characters"));
return;
}
if (password.text() != password2.text()) {
error.setText(tr("Passwords do not match"));
return;
}
if (hint.text().trimmed() == ("")) {
error.setText(tr("Hint must be entered"));
return;
}
ok.setEnabled(true);
}
bool EnCryptDialog::okPressed() {
return wasOkPressed;
}
nixnote2-2.0-beta11/dialog/encryptdialog.h 0000664 0000000 0000000 00000003166 13031043266 0020454 0 ustar 00root root 0000000 0000000 #ifndef ENCRYPTDIALOG_H
#define ENCRYPTDIALOG_H
#include
#include
#include
/*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include
#include
class EnCryptDialog : public QDialog
{
Q_OBJECT
private:
bool wasOkPressed;
QLineEdit password;
QLineEdit password2;
QLineEdit hint;
QPushButton ok;
QLabel error;
QCheckBox rememberPassword;
public:
explicit EnCryptDialog(QWidget *parent = 0);
QString getPasswordVerify();
QString getPassword();
QString getHint();
bool okPressed();
signals:
public slots:
private slots:
void validateInput();
void okButtonPressed();
void cancelButtonPressed();
};
#endif // ENCRYPTDIALOG_H
nixnote2-2.0-beta11/dialog/endecryptdialog.cpp 0000664 0000000 0000000 00000006347 13031043266 0021324 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "endecryptdialog.h"
#include "global.h"
#include
#include
#include
#include
extern Global global;
EnDecryptDialog::EnDecryptDialog(QWidget *parent) :
QDialog(parent)
{
okPressed = false;
setWindowTitle(tr("Decrypt"));
setWindowIcon(global.getIconResource(":passwordIcon"));
grid = new QGridLayout(this);
setLayout(grid);
password = new QLineEdit(this);
hintLabel = new QLabel(this);
hint = new QLabel(this);
passwordGrid = new QGridLayout(this);
buttonGrid = new QGridLayout(this);
ok= new QPushButton(this);
cancel = new QPushButton(this);
connect(password, SIGNAL(textChanged(const QString&)), this, SLOT(validateInput()));
passwordLabel = new QLabel();
passwordLabel->setText(tr("Password"));
hintLabel->setText(tr("Hint"));
passwordGrid->addWidget(passwordLabel, 1,1);
passwordGrid->addWidget(password, 1, 2);
passwordGrid->addWidget(hintLabel, 2,1);
passwordGrid->addWidget(hint, 2, 2);
rememberPassword = new QCheckBox(this);
permanentlyDecrypt = new QCheckBox(this);
passwordGrid->addWidget(new QLabel(tr("Permanently Decrypt")), 3,1);
passwordGrid->addWidget(permanentlyDecrypt, 3,2);
passwordGrid->addWidget(new QLabel(tr("Remember Password")), 4,1);
passwordGrid->addWidget(rememberPassword, 4,2);
passwordGrid->setContentsMargins(10, 10, -10, -10);
grid->addLayout(passwordGrid,1,1);
ok->setText(tr("OK"));
if (global.password == "" and global.username == "")
ok->setEnabled(false);
connect(ok, SIGNAL(clicked()), this, SLOT(okButtonPressed()));
cancel->setText(tr("Cancel"));
connect(cancel, SIGNAL(clicked()), this, SLOT(cancelButtonPressed()));
buttonGrid->addWidget(ok, 1, 1);
buttonGrid->addWidget(cancel, 1,2);
grid->addLayout(buttonGrid,2,1);
grid->setSizeConstraint( QLayout::SetFixedSize );
password->setEchoMode(QLineEdit::Password);
this->setFont(global.getGuiFont(font()));
}
void EnDecryptDialog::okButtonPressed() {
okPressed = true;
close();
}
void EnDecryptDialog::cancelButtonPressed() {
okPressed = false;
close();
}
void EnDecryptDialog::validateInput() {
ok->setEnabled(true);
if (password->text()=="") {
ok->setEnabled(false);
return;
}
}
nixnote2-2.0-beta11/dialog/endecryptdialog.h 0000664 0000000 0000000 00000003274 13031043266 0020765 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef ENDECRYPTDIALOG_H
#define ENDECRYPTDIALOG_H
#include
#include
#include
#include
#include
#include
class EnDecryptDialog : public QDialog
{
Q_OBJECT
private:
QGridLayout *grid;
QGridLayout *passwordGrid;
QGridLayout *buttonGrid;
QPushButton *ok;
QLabel *passwordLabel;
QLabel *hintLabel;
QPushButton *cancel;
public:
explicit EnDecryptDialog(QWidget *parent = 0);
QLabel *hint;
QLineEdit *password;
bool okPressed;
QCheckBox *permanentlyDecrypt;
QCheckBox *rememberPassword;
signals:
private slots:
void okButtonPressed();
void cancelButtonPressed();
void validateInput();
};
#endif // ENDECRYPTDIALOG_H
nixnote2-2.0-beta11/dialog/faderdialog.cpp 0000664 0000000 0000000 00000003066 13031043266 0020403 0 ustar 00root root 0000000 0000000 //***********************************************************************************************
//* This code was shamelessly copied from the Qt Centre forums:
//* http://www.qtcentre.org/threads/56737-Implementing-fade-in-fade-out-for-a-modal-QDialog
//***********************************************************************************************
#include "faderdialog.h"
FaderDialog::FaderDialog( QWidget * parent ) : QDialog( parent ), mResult( 0 ) {
setWindowFlags(Qt::SplashScreen);
layout = new QVBoxLayout();
text = new QLabel();
layout->addWidget(text);
setLayout(layout);
// Create the fade-in / fade-out animators
mpFadeIn = new QPropertyAnimation( this, "windowOpacity" );
mpFadeIn->setDuration( 2000 );
mpFadeIn->setStartValue( 0.0 );
mpFadeIn->setEndValue( 1.0 );
mpFadeOut = new QPropertyAnimation( this, "windowOpacity" );
mpFadeOut->setDuration( 2000 );
mpFadeOut->setStartValue( 1.0 );
mpFadeOut->setEndValue( 0.0 );
connect( mpFadeIn, SIGNAL(finished()), this, SLOT(done()));
connect( mpFadeOut, SIGNAL( finished() ), this, SLOT( onFadeOutFinished() ) );
}
void FaderDialog::setText(QString value) {
this->text->setText(value);
}
void FaderDialog::showEvent( QShowEvent * )
{
mpFadeIn->start();
}
void FaderDialog::done() {
this->done(0);
}
void FaderDialog::done( int result )
{
mResult = result; // remember the result in a member variable
mpFadeOut->start();
}
void FaderDialog::onFadeOutFinished()
{
QDialog::done( mResult ); // now call the real done() slot
}
nixnote2-2.0-beta11/dialog/faderdialog.h 0000664 0000000 0000000 00000001641 13031043266 0020045 0 ustar 00root root 0000000 0000000 //***********************************************************************************************
//* This code was shamelessly copied from the Qt Centre forums:
//* http://www.qtcentre.org/threads/56737-Implementing-fade-in-fade-out-for-a-modal-QDialog
//***********************************************************************************************
#ifndef FADERDIALOG_H
#define FADERDIALOG_H
#include
#include
#include
#include
class FaderDialog : public QDialog
{
Q_OBJECT
private:
QPropertyAnimation *mpFadeIn;
QPropertyAnimation *mpFadeOut;
int mResult;
QVBoxLayout *layout;
QLabel *text;
public:
explicit FaderDialog(QWidget *parent = 0);
void showEvent(QShowEvent *);
void done(int result);
void setText(QString value);
signals:
public slots:
void onFadeOutFinished();
void done();
};
#endif // FADERDIALOG_H
nixnote2-2.0-beta11/dialog/htmlentitiesdialog.cpp 0000664 0000000 0000000 00000022131 13031043266 0022025 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2014 Randy Baumgarte
Copyright (C) 2014 Milos.Kozina@postino.net
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "htmlentitiesdialog.h"
#include
#include "global.h"
extern Global global;
HtmlEntitiesDialog::HtmlEntitiesDialog(QWidget *parent) :
QDialog(parent)
{
editMode = false;
cancelString = tr("Cancel");
closeString = tr("Close");
editString = tr("Edit entries list");
saveString = tr("Save entities list");
defaultEntities.append("←");
defaultEntities.append("→");
defaultEntities.append("⇐");
defaultEntities.append("⇒");
defaultEntities.append("↑");
defaultEntities.append("↓");
defaultEntities.append("⇑");
defaultEntities.append("⇓");
defaultEntities.append("↔");
defaultEntities.append("↕");
defaultEntities.append("⇕");
defaultEntities.append("⇔");
defaultEntities.append("♠");
defaultEntities.append("♣");
defaultEntities.append("♦");
defaultEntities.append("♥");
defaultEntities.append("☹");
defaultEntities.append("☺");
defaultEntities.append("☻");
defaultEntities.append("☯");
defaultEntities.append("©");
defaultEntities.append("®");
defaultEntities.append("€");
defaultEntities.append("°");
defaultEntities.append("¼");
defaultEntities.append("½");
defaultEntities.append("¾");
defaultEntities.append("±");
defaultEntities.append("✓");
defaultEntities.append("✔");
defaultEntities.append("✗");
defaultEntities.append("✘");
this->listSeparator = ",";
loadCustomEntities();
setWindowTitle(tr("HTML Entities Selection"));
this->setWindowIcon(global.getIconResource(":htmlentitiesIcon"));
setModal(false);
initGrid();
initEntitiesGrid();
signalmapper = new QSignalMapper();
initEntitiesButtons();
connect(signalmapper, SIGNAL(mapped(QString)), this, SLOT(htmlEntityClicked(QString)));
scrollArea = new QScrollArea();
scrollArea->setBackgroundRole(QPalette::Dark);
scrollArea->setMinimumWidth(ENTITY_BUTTON_COLUMNS*(ENTITY_BUTTON_WIDTH+2*ENTITY_MARGIN));
scrollArea->setMinimumHeight(ENTITY_BUTTON_ROWS*(ENTITY_BUTTON_HEIGHT+2*ENTITY_MARGIN));
initEntitiesWidget();
scrollArea->setWidget(entitiesWidget);
scrollArea->setWidgetResizable(false);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
grid->addWidget(scrollArea,2,1);
buttonLayout = new QHBoxLayout();
editButton = new QPushButton(editString);
closeButton = new QPushButton(closeString);
connect(closeButton, SIGNAL(clicked()), this, SLOT(closeClicked()));
connect(editButton, SIGNAL(clicked()), this, SLOT(editClicked()));
buttonLayout->addStretch();
buttonLayout->addWidget(editButton);
buttonLayout->addWidget(closeButton);
buttonLayout->addStretch();
grid->addLayout(buttonLayout,3,1);
setWindowFlags(Qt::WindowStaysOnTopHint);
textEdit = NULL;
scrollArea->setWidgetResizable(false);
//layout()->setSizeConstraint( QLayout::SetFixedSize);
//saveSize = this->size();
this->setFont(global.getGuiFont(font()));
}
void HtmlEntitiesDialog::clearEntitiesButtons() {
for (int i =buttonList.size()-1; i>=0; i--) {
signalmapper->removeMappings(buttonList[i]);
entitiesGrid->removeWidget(buttonList[i]);
buttonList[i]->setVisible(false);
//delete buttonList[i];
}
buttonList.clear();
}
void HtmlEntitiesDialog::initEntitiesButtons() {
int row = 0;
int column = 0;
QStringList *ptr;
if (entities.size() > 0)
ptr = &entities;
else
ptr = &defaultEntities;
for (int i=0; isize(); i++) {
column = i % ENTITY_BUTTON_COLUMNS;
if (column == 0)
row++;
QTextDocument doc;
doc.setHtml(ptr->at(i));
QString htmlText = doc.toPlainText();
QPushButton *button = new QPushButton(htmlText);
signalmapper->setMapping(button, ptr->at(i));
connect(button, SIGNAL(clicked()), signalmapper, SLOT(map()));
button->setMinimumHeight(ENTITY_BUTTON_HEIGHT);
button->setMinimumWidth(ENTITY_BUTTON_WIDTH);
entitiesGrid->addWidget(button,row, column);
buttonList.append(button);
}
}
void HtmlEntitiesDialog::initEntitiesWidget() {
entitiesWidget = new QWidget();
entitiesWidget->setLayout(entitiesGrid);
}
void HtmlEntitiesDialog::htmlEntityClicked(QString htmlEntity) {
emit entityClicked(htmlEntity);
}
void HtmlEntitiesDialog::initEntitiesGrid() {
entitiesGrid = new QGridLayout();
entitiesGrid->setContentsMargins(QMargins(ENTITY_MARGIN, ENTITY_MARGIN, ENTITY_MARGIN, ENTITY_MARGIN));
}
void HtmlEntitiesDialog::initGrid() {
grid = new QGridLayout();
setLayout(grid);
}
void HtmlEntitiesDialog::closeClicked() {
if (editMode) {
editMode = false;
scrollArea->takeWidget();
scrollArea->setWidget(entitiesWidget);
editButton->setText(editString);
closeButton->setText(closeString);
return;
}
this->close();
}
void HtmlEntitiesDialog::editClicked() {
if (editMode) {
if (textEdit->document()->isModified()) {
QString value = textEdit->toPlainText();
QString fileName = global.fileManager.getHomeDirPath("") + QString("entities.txt");
QDir dir;
dir.remove(fileName);
QFile file(fileName);
file.open(QFile::WriteOnly);
if (file.isOpen()) {
QTextStream out(&file);
out << value;
}
file.close();
}
clearEntitiesButtons();
loadCustomEntities();
initEntitiesButtons();
} else {
if (textEdit == NULL) {
textEdit = new QTextEdit(tr("Comma separated list of HTML entities.\nSee http://www.w3schools.com/charsets/ for list."));
}
textEdit->setText(getEntities(true));
}
editMode = !editMode;
scrollArea->takeWidget();
scrollArea->setWidget(editMode ? textEdit : entitiesWidget);
scrollArea->setWidgetResizable(editMode);
editButton->setText(editMode ? saveString : editString);
closeButton->setText(editMode ? cancelString : closeString);
}
bool HtmlEntitiesDialog::close() {
this->hide();
return false;
}
QString HtmlEntitiesDialog::getEntities(bool withBreakLines) {
QString result = "";
QStringList *ptr;
if (entities.size() > 0)
ptr = &entities;
else
ptr = &defaultEntities;
for (int i=0; isize(); i++) {
result = result+ptr->at(i) + " ";
if ((i+1) % ENTITY_BUTTON_COLUMNS == 0 && withBreakLines) {
result = result + ",\n";
} else {
result = result + ", ";
}
}
return result;
}
void HtmlEntitiesDialog::getEntitiesList(QStringList *list, QString entitiesAsText) {
list->clear();
if (entitiesAsText != "") {
QStringList separated = entitiesAsText.split(listSeparator);
for (int i = 0; i < separated.length(); i++) {
QString s = separated.at(i).trimmed();
if (s.startsWith("&") && s.endsWith(";")) {
if (!list->contains(s))
list->append(s);
}
}
}
}
void HtmlEntitiesDialog::loadCustomEntities() {
entities.clear();
QString fileName = global.fileManager.getHomeDirPath("") + QString("entities.txt");
QFile file(fileName);
file.open(QFile::ReadOnly);
if (file.isOpen()) {
while (!file.atEnd()) {
QString line = file.readLine();
line = line.replace("\t", " ");
line = line.replace("\n", " ");
line = line.replace("\r", " " );
line = line.trimmed();
QStringList list = line.split(this->listSeparator);
for(int i=0;i
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define ENTITY_BUTTON_WIDTH 45
#define ENTITY_BUTTON_COLUMNS 4
#define ENTITY_BUTTON_HEIGHT 25
#define ENTITY_BUTTON_ROWS 4
#define ENTITY_MARGIN 1
class HtmlEntitiesDialog : public QDialog
{
Q_OBJECT
private:
QPushButton *closeButton;
QStringList defaultEntities;
QPushButton *editButton;
QScrollArea *scrollArea;
QWidget *entitiesWidget;
bool editMode;
QGridLayout *entitiesGrid;
//QSize saveSize;
QGridLayout *grid;
QSignalMapper *signalmapper;
QHBoxLayout *buttonLayout;
QTextEdit *textEdit;
QString listSeparator;
QStringList entities;
QString cancelString;
QString closeString;
QString editString;
QString saveString;
void initEntitiesWidget();
void initGrid();
void clearEntitiesButtons();
void initEntitiesButtons();
void initEntitiesGrid();
QList buttonList;
QString getEntities(bool withBreakLines);
void getEntitiesList(QStringList *list, QString entitiesAsText);
void loadCustomEntities();
public:
explicit HtmlEntitiesDialog(QWidget *parent = 0);
signals:
void entityClicked(QString entity);
public slots:
void htmlEntityClicked(QString htmlEntity);
void editClicked();
void closeClicked();
bool close();
};
#endif // HTMLENTITIESDIALOG_H
nixnote2-2.0-beta11/dialog/insertlatexdialog.cpp 0000664 0000000 0000000 00000005633 13031043266 0021666 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "insertlatexdialog.h"
#include "global.h"
#include
#include
extern Global global;
InsertLatexDialog::InsertLatexDialog(QWidget *parent) :
QDialog(parent)
{
wasOkPressed = false;
setWindowTitle(tr("Insert LaTeX Formula"));
//setWindowIcon(new QIcon(iconPath+"link.png"));
QGridLayout *grid = new QGridLayout(this);
QGridLayout *input = new QGridLayout(this);
QGridLayout *button = new QGridLayout(this);
setLayout(grid);
url.setText("");
input->addWidget(new QLabel(tr("Formula")), 1,1);
input->addWidget(&url, 2, 1);
input->setContentsMargins(10, 10, -10, -10);
grid->addLayout(input, 1,1);
ok.setText(tr("OK"));
connect(&ok, SIGNAL(clicked()), this, SLOT(accept()));
ok.setEnabled(false);
ok.setDefault(true);
QPushButton *cancel = new QPushButton(tr("Cancel"), this);
connect(cancel, SIGNAL(clicked()), this, SLOT(reject()));
button->addWidget(&ok, 1, 1);
button->addWidget(cancel, 1,2);
grid->addLayout(button, 3, 1);
connect(&url, SIGNAL(textChanged()), this, SLOT(validateInput()));
//setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose);
this->setFont(global.getGuiFont(font()));
}
// Set the formula
void InsertLatexDialog::setFormula(QString x) {
url.setText(x);
}
// Get the formula
QString InsertLatexDialog::getFormula() {
return latexText;
}
// Set the url
void InsertLatexDialog::setUrl(QString u) {
url.setText(u);
}
// Check if the OK button was pressed
bool InsertLatexDialog::okPressed() {
return wasOkPressed;
}
// Check that we have a valid URL
void InsertLatexDialog::validateInput() {
ok.setEnabled(true);
if (url.toPlainText().trimmed() == "")
ok.setEnabled(false);
}
void InsertLatexDialog::accept() {
if (ok.isEnabled()) {
wasOkPressed = true;
latexText = url.toPlainText();
QDialog::accept();
}
}
void InsertLatexDialog::reject() {
wasOkPressed=false;
QDialog::reject();
}
nixnote2-2.0-beta11/dialog/insertlatexdialog.h 0000664 0000000 0000000 00000003031 13031043266 0021321 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#ifndef INSERTLATEXDIALOG_H
#define INSERTLATEXDIALOG_H
#include
#include
#include
#include
class InsertLatexDialog : public QDialog
{
Q_OBJECT
private:
bool wasOkPressed;
QTextEdit url;
QPushButton ok;
QString latexText;
public:
explicit InsertLatexDialog(QWidget *parent = 0);
void setFormula(QString formula);
QString getFormula();
void setUrl(QString url);
bool okPressed();
void accept();
void reject();
signals:
public slots:
private slots:
void validateInput();
};
#endif // INSERTLATEXDIALOG_H
nixnote2-2.0-beta11/dialog/insertlinkdialog.cpp 0000664 0000000 0000000 00000006035 13031043266 0021503 0 ustar 00root root 0000000 0000000 /*********************************************************************************
NixNote - An open-source client for the Evernote service.
Copyright (C) 2013 Randy Baumgarte
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
***********************************************************************************/
#include "insertlinkdialog.h"
#include