libquentier 0.5.0
The library for rich desktop clients of Evernote service
Loading...
Searching...
No Matches
Public Slots | Signals | Public Member Functions | Protected Member Functions | List of all members
quentier::NoteEditor Class Reference

The NoteEditor class is a widget encapsulating all the functionality necessary for showing and editing notes. More...

#include <NoteEditor.h>

Inheritance diagram for quentier::NoteEditor:
Inheritance graph
[legend]
Collaboration diagram for quentier::NoteEditor:
Collaboration graph
[legend]

Public Slots

void convertToNote ()
 
void saveNoteToLocalStorage ()
 
void setNoteTitle (const QString &noteTitle)
 
void setTagIds (const QStringList &tagLocalUids, const QStringList &tagGuids)
 
void undo ()
 
void redo ()
 
void cut ()
 
void copy ()
 
void paste ()
 
void pasteUnformatted ()
 
void selectAll ()
 
void formatSelectionAsSourceCode ()
 
void fontMenu ()
 
void textBold ()
 
void textItalic ()
 
void textUnderline ()
 
void textStrikethrough ()
 
void textHighlight ()
 
void alignLeft ()
 
void alignCenter ()
 
void alignRight ()
 
void alignFull ()
 
void findNext (const QString &text, const bool matchCase) const
 
void findPrevious (const QString &text, const bool matchCase) const
 
void replace (const QString &textToReplace, const QString &replacementText, const bool matchCase)
 
void replaceAll (const QString &textToReplace, const QString &replacementText, const bool matchCase)
 
void insertToDoCheckbox ()
 
void insertInAppNoteLink (const QString &userId, const QString &shardId, const QString &noteGuid, const QString &linkText)
 
void setSpellcheck (const bool enabled)
 
void setFont (const QFont &font)
 
void setFontHeight (const int height)
 
void setFontColor (const QColor &color)
 
void setBackgroundColor (const QColor &color)
 
void setDefaultPalette (const QPalette &pal)
 
void setDefaultFont (const QFont &font)
 
void insertHorizontalLine ()
 
void increaseFontSize ()
 
void decreaseFontSize ()
 
void increaseIndentation ()
 
void decreaseIndentation ()
 
void insertBulletedList ()
 
void insertNumberedList ()
 
void insertTableDialog ()
 
void insertFixedWidthTable (const int rows, const int columns, const int widthInPixels)
 
void insertRelativeWidthTable (const int rows, const int columns, const double relativeWidth)
 
void insertTableRow ()
 
void insertTableColumn ()
 
void removeTableRow ()
 
void removeTableColumn ()
 
void addAttachmentDialog ()
 
void saveAttachmentDialog (const QByteArray &resourceHash)
 
void saveAttachmentUnderCursor ()
 
void openAttachment (const QByteArray &resourceHash)
 
void openAttachmentUnderCursor ()
 
void copyAttachment (const QByteArray &resourceHash)
 
void copyAttachmentUnderCursor ()
 
void encryptSelectedText ()
 
void decryptEncryptedTextUnderCursor ()
 
void editHyperlinkDialog ()
 
void copyHyperlink ()
 
void removeHyperlink ()
 
void onNoteLoadCancelled ()
 

Signals

void contentChanged ()
 contentChanged signal is emitted when the note's content (text) gets modified via manual editing (i.e. not any action like paste or cut)
 
void noteAndNotebookFoundInLocalStorage (Note note, Notebook notebook)
 noteAndNotebookFoundInLocalStorage signal is emitted when note and its corresponding notebook were found within the local storage right before the note editor starts to load the note into the editor
 
void noteNotFound (QString noteLocalUid)
 noteNotFound signal is emitted when the note could not be found within the local storage by the provided local uid
 
void noteDeleted (QString noteLocalUid)
 noteDeleted signal is emitted when the note displayed within the note editor is deleted. The note editor stops displaying the note in this case shortly after emitting this signal
 
void noteModified ()
 noteModified signal is emitted when the note's content within the editor gets modified via some way - either via manual editing or via some action (like paste or cut)
 
void notifyError (ErrorString error)
 notifyError signal is emitted when NoteEditor encounters some problem worth letting the user to know about
 
void inAppNoteLinkClicked (QString userId, QString shardId, QString noteGuid)
 inAppNoteLinkClicked signal is emitted when the in-app note link is clicked within the note editor
 
void inAppNoteLinkPasteRequested (QString url, QString userId, QString shardId, QString noteGuid)
 
void convertedToNote (Note note)
 
void cantConvertToNote (ErrorString error)
 
void noteEditorHtmlUpdated (QString html)
 
void currentNoteChanged (Note note)
 
void spellCheckerNotReady ()
 
void spellCheckerReady ()
 
void noteLoaded ()
 
void noteSavedToLocalStorage (QString noteLocalUid)
 noteSavedToLocalStorage signal is emitted when the note has been saved within the local storage. NoteEditor doesn't do this on its own unless it's explicitly asked to do this via invoking its saveNoteToLocalStorage slot
 
void failedToSaveNoteToLocalStorage (ErrorString errorDescription, QString noteLocalUid)
 failedToSaveNoteToLocalStorage signal is emitted in case of failure to save the note to local storage
 
void textBoldState (bool state)
 
void textItalicState (bool state)
 
void textUnderlineState (bool state)
 
void textStrikethroughState (bool state)
 
void textAlignLeftState (bool state)
 
void textAlignCenterState (bool state)
 
void textAlignRightState (bool state)
 
void textAlignFullState (bool state)
 
void textInsideOrderedListState (bool state)
 
void textInsideUnorderedListState (bool state)
 
void textInsideTableState (bool state)
 
void textFontFamilyChanged (QString fontFamily)
 
void textFontSizeChanged (int fontSize)
 
void insertTableDialogRequested ()
 

Public Member Functions

 NoteEditor (QWidget *parent=nullptr, Qt::WindowFlags flags={})
 
void initialize (LocalStorageManagerAsync &localStorageManager, SpellChecker &spellChecker, const Account &account, QThread *pBackgroundJobsThread=nullptr)
 
INoteEditorBackendbackend ()
 
void setBackend (INoteEditorBackend *backend)
 
void setAccount (const Account &account)
 
const QUndoStack * undoStack () const
 
void setUndoStack (QUndoStack *pUndoStack)
 
void setInitialPageHtml (const QString &html)
 
void setNoteNotFoundPageHtml (const QString &html)
 
void setNoteDeletedPageHtml (const QString &html)
 
void setNoteLoadingPageHtml (const QString &html)
 
QString currentNoteLocalUid () const
 
void setCurrentNoteLocalUid (const QString &noteLocalUid)
 
void clear ()
 
bool isModified () const
 
bool isEditorPageModified () const
 
bool isNoteLoaded () const
 
qint64 idleTime () const
 
void setFocus ()
 
QString selectedText () const
 
bool hasSelection () const
 
bool spellCheckEnabled () const
 
bool print (QPrinter &printer, ErrorString &errorDescription)
 
bool exportToPdf (const QString &absoluteFilePath, ErrorString &errorDescription)
 
bool exportToEnex (const QStringList &tagNames, QString &enex, ErrorString &errorDescription)
 
QPalette defaultPalette () const
 
const QFont * defaultFont () const
 

Protected Member Functions

virtual void dragMoveEvent (QDragMoveEvent *pEvent) override
 
virtual void dropEvent (QDropEvent *pEvent) override
 

Detailed Description

The NoteEditor class is a widget encapsulating all the functionality necessary for showing and editing notes.

Member Function Documentation

◆ backend()

INoteEditorBackend * quentier::NoteEditor::backend ( )
Returns
the pointer to the note editor's backend

◆ clear()

void quentier::NoteEditor::clear ( )

Clear the contents of the note editor

◆ convertToNote

void quentier::NoteEditor::convertToNote ( )
slot

Invoke this slot to launch the asynchronous procedure of converting the current contents of the note editor to note; the convertedToNote signal would be emitted in response when the conversion is done

◆ currentNoteLocalUid()

QString quentier::NoteEditor::currentNoteLocalUid ( ) const

Get the local uid of the note currently set to the note editor

◆ defaultFont()

const QFont * quentier::NoteEditor::defaultFont ( ) const
Returns
pointer to the default font used by the note editor; if no such font was set to the editor previously, returns null pointer

◆ defaultPalette()

QPalette quentier::NoteEditor::defaultPalette ( ) const
Returns
palette containing default colors used by the editor; the palette is composed of colors from note editor widget's native palette but some of them might be overridden by colors from the palette specified previously via setDefaultPalette method: those colors from the specified palette which were valid

◆ idleTime()

qint64 quentier::NoteEditor::idleTime ( ) const
Returns
the number of milliseconds since the last user's interaction with the note editor or -1 if there was no interaction or if no note is loaded at the moment

◆ inAppNoteLinkPasteRequested

void quentier::NoteEditor::inAppNoteLinkPasteRequested ( QString  url,
QString  userId,
QString  shardId,
QString  noteGuid 
)
signal

inAppNoteLinkPasteRequested signal is emitted when the note editor detects the attempt to paste the in-app note link into the note editor; the link would not be inserted right away, instead this signal would be emitted. Whatever party managing the note editor is expected to connect some slot to this signal and provide the optionally amended link information to the note editor by sending the signal connected to its insertInAppNoteLink slot - this slot accepts both the URL of the link and the link text and performs the actual link insertion into the note. If the link text is empty, the URL itself is used as the link text.

◆ initialize()

void quentier::NoteEditor::initialize ( LocalStorageManagerAsync localStorageManager,
SpellChecker spellChecker,
const Account account,
QThread *  pBackgroundJobsThread = nullptr 
)

NoteEditor requires LocalStorageManagerAsync, SpellChecker and Account for its work but due to the particularities of Qt's .ui files processing these can't be passed right inside the constructor, hence here's a special initialization method

Parameters
localStorageManagerThe reference to LocalStorageManagerAsync, to set up signal-slot connections with it
spellCheckerThe spell checker to be used by note editor for, well, spell-checking
accountCurrently active account
pBackgroundJobsThreadPointer to the thread to be used for scheduling of background jobs of NoteEditor; if null, NoteEditor's background jobs would take place in GUI thread

◆ isEditorPageModified()

bool quentier::NoteEditor::isEditorPageModified ( ) const
Returns
true if there's content within the editor not yet converted to note, false otherwise

◆ isModified()

bool quentier::NoteEditor::isModified ( ) const
Returns
true if there's content within the editor not yet converted to note or not saved to local storage, false otherwise

◆ isNoteLoaded()

bool quentier::NoteEditor::isNoteLoaded ( ) const
Returns
true if the note last set to the editor has been fully loaded already, false otherwise

◆ saveNoteToLocalStorage

void quentier::NoteEditor::saveNoteToLocalStorage ( )
slot

Invoke this slot to launch the asynchronous procedure of saving the modified current note back to the local storage. If no note is set to the editor or if the note is not modified, no action would be performed. Otherwise noteSavedToLocalStorage signal would be emitted in case of successful saving or failedToSaveNoteToLocalStorage would be emitted otherwise

◆ setAccount()

void quentier::NoteEditor::setAccount ( const Account account)

Set the current account to the note editor

◆ setBackend()

void quentier::NoteEditor::setBackend ( INoteEditorBackend backend)

This method can be used to set the backend to the note editor; the note editor has the default backend so this method is not obligatory to be called

◆ setCurrentNoteLocalUid()

void quentier::NoteEditor::setCurrentNoteLocalUid ( const QString &  noteLocalUid)

Set note local uid to the note editor. The note is being searched for within the local storage, in case of no note being found noteNotFound signal is emitted. Otherwise note editor page starts loading.

Parameters
noteLocalUidThe local uid of note

◆ setDefaultFont

void quentier::NoteEditor::setDefaultFont ( const QFont &  font)
slot

Sets the font which would be used by the editor by default

Parameters
fontThe font to be used by the editor by default

◆ setDefaultPalette

void quentier::NoteEditor::setDefaultPalette ( const QPalette &  pal)
slot

Sets the palette with colors to be used by the editor. New colors are applied after the note is fully loaded. If no note is set to the editor, the palette is simply remembered for the next note to be loaded into it.

Colors within the palette and their usage:

  1. WindowText - used as default font color
  2. Base - used as default background color
  3. HighlightedText - used as font color for selected text
  4. Highlight - used as background color for selected text
Parameters
palThe palette to be set. Invalid colors from it are substituted by colors from widget's palette by the editor

◆ setFocus()

void quentier::NoteEditor::setFocus ( )

Sets the focus to the backend note editor widget

◆ setInitialPageHtml()

void quentier::NoteEditor::setInitialPageHtml ( const QString &  html)

Set the html to be displayed when the note is not set to the editor

◆ setNoteDeletedPageHtml()

void quentier::NoteEditor::setNoteDeletedPageHtml ( const QString &  html)

Set the html to be displayed when the note set to the editor was deleted from the local storage (either marked as deleted or deleted permanently i.e. expunged)

◆ setNoteLoadingPageHtml()

void quentier::NoteEditor::setNoteLoadingPageHtml ( const QString &  html)

Set the html to be displayed when the note set to the editor is being loaded into it

◆ setNoteNotFoundPageHtml()

void quentier::NoteEditor::setNoteNotFoundPageHtml ( const QString &  html)

Set the html to be displayed when the note attempted to be set to the editor was not found within the local storage

◆ setNoteTitle

void quentier::NoteEditor::setNoteTitle ( const QString &  noteTitle)
slot

Invoke this slot to set the title to the note displayed via the note editor. The note editor itself doesn't manage the note title in any way so any external code using the note editor can set the title to the note editor's note which would be considered modified if the title is new and then eventually the note would be saved to local storage

Parameters
noteTitleThe title of the note

◆ setTagIds

void quentier::NoteEditor::setTagIds ( const QStringList &  tagLocalUids,
const QStringList &  tagGuids 
)
slot

Invoke this slot to set tag local uids and/or tag guids to the note displayed via the note editor. The note editor itself doesn't manage the note tags in any way so any external code using the note editor can set the tag ids to the note editor's internal note which would be considered modified if the tag ids are new and then eventually the note would be saved to local storage

Parameters
tagLocalUidsThe list of tag local uids for the note
tagGuidsThe list of tag guids for the note

◆ setUndoStack()

void quentier::NoteEditor::setUndoStack ( QUndoStack *  pUndoStack)

Set the undo stack for the note editor to use

◆ undoStack()

const QUndoStack * quentier::NoteEditor::undoStack ( ) const

Get the undo stack serving to the note editor