" + QString(tr("Profile last updated %1")). arg(relativeFuzzyTime(m_actor->updatedDate(), true)); } else { infoStr = QString("%1"). arg(relativeFuzzyTime(m_object->published())). arg(m_object->url()); if (m_object->published() != m_object->updatedDate()) infoStr += ", " + QString(tr("updated %1")). arg(relativeFuzzyTime(m_object->updatedDate())); QASActor* author = m_object->author(); if (author) infoStr = QString("%1"). arg(author->displayName()). arg(author->url()) + " " + QString(tr("at %1", "time when post was published")).arg(infoStr); QASLocation* loc = m_object->location(); if (!loc->isEmpty()) { QString locInfo = loc->displayName(); if (loc->hasPosition()) locInfo = QString("%1").arg(locInfo). arg(loc->osmURL(10)); infoStr += " @ " + locInfo; } } m_infoLabel->setText(infoStr + "."); } //------------------------------------------------------------------------------ void FullObjectWidget::updateFavourButton(bool wait) { if (!m_favourButton) return; QString text = m_object->liked() ? tr("unlike") : tr("like"); if (wait) text = "..."; m_favourButton->setText(text); } //------------------------------------------------------------------------------ void FullObjectWidget::updateShareButton(bool /*wait*/) { if (!m_shareButton) return; m_shareButton->setText(tr("share")); } //------------------------------------------------------------------------------ bool FullObjectWidget::isFollowable(QASObject* obj) const { if (!obj) return false; QASActor* actor = obj->asActor(); return obj->type() == "person" && actor && !actor->isYou(); } //------------------------------------------------------------------------------ void FullObjectWidget::updateFollowButton(bool /*wait*/) { if (!m_followButton) return; if (!isFollowable(m_object) || !m_actor->followedKnown()) { m_followButton->setVisible(false); return; } m_followButton->setVisible(true); m_followButton->setText(m_actor->followed() ? tr("stop following") : tr("follow")); } //------------------------------------------------------------------------------ void FullObjectWidget::updateFollowAuthorButton(bool /*wait*/) { if (!m_followAuthorButton) return; if (!m_author || !isFollowable(m_author) || m_author->followed() || !m_author->followedKnown()) { m_followAuthorButton->setVisible(false); return; } m_followAuthorButton->setVisible(true); QString text = QString(tr("follow %1")).arg(m_author->preferredUsername()); m_followAuthorButton->setText(text); } //------------------------------------------------------------------------------ void FullObjectWidget::updateDeleteEditButtons() { bool isYours = m_author && m_author->isYou(); if (isCommentable()) { m_deleteButton->setVisible(isYours); m_editButton->setVisible(isYours); } else { m_deleteButton->setVisible(false); m_editButton->setVisible(false); } } //------------------------------------------------------------------------------ void FullObjectWidget::updateImage() { FileDownloadManager* fdm = FileDownloadManager::getManager(); if (fdm->hasFile(m_imageUrl)) { if (fdm->supportsAnimation(m_imageUrl)) { QMovie* mov = fdm->movie(m_imageUrl); m_imageLabel->setMovie(mov); mov->start(); } else { m_imageLabel->setPixmap(fdm->pixmap(m_imageUrl, ":/images/image_broken.png")); } } else { m_imageLabel->setPixmap(QPixmap(":/images/image_downloading.png")); if (!m_imageUrl.isEmpty()) { FileDownloader* fd = fdm->download(m_imageUrl); connect(fd, SIGNAL(fileReady()), this, SLOT(updateImage()), Qt::UniqueConnection); } } } //------------------------------------------------------------------------------ void FullObjectWidget::updateLikes() { size_t nl = m_object->numLikes(); if (nl <= 0) { if (m_likesLabel != NULL) { m_contentLayout->removeWidget(m_likesLabel); delete m_likesLabel; m_likesLabel = NULL; } return; } QASActorList* likes = m_object->likes(); QString text; if (m_likesLabel == NULL) { m_likesLabel = new RichTextLabel(this); connect(m_likesLabel, SIGNAL(linkHovered(const QString&)), this, SIGNAL(linkHovered(const QString&))); m_contentLayout->addWidget(m_likesLabel); } QString nstr = likes->actorNames(); if (likes->onlyYou()) text = QString(" ") + tr("You like this."); else if (nl==1) text = " " + QString(tr("%1 likes this.")).arg(nstr); else text = " " + QString(tr("%1 like this.")).arg(nstr); m_likesLabel->setText(text); } //------------------------------------------------------------------------------ void FullObjectWidget::updateShares() { size_t ns = m_object->numShares(); if (!ns) { if (m_sharesLabel != NULL) { m_contentLayout->removeWidget(m_sharesLabel); delete m_sharesLabel; m_sharesLabel = NULL; } return; } if (m_sharesLabel == NULL) { m_sharesLabel = new RichTextLabel(this); connect(m_sharesLabel, SIGNAL(linkHovered(const QString&)), this, SIGNAL(linkHovered(const QString&))); m_contentLayout->addWidget(m_sharesLabel); } QString text; if (m_object->shares()->size()) { text = m_object->shares()->actorNames(); int others = ns-m_object->shares()->size(); if (others >= 1) text += QString(" ") + tr("and %Ln other person(s)", 0, others); if (ns > 1) text += QString(" ") + tr("shared this.", "Many persons shared"); else text += QString(" ") + tr("shared this.", "One person shared"); } else { if (ns >= 1) text = tr("%Ln person(s) shared this.", 0, ns); } m_sharesLabel->setText(text); } //------------------------------------------------------------------------------ void FullObjectWidget::imageClicked() { QString url = m_object->fullImageUrl(); if (!url.isEmpty()) QDesktopServices::openUrl(url); } //------------------------------------------------------------------------------ void FullObjectWidget::addObjectList(QASObjectList* ol) { int li = 0; // index where to insert next widget in the layout int li_before = li; if (m_hasMoreButton != NULL) li++; /* For now we sort by time, or more accurately by whatever number the QASObject::sortInt() returns. Higher number is newer, goes further down the list. */ for (size_t j=0; j
:s while (text.endsWith("
")) text.chop(4); return text; } //------------------------------------------------------------------------------ void FullObjectWidget::clearObjectList() { QLayoutItem* item; while ((item = m_commentsLayout->takeAt(0)) != 0) { if (dynamic_cast
In order to use pump.io you need to first register an "
"account with a pump.io server. If you haven't done this yet "
"you can do it now by trying out one of the existing public "
"servers:
"
"http://pump.io/tryit.html.
When you are done enter your new pump.io account id " "below in the form of username@servername.
"), this); infoLabel->setOpenExternalLinks(true); infoLabel->setTextInteractionFlags(Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse); infoLabel->setWordWrap(true); layout->addWidget(infoLabel); layout->addStretch(); m_messageLabel = new QLabel(this); layout->addWidget(m_messageLabel); QLabel* accountIdLabel = new QLabel(tr("Your pump.io account id:"), this); QLineEdit* accountIdEdit = new QLineEdit(EXAMPLE_ACCOUNT_ID, this); accountIdLabel->setBuddy(accountIdEdit); connect(accountIdEdit, SIGNAL(textEdited(const QString&)), this, SIGNAL(completeChanged())); QCheckBox* sslCheckBox = new QCheckBox(tr("Use secure connection (recommended)"), this); sslCheckBox->setChecked(true); layout->addWidget(accountIdLabel); layout->addWidget(accountIdEdit); layout->addWidget(sslCheckBox); registerField("accountId*", accountIdEdit); registerField("useSsl*", sslCheckBox); setButtonText(QWizard::CommitButton, tr("Next")); setCommitPage(true); setLayout(layout); } //------------------------------------------------------------------------------ void OAuthFirstPage::setMessage(QString msg) { m_messageLabel->setText(msg); } //------------------------------------------------------------------------------ bool OAuthFirstPage::splitAccountId(QString& username, QString& server) const { QString accountId = field("accountId").toString().trimmed(); if (accountId == EXAMPLE_ACCOUNT_ID) return false; return splitWebfingerId(accountId, username, server); } //------------------------------------------------------------------------------ bool OAuthFirstPage::isComplete() const { QString username, server; return splitAccountId(username, server); } //------------------------------------------------------------------------------ bool OAuthFirstPage::validatePage() { QString username, server; bool ok = splitAccountId(username, server); if (!ok) return false; emit committed(username, server); return true; } //------------------------------------------------------------------------------ OAuthSecondPage::OAuthSecondPage(QWidget* parent) : QWizardPage(parent) { setTitle(tr("Authorise Pumpa")); QVBoxLayout* layout = new QVBoxLayout(this); QLabel* infoLabel = new QLabel(tr("In order for Pumpa to be able to read and post new messages " "to your pump.io account you need to grant Pumpa access via " "the web page. Pumpa will open the web page for you - just " "follow the instructions and copy & paste the " "verifier text string back into the field below. (The " "token should be automatically pre-filled.)"), this); infoLabel->setWordWrap(true); layout->addWidget(infoLabel); QLabel* tokenLabel = new QLabel(tr("Token:"), this); QLineEdit* tokenEdit = new QLineEdit(this); tokenLabel->setBuddy(tokenEdit); layout->addWidget(tokenLabel); layout->addWidget(tokenEdit); QLabel* verifierLabel = new QLabel(tr("Verifier:"), this); QLineEdit* verifierEdit = new QLineEdit(this); verifierLabel->setBuddy(verifierEdit); layout->addWidget(verifierLabel); layout->addWidget(verifierEdit); registerField("token*", tokenEdit); registerField("verifier*", verifierEdit); setLayout(layout); } //------------------------------------------------------------------------------ bool OAuthSecondPage::validatePage() { QString token = field("token").toString(); QString verifier = field("verifier").toString(); if (token.isEmpty() || verifier.isEmpty()) return false; emit committed(token, verifier); return true; } //------------------------------------------------------------------------------ OAuthWizard::OAuthWizard(QNetworkAccessManager* nam, KQOAuthManager* oam, QWidget* parent) : QWizard(parent), m_oam(oam), m_nam(nam) { setWindowTitle(CLIENT_FANCY_NAME); m_oar = new KQOAuthRequest(this); p1 = new OAuthFirstPage(this); p2 = new OAuthSecondPage(this); connect(p1, SIGNAL(committed(QString, QString)), this, SLOT(onFirstPageCommitted(QString, QString))); connect(p2, SIGNAL(committed(QString, QString)), this, SLOT(onSecondPageCommitted(QString, QString))); addPage(p1); addPage(p2); } //------------------------------------------------------------------------------ void OAuthWizard::notifyMessage(QString msg) { qDebug() << "[OAuthWizard]" << msg; } //------------------------------------------------------------------------------ void OAuthWizard::errorMessage(QString msg) { p1->setMessage(""+msg+""); qDebug() << "[OAuthWizard ERROR]" << msg; back(); } //------------------------------------------------------------------------------ void OAuthWizard::onFirstPageCommitted(QString username, QString server) { m_username = username; m_server = siteUrlFixer(server, field("useSsl").toBool()); m_clientRegTryCount = 0; registerOAuthClient(); } //------------------------------------------------------------------------------ void OAuthWizard::registerOAuthClient() { notifyMessage(tr("Registering client ...")); m_clientRegTryCount++; QUrl serverUrl(m_server); serverUrl.setPath("/api/client/register"); qDebug() << serverUrl; QNetworkRequest req; req.setUrl(serverUrl); req.setHeader(QNetworkRequest::ContentTypeHeader, "application/json"); QVariantMap post; post["type"] = "client_associate"; post["application_type"] = "native"; post["application_name"] = CLIENT_FANCY_NAME; post["logo_uri"] = "http://saz.im/images/pumpa.png"; QByteArray postData = serializeJson(post); // qDebug() << "data=" << postData; QNetworkReply *reply = m_nam->post(req, postData); connect(reply, SIGNAL(finished()), this, SLOT(onOAuthClientRegDone())); } //------------------------------------------------------------------------------ void OAuthWizard::onOAuthClientRegDone() { QNetworkReply *reply = qobject_castsize; ++i, ++cls) {
while (i < lang->size && isspace(lang->data[i]))
i++;
if (i < lang->size) {
size_t org = i;
while (i < lang->size && !isspace(lang->data[i]))
i++;
if (lang->data[org] == '.')
org++;
if (cls) bufputc(ob, ' ');
escape_html(ob, lang->data + org, i - org);
}
}
BUFPUTSL(ob, "\">");
} else
BUFPUTSL(ob, "");
if (text)
escape_html(ob, text->data, text->size);
BUFPUTSL(ob, "
\n");
}
static void
rndr_blockquote(struct buf *ob, const struct buf *text, void *opaque)
{
if (ob->size) bufputc(ob, '\n');
BUFPUTSL(ob, "\n");
if (text) bufput(ob, text->data, text->size);
BUFPUTSL(ob, "
\n");
}
static int
rndr_codespan(struct buf *ob, const struct buf *text, void *opaque)
{
BUFPUTSL(ob, "");
if (text) escape_html(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static int
rndr_strikethrough(struct buf *ob, const struct buf *text, void *opaque)
{
if (!text || !text->size)
return 0;
BUFPUTSL(ob, "");
bufput(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static int
rndr_double_emphasis(struct buf *ob, const struct buf *text, void *opaque)
{
if (!text || !text->size)
return 0;
BUFPUTSL(ob, "");
bufput(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static int
rndr_emphasis(struct buf *ob, const struct buf *text, void *opaque)
{
if (!text || !text->size) return 0;
BUFPUTSL(ob, "");
if (text) bufput(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static int
rndr_linebreak(struct buf *ob, void *opaque)
{
struct html_renderopt *options = opaque;
bufputs(ob, USE_XHTML(options) ? "
\n" : "
\n");
return 1;
}
static void
rndr_header(struct buf *ob, const struct buf *text, int level, void *opaque)
{
struct html_renderopt *options = opaque;
if (ob->size)
bufputc(ob, '\n');
if (options->flags & HTML_TOC)
bufprintf(ob, "", level, options->toc_data.header_count++);
else
bufprintf(ob, "", level);
if (text) bufput(ob, text->data, text->size);
bufprintf(ob, " \n", level);
}
static int
rndr_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque)
{
struct html_renderopt *options = opaque;
if (link != NULL && (options->flags & HTML_SAFELINK) != 0 && !sd_autolink_issafe(link->data, link->size))
return 0;
BUFPUTSL(ob, "size)
escape_href(ob, link->data, link->size);
if (title && title->size) {
BUFPUTSL(ob, "\" title=\"");
escape_html(ob, title->data, title->size);
}
if (options->link_attributes) {
bufputc(ob, '\"');
options->link_attributes(ob, link, opaque);
bufputc(ob, '>');
} else {
BUFPUTSL(ob, "\">");
}
if (content && content->size) bufput(ob, content->data, content->size);
BUFPUTSL(ob, "");
return 1;
}
static void
rndr_list(struct buf *ob, const struct buf *text, int flags, void *opaque)
{
if (ob->size) bufputc(ob, '\n');
bufput(ob, flags & MKD_LIST_ORDERED ? "\n" : "\n", 5);
if (text) bufput(ob, text->data, text->size);
bufput(ob, flags & MKD_LIST_ORDERED ? "
\n" : "\n", 6);
}
static void
rndr_listitem(struct buf *ob, const struct buf *text, int flags, void *opaque)
{
BUFPUTSL(ob, "");
if (text) {
size_t size = text->size;
while (size && text->data[size - 1] == '\n')
size--;
bufput(ob, text->data, size);
}
BUFPUTSL(ob, " \n");
}
static void
rndr_paragraph(struct buf *ob, const struct buf *text, void *opaque)
{
struct html_renderopt *options = opaque;
size_t i = 0;
if (ob->size) bufputc(ob, '\n');
if (!text || !text->size)
return;
while (i < text->size && isspace(text->data[i])) i++;
if (i == text->size)
return;
BUFPUTSL(ob, "");
if (options->flags & HTML_HARD_WRAP) {
size_t org;
while (i < text->size) {
org = i;
while (i < text->size && text->data[i] != '\n')
i++;
if (i > org)
bufput(ob, text->data + org, i - org);
/*
* do not insert a line break if this newline
* is the last character on the paragraph
*/
if (i >= text->size - 1)
break;
rndr_linebreak(ob, opaque);
i++;
}
} else {
bufput(ob, &text->data[i], text->size - i);
}
BUFPUTSL(ob, "
\n");
}
static void
rndr_raw_block(struct buf *ob, const struct buf *text, void *opaque)
{
size_t org, sz;
if (!text) return;
sz = text->size;
while (sz > 0 && text->data[sz - 1] == '\n') sz--;
org = 0;
while (org < sz && text->data[org] == '\n') org++;
if (org >= sz) return;
if (ob->size) bufputc(ob, '\n');
bufput(ob, text->data + org, sz - org);
bufputc(ob, '\n');
}
static int
rndr_triple_emphasis(struct buf *ob, const struct buf *text, void *opaque)
{
if (!text || !text->size) return 0;
BUFPUTSL(ob, "");
bufput(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static void
rndr_hrule(struct buf *ob, void *opaque)
{
struct html_renderopt *options = opaque;
if (ob->size) bufputc(ob, '\n');
bufputs(ob, USE_XHTML(options) ? "
\n" : "
\n");
}
static int
rndr_image(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque)
{
struct html_renderopt *options = opaque;
if (!link || !link->size) return 0;
BUFPUTSL(ob, "![](\"");)
data, link->size);
BUFPUTSL(ob, "\" alt=\"");
if (alt && alt->size)
escape_html(ob, alt->data, alt->size);
if (title && title->size) {
BUFPUTSL(ob, "\" title=\"");
escape_html(ob, title->data, title->size); }
bufputs(ob, USE_XHTML(options) ? "\"/>" : "\">");
return 1;
}
static int
rndr_raw_html(struct buf *ob, const struct buf *text, void *opaque)
{
struct html_renderopt *options = opaque;
/* HTML_ESCAPE overrides SKIP_HTML, SKIP_STYLE, SKIP_LINKS and SKIP_IMAGES
* It doens't see if there are any valid tags, just escape all of them. */
if((options->flags & HTML_ESCAPE) != 0) {
escape_html(ob, text->data, text->size);
return 1;
}
if ((options->flags & HTML_SKIP_HTML) != 0)
return 1;
if ((options->flags & HTML_SKIP_STYLE) != 0 &&
sdhtml_is_tag(text->data, text->size, "style"))
return 1;
if ((options->flags & HTML_SKIP_LINKS) != 0 &&
sdhtml_is_tag(text->data, text->size, "a"))
return 1;
if ((options->flags & HTML_SKIP_IMAGES) != 0 &&
sdhtml_is_tag(text->data, text->size, "img"))
return 1;
bufput(ob, text->data, text->size);
return 1;
}
static void
rndr_table(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque)
{
if (ob->size) bufputc(ob, '\n');
BUFPUTSL(ob, "\n");
if (header)
bufput(ob, header->data, header->size);
BUFPUTSL(ob, "\n");
if (body)
bufput(ob, body->data, body->size);
BUFPUTSL(ob, "
\n");
}
static void
rndr_tablerow(struct buf *ob, const struct buf *text, void *opaque)
{
BUFPUTSL(ob, "\n");
if (text)
bufput(ob, text->data, text->size);
BUFPUTSL(ob, " \n");
}
static void
rndr_tablecell(struct buf *ob, const struct buf *text, int flags, void *opaque)
{
if (flags & MKD_TABLE_HEADER) {
BUFPUTSL(ob, "");
break;
case MKD_TABLE_ALIGN_L:
BUFPUTSL(ob, " align=\"left\">");
break;
case MKD_TABLE_ALIGN_R:
BUFPUTSL(ob, " align=\"right\">");
break;
default:
BUFPUTSL(ob, ">");
}
if (text)
bufput(ob, text->data, text->size);
if (flags & MKD_TABLE_HEADER) {
BUFPUTSL(ob, "\n");
} else {
BUFPUTSL(ob, "\n");
}
}
static int
rndr_superscript(struct buf *ob, const struct buf *text, void *opaque)
{
if (!text || !text->size) return 0;
BUFPUTSL(ob, "");
bufput(ob, text->data, text->size);
BUFPUTSL(ob, "");
return 1;
}
static void
rndr_normal_text(struct buf *ob, const struct buf *text, void *opaque)
{
if (text)
escape_html(ob, text->data, text->size);
}
static void
toc_header(struct buf *ob, const struct buf *text, int level, void *opaque)
{
struct html_renderopt *options = opaque;
/* set the level offset if this is the first header
* we're parsing for the document */
if (options->toc_data.current_level == 0) {
options->toc_data.level_offset = level - 1;
}
level -= options->toc_data.level_offset;
if (level > options->toc_data.current_level) {
while (level > options->toc_data.current_level) {
BUFPUTSL(ob, "\n- \n");
options->toc_data.current_level++;
}
} else if (level < options->toc_data.current_level) {
BUFPUTSL(ob, "
\n");
while (level < options->toc_data.current_level) {
BUFPUTSL(ob, "
\n\n");
options->toc_data.current_level--;
}
BUFPUTSL(ob,"\n");
} else {
BUFPUTSL(ob," \n\n");
}
bufprintf(ob, "", options->toc_data.header_count++);
if (text)
escape_html(ob, text->data, text->size);
BUFPUTSL(ob, "\n");
}
static int
toc_link(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque)
{
if (content && content->size)
bufput(ob, content->data, content->size);
return 1;
}
static void
toc_finalize(struct buf *ob, void *opaque)
{
struct html_renderopt *options = opaque;
while (options->toc_data.current_level > 0) {
BUFPUTSL(ob, " \n\n");
options->toc_data.current_level--;
}
}
void
sdhtml_toc_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options)
{
static const struct sd_callbacks cb_default = {
NULL,
NULL,
NULL,
toc_header,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
rndr_codespan,
rndr_double_emphasis,
rndr_emphasis,
NULL,
NULL,
toc_link,
NULL,
rndr_triple_emphasis,
rndr_strikethrough,
rndr_superscript,
NULL,
NULL,
NULL,
toc_finalize,
};
memset(options, 0x0, sizeof(struct html_renderopt));
options->flags = HTML_TOC;
memcpy(callbacks, &cb_default, sizeof(struct sd_callbacks));
}
void
sdhtml_renderer(struct sd_callbacks *callbacks, struct html_renderopt *options, unsigned int render_flags)
{
static const struct sd_callbacks cb_default = {
rndr_blockcode,
rndr_blockquote,
rndr_raw_block,
rndr_header,
rndr_hrule,
rndr_list,
rndr_listitem,
rndr_paragraph,
rndr_table,
rndr_tablerow,
rndr_tablecell,
rndr_autolink,
rndr_codespan,
rndr_double_emphasis,
rndr_emphasis,
rndr_image,
rndr_linebreak,
rndr_link,
rndr_raw_html,
rndr_triple_emphasis,
rndr_strikethrough,
rndr_superscript,
NULL,
rndr_normal_text,
NULL,
NULL,
};
/* Prepare the options pointer */
memset(options, 0x0, sizeof(struct html_renderopt));
options->flags = render_flags;
/* Prepare the callbacks */
memcpy(callbacks, &cb_default, sizeof(struct sd_callbacks));
if (render_flags & HTML_SKIP_IMAGES)
callbacks->image = NULL;
if (render_flags & HTML_SKIP_LINKS) {
callbacks->link = NULL;
callbacks->autolink = NULL;
}
if (render_flags & HTML_SKIP_HTML || render_flags & HTML_ESCAPE)
callbacks->blockhtml = NULL;
}
pumpa-0.9.2/src/sundown/markdown.h 0000644 0001750 0001750 00000011365 12653206625 015632 0 ustar mats mats /* markdown.h - generic markdown parser */
/*
* Copyright (c) 2009, Natacha Porté
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef UPSKIRT_MARKDOWN_H
#define UPSKIRT_MARKDOWN_H
#include "buffer.h"
#include "autolink.h"
#ifdef __cplusplus
extern "C" {
#endif
#define SUNDOWN_VERSION "1.16.0"
#define SUNDOWN_VER_MAJOR 1
#define SUNDOWN_VER_MINOR 16
#define SUNDOWN_VER_REVISION 0
/********************
* TYPE DEFINITIONS *
********************/
/* mkd_autolink - type of autolink */
enum mkd_autolink {
MKDA_NOT_AUTOLINK, /* used internally when it is not an autolink*/
MKDA_NORMAL, /* normal http/http/ftp/mailto/etc link */
MKDA_EMAIL, /* e-mail link without explit mailto: */
};
enum mkd_tableflags {
MKD_TABLE_ALIGN_L = 1,
MKD_TABLE_ALIGN_R = 2,
MKD_TABLE_ALIGN_CENTER = 3,
MKD_TABLE_ALIGNMASK = 3,
MKD_TABLE_HEADER = 4
};
enum mkd_extensions {
MKDEXT_NO_INTRA_EMPHASIS = (1 << 0),
MKDEXT_TABLES = (1 << 1),
MKDEXT_FENCED_CODE = (1 << 2),
MKDEXT_AUTOLINK = (1 << 3),
MKDEXT_STRIKETHROUGH = (1 << 4),
MKDEXT_SPACE_HEADERS = (1 << 6),
MKDEXT_SUPERSCRIPT = (1 << 7),
MKDEXT_LAX_SPACING = (1 << 8),
};
/* sd_callbacks - functions for rendering parsed data */
struct sd_callbacks {
/* block level callbacks - NULL skips the block */
void (*blockcode)(struct buf *ob, const struct buf *text, const struct buf *lang, void *opaque);
void (*blockquote)(struct buf *ob, const struct buf *text, void *opaque);
void (*blockhtml)(struct buf *ob,const struct buf *text, void *opaque);
void (*header)(struct buf *ob, const struct buf *text, int level, void *opaque);
void (*hrule)(struct buf *ob, void *opaque);
void (*list)(struct buf *ob, const struct buf *text, int flags, void *opaque);
void (*listitem)(struct buf *ob, const struct buf *text, int flags, void *opaque);
void (*paragraph)(struct buf *ob, const struct buf *text, void *opaque);
void (*table)(struct buf *ob, const struct buf *header, const struct buf *body, void *opaque);
void (*table_row)(struct buf *ob, const struct buf *text, void *opaque);
void (*table_cell)(struct buf *ob, const struct buf *text, int flags, void *opaque);
/* span level callbacks - NULL or return 0 prints the span verbatim */
int (*autolink)(struct buf *ob, const struct buf *link, enum mkd_autolink type, void *opaque);
int (*codespan)(struct buf *ob, const struct buf *text, void *opaque);
int (*double_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
int (*emphasis)(struct buf *ob, const struct buf *text, void *opaque);
int (*image)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *alt, void *opaque);
int (*linebreak)(struct buf *ob, void *opaque);
int (*link)(struct buf *ob, const struct buf *link, const struct buf *title, const struct buf *content, void *opaque);
int (*raw_html_tag)(struct buf *ob, const struct buf *tag, void *opaque);
int (*triple_emphasis)(struct buf *ob, const struct buf *text, void *opaque);
int (*strikethrough)(struct buf *ob, const struct buf *text, void *opaque);
int (*superscript)(struct buf *ob, const struct buf *text, void *opaque);
/* low level callbacks - NULL copies input directly into the output */
void (*entity)(struct buf *ob, const struct buf *entity, void *opaque);
void (*normal_text)(struct buf *ob, const struct buf *text, void *opaque);
/* header and footer */
void (*doc_header)(struct buf *ob, void *opaque);
void (*doc_footer)(struct buf *ob, void *opaque);
};
struct sd_markdown;
/*********
* FLAGS *
*********/
/* list/listitem flags */
#define MKD_LIST_ORDERED 1
#define MKD_LI_BLOCK 2 /* containing block data */
/**********************
* EXPORTED FUNCTIONS *
**********************/
extern struct sd_markdown *
sd_markdown_new(
unsigned int extensions,
size_t max_nesting,
const struct sd_callbacks *callbacks,
void *opaque);
extern void
sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md);
extern void
sd_markdown_free(struct sd_markdown *md);
extern void
sd_version(int *major, int *minor, int *revision);
#ifdef __cplusplus
}
#endif
#endif
/* vim: set filetype=c: */
pumpa-0.9.2/src/sundown/houdini.h 0000644 0001750 0001750 00000002504 12653206625 015442 0 ustar mats mats #ifndef HOUDINI_H__
#define HOUDINI_H__
#include "buffer.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifdef HOUDINI_USE_LOCALE
# define _isxdigit(c) isxdigit(c)
# define _isdigit(c) isdigit(c)
#else
/*
* Helper _isdigit methods -- do not trust the current locale
* */
# define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
# define _isdigit(c) ((c) >= '0' && (c) <= '9')
#endif
extern void houdini_escape_html(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_html0(struct buf *ob, const uint8_t *src, size_t size, int secure);
extern void houdini_unescape_html(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_xml(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_uri(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_url(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_href(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_unescape_uri(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_unescape_url(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_escape_js(struct buf *ob, const uint8_t *src, size_t size);
extern void houdini_unescape_js(struct buf *ob, const uint8_t *src, size_t size);
#ifdef __cplusplus
}
#endif
#endif
pumpa-0.9.2/src/sundown/buffer.h 0000644 0001750 0001750 00000005631 12653206625 015260 0 ustar mats mats /*
* Copyright (c) 2008, Natacha Porté
* Copyright (c) 2011, Vicent Martí
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#ifndef BUFFER_H__
#define BUFFER_H__
#include
#include
#include
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_MSC_VER)
#define __attribute__(x)
#define inline
#endif
typedef enum {
BUF_OK = 0,
BUF_ENOMEM = -1,
} buferror_t;
/* struct buf: character array buffer */
struct buf {
uint8_t *data; /* actual character data */
size_t size; /* size of the string */
size_t asize; /* allocated size (0 = volatile buffer) */
size_t unit; /* reallocation unit size (0 = read-only buffer) */
};
/* CONST_BUF: global buffer from a string litteral */
#define BUF_STATIC(string) \
{ (uint8_t *)string, sizeof string -1, sizeof string, 0, 0 }
/* VOLATILE_BUF: macro for creating a volatile buffer on the stack */
#define BUF_VOLATILE(strname) \
{ (uint8_t *)strname, strlen(strname), 0, 0, 0 }
/* BUFPUTSL: optimized bufputs of a string litteral */
#define BUFPUTSL(output, literal) \
bufput(output, literal, sizeof literal - 1)
/* bufgrow: increasing the allocated size to the given value */
int bufgrow(struct buf *, size_t);
/* bufnew: allocation of a new buffer */
struct buf *bufnew(size_t) __attribute__ ((malloc));
/* bufnullterm: NUL-termination of the string array (making a C-string) */
const char *bufcstr(struct buf *);
/* bufprefix: compare the beginning of a buffer with a string */
int bufprefix(const struct buf *buf, const char *prefix);
/* bufput: appends raw data to a buffer */
void bufput(struct buf *, const void *, size_t);
/* bufputs: appends a NUL-terminated string to a buffer */
void bufputs(struct buf *, const char *);
/* bufputc: appends a single char to a buffer */
void bufputc(struct buf *, int);
/* bufrelease: decrease the reference count and free the buffer if needed */
void bufrelease(struct buf *);
/* bufreset: frees internal data of the buffer */
void bufreset(struct buf *);
/* bufslurp: removes a given number of bytes from the head of the array */
void bufslurp(struct buf *, size_t);
/* bufprintf: formatted printing to a buffer */
void bufprintf(struct buf *, const char *, ...) __attribute__ ((format (printf, 2, 3)));
#ifdef __cplusplus
}
#endif
#endif
pumpa-0.9.2/src/contextwidget.cpp 0000644 0001750 0001750 00000004440 12653206625 015532 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
ContextWidget::ContextWidget(QWidget* parent) :
ASWidget(parent),
m_numReplies(-1),
m_object(NULL)
{}
//------------------------------------------------------------------------------
void ContextWidget::setObject(QASObject* obj) {
clear();
m_asMode = QAS_OBJECT;
m_object = obj;
connect(m_object, SIGNAL(changed()), this, SLOT(update()),
Qt::UniqueConnection);
ObjectWidget* ow = new ObjectWidget(m_object, this);
ow->disableLessButton();
ObjectWidgetWithSignals::connectSignals(ow, this);
connect(ow, SIGNAL(showContext(QASObject*)),
this, SIGNAL(showContext(QASObject*)));
m_itemLayout->insertWidget(0, ow);
m_itemLayout->addStretch();
refreshObject(m_object);
refreshObject(m_object->replies());
updateNumReplies();
m_firstTime = false;
}
//------------------------------------------------------------------------------
void ContextWidget::fetchNewer() {
if (m_object)
emit request(m_object->urlOrProxy(), m_asMode | QAS_NEWER);
}
//------------------------------------------------------------------------------
bool ContextWidget::updateNumReplies() {
int oldNr = m_numReplies;
m_numReplies = m_object->replies() ? m_object->replies()->size() : -1;
return oldNr != m_numReplies;
}
//------------------------------------------------------------------------------
void ContextWidget::update() {
if (!isVisible() && updateNumReplies())
emit highlightMe();
}
pumpa-0.9.2/src/recipientedit.h 0000644 0001750 0001750 00000002434 12653206625 015140 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
//------------------------------------------------------------------------------
class RecipientEdit : public QLineEdit {
Q_OBJECT
public:
RecipientEdit(QWidget* parent=0);
void setChoices(QStringList choices);
signals:
void ready();
protected slots:
void insertCompletion(QString completion);
protected:
virtual void keyPressEvent(QKeyEvent* event);
QPair wordPosAtCursor();
void complete();
QStringList m_choices;
QCompleter* m_completer;
};
#endif
pumpa-0.9.2/src/fancyhighlighter.cpp 0000644 0001750 0001750 00000003417 12653206625 016164 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
FancyHighlighter::FancyHighlighter(QTextDocument* doc, QASpell* checker) :
QSyntaxHighlighter(doc), m_checker(checker) {}
//------------------------------------------------------------------------------
void FancyHighlighter::highlightBlock(const QString& text) {
QTextCharFormat urlHighlightFormat;
urlHighlightFormat.setForeground(QBrush(Qt::blue));
#ifdef USE_ASPELL
int index;
QTextCharFormat spellErrorFormat;
spellErrorFormat.setFontUnderline(true);
spellErrorFormat.setUnderlineColor(Qt::red);
spellErrorFormat.setUnderlineStyle(QTextCharFormat::WaveUnderline);
QRegExp rxa("(^|\\s)(\\w[\\w']*\\w)");
index = text.indexOf(rxa);
while (index >= 0) {
int length = rxa.matchedLength();
int offset = rxa.cap(1).count();
int s = index+offset;
int l = length-offset;
if (!m_checker->checkWord(rxa.cap(2)))
setFormat(s, l, spellErrorFormat);
index = text.indexOf(rxa, index + length);
}
#endif // USE_ASPELL
}
pumpa-0.9.2/src/pumpasettingsdialog.cpp 0000644 0001750 0001750 00000014735 12653206625 016735 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see comboToFeeds;
if (comboToFeeds.isEmpty()) {
comboToFeeds << 0
<< FEED_DIRECT
<< (FEED_DIRECT | FEED_MENTIONS)
<< (FEED_DIRECT | FEED_MENTIONS | FEED_INBOX)
<< (FEED_DIRECT | FEED_MENTIONS | FEED_INBOX | FEED_MEANWHILE);
}
if (backwards) {
int ret = comboToFeeds.indexOf(ci);
return ret == -1 ? 0 : ret;
}
return ci < comboToFeeds.size() ? comboToFeeds[ci] : 0;
}
//------------------------------------------------------------------------------
void PumpaSettingsDialog::updateUI() {
QString accountId = siteUrlToAccountId(s->userName(), s->siteUrl());
m_currentAccountLabel->setText(QString(tr("Currently logged in as %1.")).
arg(accountId));
m_updateTimeSpinBox->setValue(s->reloadTime());
m_useIconCheckBox->setChecked(s->useTrayIcon());
m_showCharCountCheckBox->setChecked(s->showCharCount());
m_highlightComboBox->
setCurrentIndex(feedIntToComboIndex(s->highlightFeeds()));
m_popupComboBox->
setCurrentIndex(feedIntToComboIndex(s->popupFeeds()));
m_defaultToComboBox->setCurrentIndex(s->defaultToAddress());
m_defaultCcComboBox->setCurrentIndex(s->defaultCcAddress());
}
//------------------------------------------------------------------------------
void PumpaSettingsDialog::onOKClicked() {
s->reloadTime(m_updateTimeSpinBox->value());
s->useTrayIcon(m_useIconCheckBox->isChecked());
s->showCharCount(m_showCharCountCheckBox->isChecked());
s->highlightFeeds(comboIndexToFeedInt(m_highlightComboBox->currentIndex()));
s->popupFeeds(comboIndexToFeedInt(m_popupComboBox->currentIndex()));
s->defaultToAddress(m_defaultToComboBox->currentIndex());
s->defaultCcAddress(m_defaultCcComboBox->currentIndex());
emit accepted();
}
pumpa-0.9.2/src/collectionwidget.h 0000644 0001750 0001750 00000003253 12653206625 015647 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see m_objects_shown;
};
#endif /* _COLLECTIONWIDGET_H_ */
pumpa-0.9.2/src/qactivitystreams.cpp 0000644 0001750 0001750 00000002276 12653206625 016263 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
//------------------------------------------------------------------------------
void resetActivityStreams() {
QASActor::clearCache();
QASObject::clearCache();
QASActivity::clearCache();
QASObjectList::clearCache();
QASActorList::clearCache();
QASCollection::clearCache();
}
//------------------------------------------------------------------------------
pumpa-0.9.2/src/editprofiledialog.h 0000644 0001750 0001750 00000003177 12653206625 016003 0 ustar mats mats /*
Copyright 2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include
#include
#include
#include "qasactor.h"
#include "texttoolbutton.h"
class EditProfileDialog : public QDialog {
Q_OBJECT
public:
EditProfileDialog(QWidget* parent=0);
void setProfile(QASActor* profile);
signals:
void profileEdited(QASActor*, QString);
private slots:
void onOKClicked();
void updateImage();
void onChangeImage();
private:
QString m_imageFileName;
QLabel* m_imageLabel;
TextToolButton* m_changeImageButton;
QHBoxLayout* m_imageLayout;
QLabel* m_realNameLabel;
QLineEdit* m_realNameEdit;
QLabel* m_hometownLabel;
QLineEdit* m_hometownEdit;
QLabel* m_bioLabel;
QTextEdit* m_bioEdit;
QDialogButtonBox* m_buttonBox;
QVBoxLayout* m_layout;
QASActor* m_profile;
};
#endif /* _EDITPROFILEDIALOG_H_ */
pumpa-0.9.2/src/actorwidget.cpp 0000644 0001750 0001750 00000011762 12653206625 015163 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
//------------------------------------------------------------------------------
ActorWidget::ActorWidget(QASActor* a, QWidget* parent, bool small) :
QToolButton(parent), m_actor(a)
{
#ifdef DEBUG_WIDGETS
qDebug() << "Creating ActorWidget" << (m_actor ? m_actor->id() : "NULL");
#endif
int max_size = small ? 32 : 64;
setStyleSheet("QToolButton::menu-indicator { "
"subcontrol-origin: padding; "
"subcontrol-position: bottom right; "
"}");
setIconSize(QSize(max_size, max_size));
setFocusPolicy(Qt::NoFocus);
setPopupMode(QToolButton::InstantPopup);
setAutoRaise(true);
m_menu = new QMenu(this);
m_menuTitleAction = new QAction(this);
connect(m_menuTitleAction, SIGNAL(triggered()), this, SLOT(onMenuTitle()));
m_followAction = new QAction(this);
connect(m_followAction, SIGNAL(triggered()), this, SLOT(onFollowAuthor()));
m_hideAuthorAction = new QAction(this);
connect(m_hideAuthorAction, SIGNAL(triggered()), this, SLOT(onHideAuthor()));
createMenu();
onImageChanged();
}
//------------------------------------------------------------------------------
ActorWidget::~ActorWidget() {
#ifdef DEBUG_WIDGETS
qDebug() << "Deleting ActorWidget" << m_actor->id();
#endif
}
//------------------------------------------------------------------------------
void ActorWidget::setActor(QASActor* a) {
if (m_actor == a)
return;
m_actor = a;
onImageChanged();
createMenu();
}
//------------------------------------------------------------------------------
void ActorWidget::onImageChanged() {
m_url = m_actor ? m_actor->imageUrl() : "";
updatePixmap();
}
//------------------------------------------------------------------------------
void ActorWidget::updatePixmap() {
FileDownloadManager* fdm = FileDownloadManager::getManager();
if (fdm->hasFile(m_url)) {
setIcon(QIcon(fdm->pixmap(m_url, ":/images/image_broken.png")));
} else {
if (m_url.isEmpty()) {
setIcon(QIcon(":/images/default.png"));
} else {
setIcon(QIcon(":/images/image_downloading.png"));
FileDownloader* fd = fdm->download(m_url);
connect(fd, SIGNAL(fileReady()), this, SLOT(updatePixmap()),
Qt::UniqueConnection);
}
}
}
//------------------------------------------------------------------------------
void ActorWidget::createMenu() {
if (!m_actor) {
setMenu(NULL);
return;
}
bool isYou = m_actor->isYou();
m_menuTitleAction->setText(m_actor->displayNameOrWebFinger());
m_menu->clear();
m_menu->addAction(m_menuTitleAction);
m_menu->addSeparator();
if (!isYou)
m_menu->addAction(m_followAction);
m_menu->addAction(m_hideAuthorAction);
updateMenu();
setMenu(m_menu);
}
//------------------------------------------------------------------------------
void ActorWidget::updateMenu() {
if (!m_actor)
return;
m_followAction->setText(m_actor->followed() ? tr("stop following") :
tr("follow"));
m_hideAuthorAction->setText(m_actor->isHidden() ?
tr("stop minimising posts") :
tr("auto-minimise posts"));
}
//------------------------------------------------------------------------------
void ActorWidget::onFollowAuthor() {
bool doFollow = !m_actor->followed();
if (!doFollow) {
QString msg = QString(tr("Are you sure you want to stop following %1?")).
arg(m_actor->displayNameOrWebFinger());
int ret = QMessageBox::warning(this, CLIENT_FANCY_NAME, msg,
QMessageBox::Cancel | QMessageBox::Yes,
QMessageBox::Cancel);
if (ret != QMessageBox::Yes)
return;
}
updateMenu();
if (!m_actor->isYou())
emit follow(m_actor->id(), doFollow);
}
//------------------------------------------------------------------------------
void ActorWidget::onHideAuthor() {
bool doHide = !m_actor->isHidden();
m_actor->setHidden(doHide);
updateMenu();
if (doHide)
emit lessClicked();
else
emit moreClicked();
}
//------------------------------------------------------------------------------
void ActorWidget::onMenuTitle() {
if (m_actor && !m_actor->url().isEmpty())
QDesktopServices::openUrl(m_actor->url());
}
pumpa-0.9.2/src/shortobjectwidget.cpp 0000644 0001750 0001750 00000007330 12653206625 016375 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
ShortObjectWidget::ShortObjectWidget(QASObject* obj, QWidget* parent) :
QFrame(parent),
m_object(NULL),
m_actor(NULL)
{
#ifdef DEBUG_WIDGETS
qDebug() << "Creating ShortObjectWidget";
#endif
m_textLabel = new RichTextLabel(this, true);
m_actorWidget = new ActorWidget(NULL, this, true);
connect(m_actorWidget, SIGNAL(follow(QString, bool)),
this, SIGNAL(follow(QString, bool)));
connect(m_actorWidget, SIGNAL(moreClicked()), this, SIGNAL(moreClicked()));
m_moreButton = new TextToolButton("+", this);
connect(m_moreButton, SIGNAL(clicked()), this, SIGNAL(moreClicked()));
QHBoxLayout* acrossLayout = new QHBoxLayout;
// acrossLayout->setSpacing(10);
acrossLayout->setContentsMargins(0, 0, 0, 0);
acrossLayout->addWidget(m_actorWidget, 0, Qt::AlignVCenter);
acrossLayout->addWidget(m_textLabel, 0, Qt::AlignVCenter);
acrossLayout->addWidget(m_moreButton, 0, Qt::AlignVCenter);
changeObject(obj);
setLayout(acrossLayout);
}
//------------------------------------------------------------------------------
ShortObjectWidget::~ShortObjectWidget() {
#ifdef DEBUG_WIDGETS
qDebug() << "Deleting ShortObjectWidget" << m_object->id();
#endif
}
//------------------------------------------------------------------------------
void ShortObjectWidget::changeObject(QASAbstractObject* obj) {
if (m_object != NULL)
disconnect(m_object, SIGNAL(changed()), this, SLOT(onChanged()));
m_object = qobject_cast(obj);
if (!m_object)
return;
connect(m_object, SIGNAL(changed()), this, SLOT(onChanged()));
if (m_actor != NULL)
disconnect(m_actor, SIGNAL(changed()),
m_actorWidget, SLOT(updateMenu()));
QASActor* m_actor = m_object->asActor();
if (!m_actor) {
m_actor = m_object->author();
if (m_actor)
connect(m_actor, SIGNAL(changed()),
m_actorWidget, SLOT(updateMenu()));
}
m_actorWidget->setActor(m_actor);
static QSet expandableTypes;
if (expandableTypes.isEmpty())
expandableTypes << "person" << "note" << "comment" << "image" << "video"
<< "audio";
m_moreButton->setVisible(expandableTypes.contains(m_object->type())
&& !m_object->isDeleted());
updateText();
}
//------------------------------------------------------------------------------
void ShortObjectWidget::updateText() {
if (!m_object)
return;
QString content = m_object->excerpt();
QString text;
QASActor* author = m_object->author();
if (author && !author->displayName().isEmpty())
text = author->displayName();
if (!content.isEmpty())
text += (text.isEmpty() ? "" : ": ") + content;
m_textLabel->setText(text);
}
//------------------------------------------------------------------------------
void ShortObjectWidget::onChanged() {
updateText();
m_actorWidget->updateMenu();
}
//------------------------------------------------------------------------------
pumpa-0.9.2/src/qasactivity.h 0000644 0001750 0001750 00000004727 12653206625 014660 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see s_activities;
};
#endif /* _QASACTIVITY_H_ */
pumpa-0.9.2/src/objectwidgetwithsignals.cpp 0000644 0001750 0001750 00000006472 12653206625 017600 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
ObjectWidgetWithSignals::ObjectWidgetWithSignals(QWidget* parent) :
QFrame(parent) {}
//------------------------------------------------------------------------------
void ObjectWidgetWithSignals::connectSignals(ObjectWidgetWithSignals* ow,
QWidget* w)
{
connect(ow, SIGNAL(linkHovered(const QString&)),
w, SIGNAL(linkHovered(const QString&)));
connect(ow, SIGNAL(like(QASObject*)),
w, SIGNAL(like(QASObject*)));
connect(ow, SIGNAL(share(QASObject*)),
w, SIGNAL(share(QASObject*)));
connect(ow, SIGNAL(newReply(QASObject*, QASObjectList*, QASObjectList*)),
w, SIGNAL(newReply(QASObject*, QASObjectList*, QASObjectList*)));
connect(ow, SIGNAL(follow(QString, bool)),
w, SIGNAL(follow(QString, bool)));
connect(ow, SIGNAL(deleteObject(QASObject*)),
w, SIGNAL(deleteObject(QASObject*)));
connect(ow, SIGNAL(editObject(QASObject*)),
w, SIGNAL(editObject(QASObject*)));
connect(ow, SIGNAL(request(QString, int)),
w, SIGNAL(request(QString, int)));
}
//------------------------------------------------------------------------------
void ObjectWidgetWithSignals::disconnectSignals(ObjectWidgetWithSignals* ow,
QWidget* w)
{
disconnect(ow, SIGNAL(linkHovered(const QString&)),
w, SIGNAL(linkHovered(const QString&)));
disconnect(ow, SIGNAL(like(QASObject*)),
w, SIGNAL(like(QASObject*)));
disconnect(ow, SIGNAL(share(QASObject*)),
w, SIGNAL(share(QASObject*)));
disconnect(ow, SIGNAL(newReply(QASObject*, QASObjectList*, QASObjectList*)),
w, SIGNAL(newReply(QASObject*, QASObjectList*, QASObjectList*)));
disconnect(ow, SIGNAL(follow(QString, bool)),
w, SIGNAL(follow(QString, bool)));
disconnect(ow, SIGNAL(deleteObject(QASObject*)),
w, SIGNAL(deleteObject(QASObject*)));
disconnect(ow, SIGNAL(editObject(QASObject*)),
w, SIGNAL(editObject(QASObject*)));
disconnect(ow, SIGNAL(request(QString, int)),
w, SIGNAL(request(QString, int)));
}
//------------------------------------------------------------------------------
void ObjectWidgetWithSignals::refreshObject(QASAbstractObject* obj) {
if (!obj)
return;
QDateTime now = QDateTime::currentDateTime();
QDateTime lr = obj->lastRefreshed();
if (lr.isNull() || lr.secsTo(now) > 10) {
obj->lastRefreshed(now);
emit request(obj->apiLink(), obj->asType());
}
}
pumpa-0.9.2/src/filedownloader.h 0000644 0001750 0001750 00000005146 12653206625 015311 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include "QtKOAuth"
//------------------------------------------------------------------------------
class FileDownloader; // forward declaration
class FileDownloadManager : public QObject {
Q_OBJECT
FileDownloadManager(QObject*);
public:
static FileDownloadManager* getManager(QObject* = 0);
bool hasFile(QString url);
QString fileName(QString url);
QPixmap pixmap(QString url, QString brokenImage = "");
QMovie* movie(QString url);
bool supportsAnimation(QString url);
FileDownloader* download(QString url);
void dumpStats();
private slots:
void onSslErrors(QNetworkReply*, QList);
void onAuthorizedRequestReady(QByteArray response, int id);
void onFileReady(QString = "");
private:
void executeAuthorizedRequest(KQOAuthRequest*, FileDownloader*);
QString urlToPath(QString url);
QNetworkAccessManager* m_nam;
KQOAuthManager* m_oam;
QMap m_inProgress;
QMap m_urlMap;
QString m_cacheDir;
int m_nextRequestId;
typedef QPair requestData_t;
QMap m_requestMap;
static FileDownloadManager* s_instance;
friend class FileDownloader;
};
//------------------------------------------------------------------------------
class FileDownloader : public QObject {
Q_OBJECT
public:
FileDownloader(QString url, FileDownloadManager* fdm);
QString url() const { return m_url; }
signals:
void networkError(QString);
void fileReady();
private slots:
void replyFinished();
private:
void requestReady(QByteArray response, KQOAuthRequest* oar);
static void resizeImage(QPixmap pix, QString fn);
QString m_url;
KQOAuthRequest* m_oar;
int m_redirs;
FileDownloadManager* m_fdm;
friend class FileDownloadManager;
};
#endif
pumpa-0.9.2/src/qaspell.cpp 0000644 0001750 0001750 00000006075 12653206625 014311 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see (word.utf16()), -1);
return correct;
}
//------------------------------------------------------------------------------
QStringList QASpell::suggestions(const QString& word) const {
QStringList list;
if (!checksOK())
return list;
const AspellWordList* wl =
aspell_speller_suggest(spell_checker,
reinterpret_cast(word.utf16()), -1);
AspellStringEnumeration* w = aspell_word_list_elements(wl);
const char* cw;
while ((cw = aspell_string_enumeration_next(w)) != NULL) {
list << QString::fromUtf16(reinterpret_cast(cw));
}
delete_aspell_string_enumeration(w);
return list;
}
#endif // USE_ASPELL
pumpa-0.9.2/src/fullobjectwidget.h 0000644 0001750 0001750 00000007506 12653206625 015652 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include
#include
#include "objectwidgetwithsignals.h"
#include "qactivitystreams.h"
#include "texttoolbutton.h"
#include "richtextlabel.h"
#include "actorwidget.h"
#include "imagelabel.h"
//------------------------------------------------------------------------------
class FullObjectWidget : public ObjectWidgetWithSignals {
Q_OBJECT
public:
FullObjectWidget(QASObject* obj, QWidget* parent = 0, bool childWidget=false);
virtual ~FullObjectWidget();
virtual void changeObject(QASAbstractObject* obj);
QASObject* object() const { return m_object; }
virtual QASAbstractObject* asObject() const { return object(); }
virtual void refreshTimeLabels();
void disableLessButton();
void updateMenu() {
if (m_actorWidget)
m_actorWidget->updateMenu();
updateFollowAuthorButton();
}
void setActivity(QASActivity* a) { m_activity = a; }
signals:
void lessClicked();
private slots:
void onChanged();
void updateImage();
void imageClicked();
void onHasMoreClicked();
void favourite();
void onRepeatClicked();
void reply();
void onFollow();
void onFollowAuthor();
void updateFollowAuthorButton(bool wait = false);
void updateDeleteEditButtons();
void onDeleteClicked();
void onEditClicked();
#ifdef DEBUG_BUTTONS
void onLoadRepliesClicked();
void onDumpJsonClicked();
#endif
private:
bool isCommentable() const;
QString typeName() const;
QString textExcerpt() const;
bool hasValidIrtObject();
void setText(QString text);
void updateInfoText();
void updateLikes();
void updateShares();
void updateTitle();
QString recipientsToString(QASObjectList* rec);
QString processText(QString old_text, bool getImages=false);
void addHasMoreButton(QASObjectList* ol, int li);
void updateFavourButton(bool wait = false);
void updateShareButton(bool wait = false);
void updateFollowButton(bool wait = false);
bool isFollowable(QASObject* obj) const;
void addObjectList(QASObjectList* ol);
void clearObjectList();
QString m_imageUrl;
QString m_localFile;
RichTextLabel* m_textLabel;
ImageLabel* m_imageLabel;
ActorWidget* m_actorWidget;
RichTextLabel* m_streamLabel;
RichTextLabel* m_infoLabel;
RichTextLabel* m_likesLabel;
RichTextLabel* m_sharesLabel;
QLabel* m_titleLabel;
QPushButton* m_hasMoreButton;
TextToolButton* m_favourButton;
TextToolButton* m_shareButton;
TextToolButton* m_commentButton;
TextToolButton* m_followButton;
TextToolButton* m_followAuthorButton;
TextToolButton* m_deleteButton;
TextToolButton* m_editButton;
TextToolButton* m_lessButton;
#ifdef DEBUG_BUTTONS
TextToolButton* m_loadRepliesButton;
TextToolButton* m_dumpJsonButton;
#endif
QVBoxLayout* m_contentLayout;
QHBoxLayout* m_buttonLayout;
QVBoxLayout* m_commentsLayout;
QASObject* m_object;
QASActor* m_actor;
QASActor* m_author;
QList m_repliesList;
QSet m_repliesMap;
QASActivity* m_activity;
bool m_childWidget;
bool m_commentable;
};
#endif /* _FULLOBJECTWIDGET_H_ */
pumpa-0.9.2/src/objectwidgetwithsignals.h 0000644 0001750 0001750 00000003253 12653206625 017237 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include "qactivitystreams.h"
//------------------------------------------------------------------------------
class ObjectWidgetWithSignals : public QFrame {
Q_OBJECT
public:
ObjectWidgetWithSignals(QWidget* parent = 0);
virtual void changeObject(QASAbstractObject* obj) = 0;
virtual QASAbstractObject* asObject() const = 0;
static void connectSignals(ObjectWidgetWithSignals* ow, QWidget* w);
static void disconnectSignals(ObjectWidgetWithSignals* ow, QWidget* w);
virtual void refreshTimeLabels() = 0;
signals:
void linkHovered(const QString&);
void like(QASObject*);
void share(QASObject*);
void newReply(QASObject*, QASObjectList*, QASObjectList*);
void follow(QString, bool);
void deleteObject(QASObject*);
void editObject(QASObject*);
void request(QString, int);
protected:
void refreshObject(QASAbstractObject* obj);
};
#endif /* _OBJECTWIDGETWITHSIGNALS_H_ */
pumpa-0.9.2/src/messagerecipients.cpp 0000644 0001750 0001750 00000005610 12653206625 016354 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
MessageRecipients::MessageRecipients(QWidget* parent) : QWidget(parent) {
m_layout = new QGridLayout;
m_layout->setColumnStretch(0, 10);
m_layout->setColumnStretch(1, 1);
m_layout->setContentsMargins(0, 0, 0, 0);
m_buttonMapper = new QSignalMapper(this);
connect(m_buttonMapper, SIGNAL(mapped(QObject*)),
this, SLOT(onRemoveClicked(QObject*)));
setLayout(m_layout);
}
//------------------------------------------------------------------------------
void MessageRecipients::addRecipient(QASObject* obj) {
if (m_widgets.contains(obj))
return;
QString text("" + obj->displayName() + "");
QASActor* actor = obj->asActor();
if (actor)
text += " (" + actor->webFinger() + ")";
QLabel* label = new QLabel(text);
QToolButton* button = new QToolButton;
button->setText(tr("-"));
connect(button, SIGNAL(clicked()), m_buttonMapper, SLOT(map()));
m_buttonMapper->setMapping(button, obj);
m_list.append(obj);
int row = m_layout->rowCount();
m_layout->addWidget(label, row, 0);
m_layout->addWidget(button, row, 1);
m_widgets.insert(obj, qMakePair(label, button));
}
//------------------------------------------------------------------------------
void MessageRecipients::removeRecipient(QASObject* obj) {
QPair widgets = m_widgets[obj];
m_layout->removeWidget(widgets.first);
m_layout->removeWidget(widgets.second);
widgets.first->deleteLater();
widgets.second->deleteLater();
m_list.removeAll(obj);
m_widgets.remove(obj);
}
//------------------------------------------------------------------------------
void MessageRecipients::clear() {
QLayoutItem* item;
while ((item = m_layout->takeAt(0)) != 0) {
if (dynamic_cast(item)) {
QWidget* w = item->widget();
delete w;
}
delete item;
}
m_list.clear();
m_widgets.clear();
}
//------------------------------------------------------------------------------
void MessageRecipients::onRemoveClicked(QObject* qObj) {
QASObject* obj = qobject_cast(qObj);
if (!obj)
return;
removeRecipient(obj);
}
pumpa-0.9.2/src/messagewindow.cpp 0000644 0001750 0001750 00000041257 12653206625 015525 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
//------------------------------------------------------------------------------
const int max_picture_size = 160;
//------------------------------------------------------------------------------
PictureLabel::PictureLabel(QWidget* parent) : QLabel(parent) {}
//------------------------------------------------------------------------------
void PictureLabel::setOriginalPixmap(QPixmap p) {
m_originalPixmap = p;
setPixmap(p);
}
//------------------------------------------------------------------------------
void PictureLabel::resizeEvent(QResizeEvent* event) {
if (m_originalPixmap.isNull())
return;
QSize size = event->size();
setPixmap(m_originalPixmap.scaled(size, Qt::KeepAspectRatio));
}
//------------------------------------------------------------------------------
MessageWindow::MessageWindow(PumpaSettings* s, const RecipientList* rl,
QWidget* parent) :
QDialog(parent),
m_addressLayout(NULL),
m_editing(false),
m_isReply(false),
m_obj(NULL),
m_s(s),
m_rl(rl)
{
setMinimumSize(QSize(400,400));
setWindowTitle(CLIENT_FANCY_NAME);
m_infoLabel = new QLabel(this);
m_markdownCheckBox = new QCheckBox(tr("Use Markdown"), this);
connect(m_markdownCheckBox, SIGNAL(stateChanged(int)),
this, SLOT(onMarkdownChecked(int)));
m_markupLabel = new QLabel(this);
m_markupLabel->setText(QString("" + tr("[help]") + "").
arg(MARKUP_DOC_URL));
m_markupLabel->setOpenExternalLinks(true);
m_markupLabel->setTextInteractionFlags(Qt::TextSelectableByMouse |
Qt::LinksAccessibleByMouse);
m_infoLayout = new QHBoxLayout;
m_infoLayout->addWidget(m_infoLabel);
m_infoLayout->addStretch();
m_infoLayout->addWidget(m_markdownCheckBox);
m_infoLayout->addWidget(m_markupLabel);
m_toRecipients = new MessageRecipients(this);
m_ccRecipients = new MessageRecipients(this);
m_toLabel = new QLabel(tr("To:"), this);
m_ccLabel = new QLabel(tr("Cc:"), this);
m_addressLayout = new QFormLayout;
m_addressLayout->addRow(m_toLabel, m_toRecipients);
m_addressLayout->addRow(m_ccLabel, m_ccRecipients);
m_addressLayout->setContentsMargins(0, 0, 0, 0);
m_addPictureButton = new TextToolButton(this);
connect(m_addPictureButton, SIGNAL(clicked()), this, SLOT(onAddPicture()));
m_removePictureButton = new TextToolButton(tr("&Remove picture"), this);
connect(m_removePictureButton, SIGNAL(clicked()),
this, SLOT(onRemovePicture()));
m_addToButton = new TextToolButton(tr("+ &To"), this);
connect(m_addToButton, SIGNAL(clicked()), this, SLOT(onAddTo()));
m_addCcButton = new TextToolButton(tr("+ &Cc"), this);
connect(m_addCcButton, SIGNAL(clicked()), this, SLOT(onAddCc()));
m_pictureButtonLayout = new QHBoxLayout;
m_pictureButtonLayout->addWidget(m_addPictureButton, 0, Qt::AlignTop);
m_pictureButtonLayout->addWidget(m_removePictureButton, 0, Qt::AlignTop);
m_pictureButtonLayout->addStretch();
m_pictureButtonLayout->addWidget(m_addToButton, 0, Qt::AlignTop);
m_pictureButtonLayout->addWidget(m_addCcButton, 0, Qt::AlignTop);
m_pictureLabel = new PictureLabel(this);
// m_pictureLabel->setScaledContents(true);
m_pictureLabel->setMaximumSize(max_picture_size, max_picture_size);
m_pictureLabel->setFocusPolicy(Qt::NoFocus);
m_pictureLabel->setFrameStyle(QFrame::Panel | QFrame::Sunken);
m_title = new QLineEdit(this);
#if QT_VERSION >= 0x040700
m_title->setPlaceholderText(tr("Title (optional)"));
#endif
connect(m_title, SIGNAL(textChanged(const QString&)),
this, SLOT(updatePreview()));
m_textEdit = new MessageEdit(m_s, this);
connect(m_textEdit, SIGNAL(ready()), this, SLOT(accept()));
connect(m_textEdit, SIGNAL(textChanged()), this, SLOT(updatePreview()));
connect(m_textEdit, SIGNAL(addRecipient(QASActor*)),
this, SLOT(onAddRecipient(QASActor*)));
m_previewLabel = new RichTextLabel;
m_previewLabel->setSizePolicy(QSizePolicy::Ignored,
QSizePolicy::Maximum);
m_previewArea = new QScrollArea(this);
m_previewArea->setWidget(m_previewLabel);
m_previewArea->setWidgetResizable(true);
m_charCountLabel = new QLabel(this);
QWidget* qw = new QWidget(this);
QVBoxLayout* qwLayout = new QVBoxLayout;
qwLayout->addWidget(m_textEdit);
qwLayout->addWidget(m_charCountLabel);
qwLayout->setMargin(0);
qw->setLayout(qwLayout);
m_splitter = new QSplitter(Qt::Vertical, this);
m_splitter->addWidget(qw);
m_splitter->addWidget(m_previewArea);
m_splitter->setChildrenCollapsible(false);
m_layout = new QVBoxLayout;
m_layout->addLayout(m_infoLayout);
m_layout->addLayout(m_addressLayout);
m_layout->addLayout(m_pictureButtonLayout);
m_layout->addWidget(m_pictureLabel, 0, Qt::AlignHCenter);
m_layout->addWidget(m_title);
m_layout->addWidget(m_splitter);
m_cancelButton = new QPushButton(tr("Ca&ncel"));
connect(m_cancelButton, SIGNAL(clicked()), this, SLOT(reject()));
m_previewButton = new QPushButton(tr("&Preview"));
connect(m_previewButton, SIGNAL(clicked()), this, SLOT(togglePreview()));
m_sendButton = new QPushButton(tr("&Send message"));
connect(m_sendButton, SIGNAL(clicked()), this, SLOT(accept()));
m_sendButton->setDefault(true);
m_buttonLayout = new QHBoxLayout;
m_buttonLayout->addWidget(m_cancelButton);
m_buttonLayout->addWidget(m_previewButton);
m_buttonLayout->addWidget(m_sendButton);
m_layout->addLayout(m_buttonLayout);
setLayout(m_layout);
m_textEdit->setFocus(Qt::OtherFocusReason);
QTextCursor cursor = m_textEdit->textCursor();
cursor.movePosition(QTextCursor::End);
m_textEdit->setTextCursor(cursor);
}
//------------------------------------------------------------------------------
void MessageWindow::onMarkdownChecked(int state) {
if (!m_editing) {
if (state == Qt::Unchecked) {
m_s->useMarkdown(false);
} else {
m_s->useMarkdown(true);
}
}
updatePreview();
}
//------------------------------------------------------------------------------
void MessageWindow::setCompletions(const MessageEdit::completion_t*
completions) {
if (m_textEdit)
m_textEdit->setCompletions(completions);
}
//------------------------------------------------------------------------------
void MessageWindow::addToRecipientList(QString name, QASObject* obj) {
m_recipientList.append(name);
if (!m_recipientSelection.contains(name))
m_recipientSelection.insert(name, obj);
}
//------------------------------------------------------------------------------
void MessageWindow::addRecipientWindow(MessageRecipients* mr, QString title) {
QInputDialog* dialog = new QInputDialog(this);
// dialog->setOption(QInputDialog::UseListViewForComboBoxItems);
dialog->setComboBoxItems(m_recipientList);
dialog->setComboBoxEditable(true);
dialog->setLabelText(title);
dialog->setInputMode(QInputDialog::TextInput);
dialog->setWindowTitle(CLIENT_FANCY_NAME);
dialog->exec();
if (dialog->result() == QDialog::Accepted) {
QString text = dialog->textValue();
if (m_recipientSelection.contains(text))
mr->addRecipient(m_recipientSelection[text]);
}
}
//------------------------------------------------------------------------------
void MessageWindow::onAddTo() {
addRecipientWindow(m_toRecipients, tr("Select recipient (To)"));
}
//------------------------------------------------------------------------------
void MessageWindow::onAddCc() {
addRecipientWindow(m_ccRecipients, tr("Select recipient (Cc)"));
}
//------------------------------------------------------------------------------
void MessageWindow::onAddRecipient(QASActor* actor) {
m_toRecipients->addRecipient(actor);
}
//------------------------------------------------------------------------------
void MessageWindow::initWindow(QString title, QString buttonText,
bool showRecipients) {
setWindowTitle(QString(CLIENT_FANCY_NAME) + " - " + title);
m_infoLabel->setText(title);
m_sendButton->setText(buttonText);
m_markdownCheckBox->setChecked(m_s->useMarkdown() || m_editing);
m_previewArea->setVisible(m_s->showPreview());
m_toRecipients->setVisible(showRecipients);
m_ccRecipients->setVisible(showRecipients);
m_toLabel->setVisible(showRecipients);
m_ccLabel->setVisible(showRecipients);
m_addToButton->setVisible(showRecipients);
m_addCcButton->setVisible(showRecipients);
m_charCountLabel->setVisible(m_s->showCharCount());
updatePreview(true);
updateAddPicture();
}
//------------------------------------------------------------------------------
void MessageWindow::newMessage(QASObject* obj, QASObjectList* to,
QASObjectList* cc) {
if (m_editing)
clear();
m_editing = false;
QASObject* origObj = obj;
if (obj && !m_s->commentOnComments() && obj->inReplyTo())
obj = obj->inReplyTo();
m_isReply = (obj != NULL);
m_obj = obj;
if (m_isReply)
m_title->clear();
QString title = m_isReply ? tr("Post a reply") : tr("Post a note");
QString buttonText = m_isReply ? tr("&Send comment") : tr("&Send post");
initWindow(title, buttonText, true);
m_recipientList.clear();
for (int i=0; isize(); ++i) {
QASObject* obj = m_rl->at(i);
addToRecipientList(obj->displayName() + " (list)", obj);
}
m_markdownCheckBox->setEnabled(true);
const MessageEdit::completion_t* completions = m_textEdit->getCompletions();
MessageEdit::completion_t::const_iterator it = completions->constBegin();
for (; it != completions->constEnd(); ++it)
addToRecipientList(it.key(), it.value());
if (!m_isReply) {
// A new post, use default recipients
setDefaultRecipients(m_toRecipients, m_s->defaultToAddress());
setDefaultRecipients(m_ccRecipients, m_s->defaultCcAddress());
} else {
// For a reply, copy recipients from parent
copyRecipients(m_toRecipients, to);
copyRecipients(m_ccRecipients, cc);
// add original post author to recipients
if (obj->author() && !obj->author()->isYou())
m_toRecipients->addRecipient(obj->author());
// if this is a reply to a comment add comment author to
// recipients as well
if (origObj != obj && origObj->author() && !origObj->author()->isYou())
m_toRecipients->addRecipient(origObj->author());
}
}
//------------------------------------------------------------------------------
void MessageWindow::editMessage(QASObject* obj) {
m_editing = true;
m_obj = obj;
QString type = obj->type();
m_isReply = type == "comment";
QString title = tr("Edit object");
// we do this for the sake of easier translation
if (type == "note")
title = tr("Edit post");
else if (type == "comment")
title = tr("Edit comment");
else if (type == "image")
title = tr("Edit image post");
QString buttonText = tr("&Update object");
// we do this for the sake of easier translation
if (type == "note")
buttonText = tr("&Update post");
else if (type == "comment")
buttonText = tr("&Update comment");
else if (type == "image")
buttonText = tr("&Update image post");
m_markdownCheckBox->setEnabled(false);
m_textEdit->setPlainText(obj->content());
m_title->setText(obj->displayName());
initWindow(title, buttonText, false);
}
//------------------------------------------------------------------------------
void MessageWindow::copyRecipients(MessageRecipients* mr, QASObjectList* ol) {
mr->clear();
if (ol) {
RecipientList rl = ol->toRecipientList();
for (int i=0; iasActor();
bool isYou = actor && actor->isYou();
if (!isYou && !rl[i]->type().isEmpty())
mr->addRecipient(rl[i]);
}
}
}
//------------------------------------------------------------------------------
void MessageWindow::setDefaultRecipients(MessageRecipients* mr,
int defAddress) {
mr->clear();
if (defAddress == RECIPIENT_PUBLIC)
mr->addRecipient(m_rl->at(0));
if (defAddress == RECIPIENT_FOLLOWERS)
mr->addRecipient(m_rl->at(1));
}
//------------------------------------------------------------------------------
void MessageWindow::clear() {
m_imageFileName = "";
m_textEdit->clear();
m_title->clear();
m_previewLabel->setText("");
}
//------------------------------------------------------------------------------
void MessageWindow::showEvent(QShowEvent*) {
m_textEdit->setFocus(Qt::OtherFocusReason);
m_textEdit->selectAll();
activateWindow();
}
//------------------------------------------------------------------------------
void MessageWindow::accept() {
m_textEdit->hideCompletion();
QString msg = m_textEdit->toPlainText();
RecipientList to = m_toRecipients->recipients();
RecipientList cc = m_ccRecipients->recipients();
QString title = m_title->text();
if (m_editing) {
emit sendEdit(m_obj, msg, title);
} else if (m_isReply) {
emit sendReply(m_obj, msg, to, cc);
} else {
if (m_imageFileName.isEmpty()) {
emit sendMessage(msg, title, to, cc);
} else {
emit sendImage(msg, title, m_imageFileName, to, cc);
}
}
QDialog::accept();
}
//------------------------------------------------------------------------------
void MessageWindow::onAddPicture() {
QString fileName =
QFileDialog::getOpenFileName(this, tr("Select Image"), "",
tr("Image files (*.png *.jpg *.jpeg *.gif)"
";;All files (*.*)"));
if (!fileName.isEmpty()) {
m_imageFileName = fileName;
updateAddPicture();
}
}
//------------------------------------------------------------------------------
void MessageWindow::onRemovePicture() {
m_imageFileName = "";
updateAddPicture();
}
//------------------------------------------------------------------------------
void MessageWindow::updateAddPicture() {
if (m_isReply || m_editing) {
m_addPictureButton->setVisible(false);
m_removePictureButton->setVisible(false);
m_pictureLabel->setVisible(false);
m_title->setVisible(!m_isReply);
m_removePictureButton->setVisible(false);
return;
}
QPixmap p;
if (!m_imageFileName.isEmpty()) {
p.load(m_imageFileName);
if (p.isNull()) {
QMessageBox::critical(this, tr("Sorry!"),
tr("That file didn't appear to be an image."));
m_imageFileName = "";
}
}
m_addPictureButton->setVisible(true);
m_title->setVisible(true);
if (m_imageFileName.isEmpty()) {
m_addPictureButton->setText(tr("&Add picture"));
m_removePictureButton->setVisible(false);
m_pictureLabel->setVisible(false);
} else {
QPixmap scaledPixmap = p.scaled(max_picture_size,
max_picture_size,
Qt::KeepAspectRatio);
m_pictureLabel->setOriginalPixmap(scaledPixmap);
m_addPictureButton->setText(tr("&Change picture"));
m_removePictureButton->setVisible(true);
m_pictureLabel->setVisible(true);
}
}
//------------------------------------------------------------------------------
void MessageWindow::updatePreview(bool force) {
QString previewText = addTextMarkup(m_textEdit->toPlainText(),
m_s->useMarkdown() || m_editing);
if (m_charCountLabel->isVisible() || force) {
QString strippedText = previewText;
strippedText.remove(QRegExp(HTML_TAG_REGEX));
#ifdef DEBUG_MARKUP
qDebug() << "STRIPPEDTEXT" << strippedText;
#endif
QString ccText = QString(tr("Characters: %1")).arg(strippedText.count());
m_charCountLabel->setText(ccText);
}
if (m_previewArea->isVisible() || force) {
QString titleText = processTitle(m_title->text(), true);
if (!titleText.isEmpty())
previewText = "" + titleText + "
" + previewText;
m_previewLabel->setText(previewText);
}
}
//------------------------------------------------------------------------------
void MessageWindow::togglePreview() {
bool visible = !m_previewArea->isVisible();
m_previewArea->setVisible(visible);
m_s->showPreview(visible);
updatePreview();
m_textEdit->setFocus(Qt::OtherFocusReason);
}
pumpa-0.9.2/src/qasobjectlist.cpp 0000644 0001750 0001750 00000007123 12653206625 015512 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
QMap QASObjectList::s_objectLists;
void QASObjectList::clearCache() { deleteMap(s_objectLists); }
//------------------------------------------------------------------------------
QASObjectList::QASObjectList(QString url, QObject* parent) :
QASAbstractObjectList(QAS_OBJECTLIST, url, parent),
m_isReplies(false)
{
#ifdef DEBUG_QAS
qDebug() << "new ObjectList" << m_url;
#endif
}
//------------------------------------------------------------------------------
QASAbstractObject* QASObjectList::getAbstractObject(QVariantMap json,
QObject* parent) {
if (json["objectType"].toString() == "person")
return QASActor::getActor(json, parent);
return QASObject::getObject(json, parent);
}
//------------------------------------------------------------------------------
QASObjectList* QASObjectList::initObjectList(QString url, QObject* parent) {
if (s_objectLists.contains(url))
return s_objectLists[url];
QASObjectList* ol = new QASObjectList(url, parent);
s_objectLists.insert(url, ol);
return ol;
}
//------------------------------------------------------------------------------
QASObjectList* QASObjectList::getObjectList(QVariantMap json, QObject* parent,
int id) {
QString url = json["url"].toString();
// if (url.isEmpty())
// return NULL;
QASObjectList* ol = s_objectLists.contains(url) ? s_objectLists[url] :
new QASObjectList(url, parent);
if (!url.isEmpty())
s_objectLists.insert(url, ol);
ol->update(json, id & QAS_OLDER);
return ol;
}
//------------------------------------------------------------------------------
QASObjectList* QASObjectList::getObjectList(QVariantList json, QObject* parent,
int id) {
QVariantMap jmap;
jmap["totalItems"] = json.size();
jmap["items"] = json;
return getObjectList(jmap, parent, id);
}
//------------------------------------------------------------------------------
void QASObjectList::update(QVariantMap json, bool older, bool) {
// if (m_isReplies && json.contains("items")) {
// m_item_set.clear();
// m_items.clear();
// }
QASAbstractObjectList::update(json, older);
}
//------------------------------------------------------------------------------
RecipientList QASObjectList::toRecipientList() const {
RecipientList rl;
for (size_t i=0; iasActor();
if (actor && actor->isYou())
return true;
}
return false;
}
pumpa-0.9.2/src/pumpasettings.cpp 0000644 0001750 0001750 00000006370 12653206625 015551 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include "pumpasettings.h"
#include "pumpa_defines.h"
#include "util.h"
PumpaSettings* PumpaSettings::s_settings = NULL;
//------------------------------------------------------------------------------
PumpaSettings::PumpaSettings(QString filename, QObject* parent) :
QObject(parent) {
if (filename.isEmpty())
m_s = new QSettings(CLIENT_NAME, CLIENT_NAME, this);
else
m_s = new QSettings(filename, QSettings::IniFormat, this);
m_firstStart = !QFile(m_s->fileName()).exists();
QFile::setPermissions(m_s->fileName(),
QFile::ReadOwner | QFile::WriteOwner);
}
//------------------------------------------------------------------------------
PumpaSettings* PumpaSettings::getSettings(bool create, QString filename,
QObject* parent) {
if (s_settings == NULL && create)
s_settings = new PumpaSettings(filename, parent);
return s_settings;
}
//------------------------------------------------------------------------------
QVariant PumpaSettings::getValue(QString name, QVariant defaultValue,
QString group) const {
m_s->beginGroup(group);
QVariant v = m_s->value(name, defaultValue);
m_s->endGroup();
return v;
}
//------------------------------------------------------------------------------
QString PumpaSettings::siteUrl() const {
return siteUrlFixer(getValue("site_url", "", "Account").toString());
}
//------------------------------------------------------------------------------
int PumpaSettings::reloadTime() const {
int reloadTime = getValue("reload_time", 1, "General").toInt();
if (reloadTime < 1)
reloadTime = 1;
return reloadTime;
}
//------------------------------------------------------------------------------
int PumpaSettings::highlightFeeds() const {
return getValue("highlight_feeds", 0, "General").toInt();
}
//------------------------------------------------------------------------------
int PumpaSettings::popupFeeds() const {
return getValue("popup_feeds", 0, "General").toInt();
}
//------------------------------------------------------------------------------
// Setters
//------------------------------------------------------------------------------
void PumpaSettings::setValue(QString name, QVariant value, QString group) {
m_s->beginGroup(group);
m_s->setValue(name, value);
m_s->endGroup();
}
//------------------------------------------------------------------------------
void PumpaSettings::useTrayIcon(bool b) {
bool old = useTrayIcon();
setValue("use_tray_icon", b);
if (old != b)
emit trayIconChanged();
}
pumpa-0.9.2/src/qaspell.h 0000644 0001750 0001750 00000002650 12653206625 013751 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#ifdef USE_ASPELL
#include
class QASpell : public QObject {
public:
QASpell(QObject* parent=0);
~QASpell();
bool checkWord(const QString& word) const;
QStringList suggestions(const QString& word) const;
static void setLocale(QString locale);
protected:
AspellConfig* spell_config;
AspellSpeller* spell_checker;
bool checksOK() const;
bool ok;
static QString s_locale;
};
#else
// dummy class
class QASpell : public QObject {
public:
QASpell() {}
~QASpell() {}
};
#endif
#endif /* _QASPELL_H_ */
pumpa-0.9.2/src/fancyhighlighter.h 0000644 0001750 0001750 00000002033 12653206625 015622 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include "qaspell.h"
#include "util.h"
class FancyHighlighter : public QSyntaxHighlighter {
public:
FancyHighlighter(QTextDocument* doc, QASpell* checker);
protected:
void highlightBlock(const QString& text);
QASpell* m_checker;
};
#endif /* FANCY_HIGHLIGHTER_H */
pumpa-0.9.2/src/activitywidget.cpp 0000644 0001750 0001750 00000010657 12653206625 015711 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
ActivityWidget::ActivityWidget(QASActivity* a, bool fullObject,
QWidget* parent) :
ObjectWidgetWithSignals(parent),
m_objectWidget(NULL),
m_activity(NULL)
{
#ifdef DEBUG_WIDGETS
qDebug() << "Creating ActivityWidget";
#endif
m_textLabel = new RichTextLabel(this);
connect(m_textLabel, SIGNAL(linkHovered(const QString&)),
this, SIGNAL(linkHovered(const QString&)));
m_objectWidget = new ObjectWidget(NULL, this);
ObjectWidgetWithSignals::connectSignals(m_objectWidget, this);
connect(m_objectWidget, SIGNAL(showContext(QASObject*)),
this, SIGNAL(showContext(QASObject*)));
QVBoxLayout* layout = new QVBoxLayout;
layout->setContentsMargins(0, 0, 0, 0);
layout->addWidget(m_textLabel, 0, Qt::AlignTop);
layout->addWidget(m_objectWidget, 0, Qt::AlignTop);
layout->addWidget(new QLabel("
"));
changeObject(a, fullObject);
setLayout(layout);
}
//------------------------------------------------------------------------------
ActivityWidget::~ActivityWidget() {
#ifdef DEBUG_WIDGETS
qDebug() << "Deleting ActivityWidget" << m_activity->id();
#endif
}
//------------------------------------------------------------------------------
void ActivityWidget::changeObject(QASAbstractObject* aObj, bool fullObject) {
m_activity = qobject_cast(aObj);
if (!m_activity)
return;
const QString verb = m_activity->verb();
QASObject* obj = m_activity->object();
QString objType = obj->type();
m_objectWidget->changeObject(obj, fullObject);
m_objectWidget->setActivity(m_activity);
bool objectVisible = !obj->content().isEmpty() ||
!obj->displayName().isEmpty()
|| (objType == "image" && !obj->imageUrl().isEmpty())
|| obj->isDeleted();
m_objectWidget->setVisible(objectVisible);
updateText();
}
//------------------------------------------------------------------------------
void ActivityWidget::onObjectChanged() {
updateText();
}
//------------------------------------------------------------------------------
void ActivityWidget::refreshTimeLabels() {
if (m_objectWidget)
m_objectWidget->refreshTimeLabels();
}
//------------------------------------------------------------------------------
void ActivityWidget::updateText() {
QString verb = m_activity->verb();
QString text = m_activity->content();
QString objType = m_activity->object()->type();
QString generatorName = m_activity->generatorName();
if (!generatorName.isEmpty() && (verb != "share"))
text += QString(tr(" via %1")).arg(generatorName);
if (verb == "share")
text = QString::fromUtf8("\342\231\273") + " " + text;
if (verb == "post") {
QString toStr = recipientsToString(m_activity->to());
QString ccStr = recipientsToString(m_activity->cc());
if (!toStr.isEmpty())
text += " " + tr("To:") +" " + toStr;
if (!ccStr.isEmpty())
text += " " + tr("CC:") + " " + ccStr;
}
m_textLabel->setText(text);
}
//------------------------------------------------------------------------------
QString ActivityWidget::recipientsToString(QASObjectList* rec) {
if (!rec)
return "";
QStringList ret;
for (size_t i=0; isize(); ++i) {
QASObject* r = rec->at(i);
if (r->type() == "collection" && r->id() == PUBLIC_RECIPIENT_ID) {
ret << tr("Public");
} else {
QString name = r->displayName();
QString url = r->url();
if (name.isEmpty())
continue;
if (url.isEmpty())
ret << name;
else
ret << QString("%2").arg(url).arg(name);
}
}
return ret.join(", ");
}
pumpa-0.9.2/src/texttoolbutton.cpp 0000644 0001750 0001750 00000002274 12653206625 015763 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include
#include "qasactor.h"
//------------------------------------------------------------------------------
class MessageRecipients : public QWidget {
Q_OBJECT
public:
MessageRecipients(QWidget* parent=0);
void clear();
void addRecipient(QASObject* obj);
void removeRecipient(QASObject* obj);
RecipientList recipients() const { return m_list; }
private slots:
void onRemoveClicked(QObject*);
private:
RecipientList m_list;
QGridLayout* m_layout;
QSignalMapper* m_buttonMapper;
QMap > m_widgets;
};
#endif
pumpa-0.9.2/src/qasactor.h 0000644 0001750 0001750 00000004542 12653206625 014127 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
//------------------------------------------------------------------------------
class QASActor : public QASObject {
Q_OBJECT
private:
QASActor(QString id, QObject* parent);
public:
static void clearCache();
static QASActor* getActor(QVariantMap json, QObject* parent);
virtual void update(QVariantMap json);
QString webFinger() const { return m_webFinger; }
QString displayNameOrWebFinger() const;
QString preferredUsername() const { return m_preferredUsername; }
QString displayNameOrYou() const { return isYou() ? "You" : displayName(); }
void setDisplayName(QString s) { m_displayName = s; }
bool isYou() const { return m_isYou; }
void setYou();
bool followed() const;
void setFollowed(bool b);
bool followedKnown() const { return s_followed_known || m_followed_set; }
static void setFollowedKnown();
void followedIsKnown();
QString summary() const { return m_summary; }
void setSummary(QString s) { m_summary = s; }
QString location() const { return m_location; }
void setLocation(QString l) { m_location = l; }
bool isHidden() const;
void setHidden(bool b);
static void setHiddenAuthors(QStringList sl);
static QStringList getHiddenAuthors() { return s_hiddenAuthors.toList(); }
private:
static bool s_followed_known;
bool m_followed;
bool m_followed_json;
bool m_followed_set;
bool m_isYou;
QString m_summary;
QString m_location;
QString m_webFinger;
QString m_preferredUsername;
static QMap s_actors;
static QSet s_hiddenAuthors;
};
#endif /* _QASACTOR_H_ */
pumpa-0.9.2/src/qasactivity.cpp 0000644 0001750 0001750 00000007104 12653206625 015203 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
//------------------------------------------------------------------------------
QMap QASActivity::s_activities;
void QASActivity::clearCache() { deleteMap(s_activities); }
//------------------------------------------------------------------------------
QASActivity::QASActivity(QString id, QObject* parent) :
QASAbstractObject(QAS_ACTIVITY, parent),
m_id(id),
m_object(NULL),
m_actor(NULL),
m_to(NULL),
m_cc(NULL)
{
#ifdef DEBUG_QAS
qDebug() << "new Activity" << m_id;
#endif
}
//------------------------------------------------------------------------------
void QASActivity::update(QVariantMap json) {
#ifdef DEBUG_QAS
qDebug() << "updating Activity" << m_id;
#endif
bool ch = false;
updateVar(json, m_verb, "verb", ch);
updateVar(json, m_url, "url", ch);
updateVar(json, m_content, "content", ch);
if (json.contains("actor")) {
m_actor = QASActor::getActor(json["actor"].toMap(), parent());
//connectSignals(m_actor);
}
if (json.contains("object")) {
m_object = QASObject::getObject(json["object"].toMap(), parent(),
isLikeVerb(m_verb) || isShareVerb(m_verb));
//connectSignals(m_object);
if (!m_object->author())
m_object->setAuthor(m_actor);
m_object->setPostingActivity(this);
}
updateVar(json, m_published, "published", ch);
updateVar(json, m_updated, "updated", ch);
updateVar(json, m_generatorName, "generator", "displayName", ch);
if (m_object && m_object->inReplyTo())
m_object->inReplyTo()->addReply(m_object);
if (isLikeVerb(m_verb) && m_object && m_actor)
m_object->addLike(m_actor, !m_verb.startsWith("un"));
if (m_verb == "share" && m_object && m_actor)
m_object->addShare(m_actor);
if (json.contains("to"))
m_to = QASObjectList::getObjectList(json["to"].toList(), parent());
if (json.contains("cc"))
m_cc = QASObjectList::getObjectList(json["cc"].toList(), parent());
if (ch)
emit changed();
}
//------------------------------------------------------------------------------
QASActivity* QASActivity::getActivity(QVariantMap json, QObject* parent) {
QString id = json["id"].toString();
if (id.isEmpty())
return NULL;
QASActivity* act = s_activities.contains(id) ? s_activities[id] :
new QASActivity(id, parent);
s_activities.insert(id, act);
act->update(json);
return act;
}
//------------------------------------------------------------------------------
bool QASActivity::hasTo() const {
return m_to && m_to->size();
}
//------------------------------------------------------------------------------
bool QASActivity::hasCc() const {
return m_cc && m_cc->size();
}
//------------------------------------------------------------------------------
bool QASActivity::skipNotify() const {
return generatorName() == "pumpbridge";
}
pumpa-0.9.2/src/qasobject.h 0000644 0001750 0001750 00000011740 12653206625 014263 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see s_objects;
};
typedef QList RecipientList;
#endif /* _QASOBJECT_H_ */
pumpa-0.9.2/src/oauthwizard.h 0000644 0001750 0001750 00000005164 12653206625 014654 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include
#include "QtKOAuth"
//------------------------------------------------------------------------------
class OAuthFirstPage : public QWizardPage {
Q_OBJECT
public:
OAuthFirstPage(QWidget* parent=0);
void setMessage(QString msg);
signals:
void committed(QString, QString);
protected:
virtual bool validatePage();
virtual bool isComplete() const;
private:
bool splitAccountId(QString& username, QString& server) const;
QLabel* m_messageLabel;
};
//------------------------------------------------------------------------------
class OAuthSecondPage : public QWizardPage {
Q_OBJECT
public:
OAuthSecondPage(QWidget* parent=0);
protected:
virtual bool validatePage();
signals:
void committed(QString, QString);
};
//------------------------------------------------------------------------------
class OAuthWizard : public QWizard {
Q_OBJECT
public:
OAuthWizard(QNetworkAccessManager* nam, KQOAuthManager* oam,
QWidget* parent=0);
signals:
void clientRegistered(QString, QString, QString, QString);
void accessTokenReceived(QString, QString);
private slots:
void onFirstPageCommitted(QString, QString);
void onSecondPageCommitted(QString, QString);
void onOAuthClientRegDone();
void onTemporaryTokenReceived(QString temporaryToken,
QString temporaryTokenSecret);
void onAccessTokenReceived(QString token, QString tokenSecret);
private:
void notifyMessage(QString);
void errorMessage(QString);
void registerOAuthClient();
void getOAuthAccess();
OAuthFirstPage* p1;
OAuthSecondPage* p2;
KQOAuthManager *m_oam;
KQOAuthRequest *m_oar;
QNetworkAccessManager *m_nam;
QString m_server, m_username;
QString m_clientId, m_clientSecret;
int m_clientRegTryCount;
};
#endif /* _OAUTHWIZARD_H_ */
pumpa-0.9.2/src/pumpasettingsdialog.h 0000644 0001750 0001750 00000004014 12653206625 016367 0 ustar mats mats /*
Copyright 2013-2015 Mats Sjöberg
This file is part of the Pumpa programme.
Pumpa 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 3 of the License, or
(at your option) any later version.
Pumpa 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 Pumpa. If not, see
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "pumpasettings.h"
class PumpaSettingsDialog : public QDialog {
Q_OBJECT
public:
PumpaSettingsDialog(PumpaSettings* settings, QWidget* parent=0);
static int comboIndexToFeedInt(int i) {
return comboIndexConverter(i, false);
}
static int feedIntToComboIndex(int i) {
return comboIndexConverter(i, true);
}
signals:
void newAccount();
private slots:
void onOKClicked();
// void on_buttonBox_accepted();
protected:
void setVisible(bool visible);
private slots:
void onAuthButtonClicked();
private:
static int comboIndexConverter(int i, bool backwards=false);
void updateUI();
PumpaSettings* s;
QLabel* m_currentAccountLabel;
QPushButton* m_authButton;
QSpinBox* m_updateTimeSpinBox;
QCheckBox* m_useIconCheckBox;
QCheckBox* m_showCharCountCheckBox;
QDialogButtonBox* m_buttonBox;
QComboBox* m_highlightComboBox;
QComboBox* m_popupComboBox;
QComboBox* m_defaultToComboBox;
QComboBox* m_defaultCcComboBox;
// QFormLayout* m_formLayout;
QVBoxLayout* m_layout;
};
#endif /* _PUMPASETTINGSDIALOG_H_ */
pumpa-0.9.2/src/kQOAuth/ 0000755 0001750 0001750 00000000000 12653206625 013450 5 ustar mats mats pumpa-0.9.2/src/kQOAuth/kqoauthauthreplyserver_p.h 0000644 0001750 0001750 00000003023 12653206625 020777 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
class KQOAUTH_EXPORT KQOAuthAuthReplyServerPrivate: public QObject
{
Q_OBJECT
public:
KQOAuthAuthReplyServerPrivate( KQOAuthAuthReplyServer * parent );
~KQOAuthAuthReplyServerPrivate();
QMultiMap parseQueryParams(QByteArray *sdata);
public Q_SLOTS:
void onIncomingConnection();
void onBytesReady();
public:
KQOAuthAuthReplyServer * q_ptr;
Q_DECLARE_PUBLIC(KQOAuthAuthReplyServer);
QTcpSocket *socket;
};
#endif // KQOAUTHAUTHREPLYSERVER_P_H
pumpa-0.9.2/src/kQOAuth/kqoauthrequest_xauth_p.h 0000644 0001750 0001750 00000002120 12653206625 020431 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#include
#include
#include
#include
#include
#include "kqoauthrequest.h"
#include "kqoauthrequest_p.h"
#include "kqoauthutils.h"
#include "kqoauthglobals.h"
//////////// Private d_ptr implementation /////////
KQOAuthRequestPrivate::KQOAuthRequestPrivate() :
timeout(0)
{
}
KQOAuthRequestPrivate::~KQOAuthRequestPrivate()
{
}
// This method will not include the "oauthSignature" paramater, since it is calculated from these parameters.
void KQOAuthRequestPrivate::prepareRequest() {
// If parameter list is not empty, we don't want to insert these values by
// accident a second time. So giving up.
if( !requestParameters.isEmpty() ) {
return;
}
switch ( requestType ) {
case KQOAuthRequest::TemporaryCredentials:
requestParameters.append( qMakePair( OAUTH_KEY_CALLBACK,
oauthCallbackUrl.isEmpty() ?
"oob" :
oauthCallbackUrl.toString() ));
requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod) );
requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey ));
requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion ));
requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() ));
requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() ));
break;
case KQOAuthRequest::AccessToken:
requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod ));
requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey ));
requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion ));
requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() ));
requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() ));
requestParameters.append( qMakePair( OAUTH_KEY_VERIFIER, oauthVerifier ));
requestParameters.append( qMakePair( OAUTH_KEY_TOKEN, oauthToken ));
break;
case KQOAuthRequest::AuthorizedRequest:
requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE_METHOD, oauthSignatureMethod ));
requestParameters.append( qMakePair( OAUTH_KEY_CONSUMER_KEY, oauthConsumerKey ));
requestParameters.append( qMakePair( OAUTH_KEY_VERSION, oauthVersion ));
requestParameters.append( qMakePair( OAUTH_KEY_TIMESTAMP, this->oauthTimestamp() ));
requestParameters.append( qMakePair( OAUTH_KEY_NONCE, this->oauthNonce() ));
requestParameters.append( qMakePair( OAUTH_KEY_TOKEN, oauthToken ));
break;
default:
break;
}
}
void KQOAuthRequestPrivate::signRequest() {
QString signature = this->oauthSignature();
requestParameters.append( qMakePair( OAUTH_KEY_SIGNATURE, signature) );
}
QString KQOAuthRequestPrivate::oauthSignature() {
/**
* http://oauth.net/core/1.0/#anchor16
* The HMAC-SHA1 signature method uses the HMAC-SHA1 signature algorithm as defined in [RFC2104] where the
* Signature Base String is the text and the key is the concatenated values (each first encoded per Parameter
* Encoding) of the Consumer Secret and Token Secret, separated by an ‘&’ character (ASCII code 38) even if empty.
**/
QByteArray baseString = this->requestBaseString();
QString secret = QString(QUrl::toPercentEncoding(oauthConsumerSecretKey)) + "&" + QString(QUrl::toPercentEncoding(oauthTokenSecret));
QString signature = KQOAuthUtils::hmac_sha1(baseString, secret);
if (debugOutput) {
qDebug() << "========== KQOAuthRequest has the following signature:";
qDebug() << " * Signature : " << QUrl::toPercentEncoding(signature) << "\n";
}
return QString( QUrl::toPercentEncoding(signature) );
}
bool normalizedParameterSort(const QPair &left, const QPair &right) {
QString keyLeft = left.first;
QString valueLeft = left.second;
QString keyRight = right.first;
QString valueRight = right.second;
if(keyLeft == keyRight) {
return (valueLeft < valueRight);
} else {
return (keyLeft < keyRight);
}
}
QByteArray KQOAuthRequestPrivate::requestBaseString() {
QByteArray baseString;
// Every request has these as the commont parameters.
baseString.append( oauthHttpMethodString.toUtf8() + "&"); // HTTP method
baseString.append( QUrl::toPercentEncoding( oauthRequestEndpoint.toString(QUrl::RemoveQuery) ) + "&" ); // The path and query components
QList< QPair > baseStringParameters;
baseStringParameters.append(requestParameters);
baseStringParameters.append(additionalParameters);
// Sort the request parameters. These parameters have been
// initialized earlier.
qSort(baseStringParameters.begin(),
baseStringParameters.end(),
normalizedParameterSort
);
// Last append the request parameters correctly encoded.
baseString.append( encodedParamaterList(baseStringParameters) );
if (debugOutput) {
qDebug() << "========== KQOAuthRequest has the following base string:";
qDebug() << baseString << "\n";
}
return baseString;
}
QByteArray KQOAuthRequestPrivate::encodedParamaterList(const QList< QPair > ¶meters) {
QByteArray resultList;
bool first = true;
QPair parameter;
// Do the debug output.
if (debugOutput) {
qDebug() << "========== KQOAuthRequest has the following parameters:";
}
foreach (parameter, parameters) {
if(!first) {
resultList.append( "&" );
} else {
first = false;
}
// Here we don't need to explicitely encode the strings to UTF-8 since
// QUrl::toPercentEncoding() takes care of that for us.
resultList.append( QUrl::toPercentEncoding(parameter.first) // Parameter key
+ "="
+ QUrl::toPercentEncoding(parameter.second) // Parameter value
);
if (debugOutput) {
qDebug() << " * "
<< parameter.first
<< " : "
<< parameter.second;
}
}
if (debugOutput) {
qDebug() << "\n";
}
return QUrl::toPercentEncoding(resultList);
}
QString KQOAuthRequestPrivate::oauthTimestamp() const {
// This is basically for unit tests only. In most cases we don't set the nonce beforehand.
if (!oauthTimestamp_.isEmpty()) {
return oauthTimestamp_;
}
#if QT_VERSION >= 0x040700
return QString::number(QDateTime::currentDateTimeUtc().toTime_t());
#else
return QString::number(QDateTime::currentDateTime().toUTC().toTime_t());
#endif
}
QString KQOAuthRequestPrivate::oauthNonce() const {
// This is basically for unit tests only. In most cases we don't set the nonce beforehand.
if (!oauthNonce_.isEmpty()) {
return oauthNonce_;
}
return QString::number(qrand());
}
bool KQOAuthRequestPrivate::validateRequest() const {
switch ( requestType ) {
case KQOAuthRequest::TemporaryCredentials:
if (oauthRequestEndpoint.isEmpty()
|| oauthConsumerKey.isEmpty()
|| oauthNonce_.isEmpty()
|| oauthSignatureMethod.isEmpty()
|| oauthTimestamp_.isEmpty()
|| oauthVersion.isEmpty())
{
return false;
}
return true;
case KQOAuthRequest::AccessToken:
if (oauthRequestEndpoint.isEmpty()
|| oauthVerifier.isEmpty()
|| oauthConsumerKey.isEmpty()
|| oauthNonce_.isEmpty()
|| oauthSignatureMethod.isEmpty()
|| oauthTimestamp_.isEmpty()
|| oauthToken.isEmpty()
|| oauthTokenSecret.isEmpty()
|| oauthVersion.isEmpty())
{
return false;
}
return true;
case KQOAuthRequest::AuthorizedRequest:
if (oauthRequestEndpoint.isEmpty()
|| oauthConsumerKey.isEmpty()
|| oauthNonce_.isEmpty()
|| oauthSignatureMethod.isEmpty()
|| oauthTimestamp_.isEmpty()
|| oauthToken.isEmpty()
|| oauthTokenSecret.isEmpty()
|| oauthVersion.isEmpty())
{
return false;
}
return true;
default:
return false;
}
// We should not come here.
return false;
}
//////////// Public implementation ////////////////
KQOAuthRequest::KQOAuthRequest(QObject *parent) :
QObject(parent),
d_ptr(new KQOAuthRequestPrivate)
{
Q_D(KQOAuthRequest);
d_ptr->debugOutput = false; // No debug output by default.
connect(&(d->timer), SIGNAL(timeout()), this, SIGNAL(requestTimedout()));
}
KQOAuthRequest::~KQOAuthRequest()
{
delete d_ptr;
}
void KQOAuthRequest::initRequest(KQOAuthRequest::RequestType type, const QUrl &requestEndpoint) {
Q_D(KQOAuthRequest);
if (!requestEndpoint.isValid()) {
qWarning() << "Endpoint URL is not valid. Ignoring. This request might not work.";
return;
}
if (type < 0 || type > KQOAuthRequest::AuthorizedRequest) {
qWarning() << "Invalid request type. Ignoring. This request might not work.";
return;
}
// Clear the request
clearRequest();
// Set smart defaults.
d->requestType = type;
d->oauthRequestEndpoint = requestEndpoint;
d->oauthTimestamp_ = d->oauthTimestamp();
d->oauthNonce_ = d->oauthNonce();
this->setSignatureMethod(KQOAuthRequest::HMAC_SHA1);
this->setHttpMethod(KQOAuthRequest::POST);
d->oauthVersion = "1.0"; // Currently supports only version 1.0
d->contentType = "application/x-www-form-urlencoded";
}
void KQOAuthRequest::setConsumerKey(const QString &consumerKey) {
Q_D(KQOAuthRequest);
d->oauthConsumerKey = consumerKey;
}
void KQOAuthRequest::setConsumerSecretKey(const QString &consumerSecretKey) {
Q_D(KQOAuthRequest);
d->oauthConsumerSecretKey = consumerSecretKey;
}
void KQOAuthRequest::setCallbackUrl(const QUrl &callbackUrl) {
Q_D(KQOAuthRequest);
d->oauthCallbackUrl = callbackUrl;
}
void KQOAuthRequest::setSignatureMethod(KQOAuthRequest::RequestSignatureMethod requestMethod) {
Q_D(KQOAuthRequest);
QString requestMethodString;
switch (requestMethod) {
case KQOAuthRequest::PLAINTEXT:
requestMethodString = "PLAINTEXT";
break;
case KQOAuthRequest::HMAC_SHA1:
requestMethodString = "HMAC-SHA1";
break;
case KQOAuthRequest::RSA_SHA1:
requestMethodString = "RSA-SHA1";
break;
default:
// We should not come here
qWarning() << "Invalid signature method set.";
break;
}
d->oauthSignatureMethod = requestMethodString;
}
void KQOAuthRequest::setTokenSecret(const QString &tokenSecret) {
Q_D(KQOAuthRequest);
d->oauthTokenSecret = tokenSecret;
}
void KQOAuthRequest::setToken(const QString &token) {
Q_D(KQOAuthRequest);
d->oauthToken = token;
}
void KQOAuthRequest::setVerifier(const QString &verifier) {
Q_D(KQOAuthRequest);
d->oauthVerifier = verifier;
}
void KQOAuthRequest::setHttpMethod(KQOAuthRequest::RequestHttpMethod httpMethod) {
Q_D(KQOAuthRequest);
QString requestHttpMethodString;
switch (httpMethod) {
case KQOAuthRequest::GET:
requestHttpMethodString = "GET";
break;
case KQOAuthRequest::POST:
requestHttpMethodString = "POST";
break;
case KQOAuthRequest::PUT:
requestHttpMethodString = "PUT";
break;
default:
qWarning() << "Invalid HTTP method set.";
break;
}
d->oauthHttpMethod = httpMethod;
d->oauthHttpMethodString = requestHttpMethodString;
}
KQOAuthRequest::RequestHttpMethod KQOAuthRequest::httpMethod() const {
Q_D(const KQOAuthRequest);
return d->oauthHttpMethod;
}
void KQOAuthRequest::setAdditionalParameters(const KQOAuthParameters &additionalParams) {
Q_D(KQOAuthRequest);
QList additionalKeys = additionalParams.keys();
QList additionalValues = additionalParams.values();
int i=0;
foreach(QString key, additionalKeys) {
QString value = additionalValues.at(i);
d->additionalParameters.append( qMakePair(key, value) );
i++;
}
}
KQOAuthParameters KQOAuthRequest::additionalParameters() const {
Q_D(const KQOAuthRequest);
QMultiMap additionalParams;
for(int i=0; iadditionalParameters.size(); i++) {
additionalParams.insert(d->additionalParameters.at(i).first,
d->additionalParameters.at(i).second);
}
return additionalParams;
}
KQOAuthRequest::RequestType KQOAuthRequest::requestType() const {
Q_D(const KQOAuthRequest);
return d->requestType;
}
QUrl KQOAuthRequest::requestEndpoint() const {
Q_D(const KQOAuthRequest);
return d->oauthRequestEndpoint;
}
QList KQOAuthRequest::requestParameters() {
Q_D(KQOAuthRequest);
QList requestParamList;
d->prepareRequest();
if (!isValid() ) {
qWarning() << "Request is not valid! I will still sign it, but it will probably not work.";
}
d->signRequest();
QPair requestParam;
QString param;
QString value;
foreach (requestParam, d->requestParameters) {
param = requestParam.first;
value = requestParam.second;
if (param != OAUTH_KEY_SIGNATURE) {
value = QUrl::toPercentEncoding(value);
}
requestParamList.append(QString(param + "=\"" + value +"\"").toUtf8());
}
return requestParamList;
}
QString KQOAuthRequest::contentType()
{
Q_D(const KQOAuthRequest);
return d->contentType;
}
void KQOAuthRequest::setContentType(const QString &contentType)
{
Q_D(KQOAuthRequest);
d->contentType = contentType;
}
int KQOAuthRequest::contentLength()
{
Q_D(const KQOAuthRequest);
return d->contentLength;
}
void KQOAuthRequest::setContentLength(int contentLength)
{
Q_D(KQOAuthRequest);
d->contentLength = contentLength;
}
QByteArray KQOAuthRequest::rawData()
{
Q_D(const KQOAuthRequest);
return d->postRawData;
}
void KQOAuthRequest::setRawData(const QByteArray &rawData)
{
Q_D(KQOAuthRequest);
d->postRawData = rawData;
}
QByteArray KQOAuthRequest::requestBody() const {
Q_D(const KQOAuthRequest);
QByteArray postBodyContent;
bool first = true;
for(int i=0; i < d->additionalParameters.size(); i++) {
if(!first) {
postBodyContent.append("&");
} else {
first = false;
}
QString key = d->additionalParameters.at(i).first;
QString value = d->additionalParameters.at(i).second;
postBodyContent.append(QUrl::toPercentEncoding(key) + QString("=").toUtf8() +
QUrl::toPercentEncoding(value));
}
return postBodyContent;
}
bool KQOAuthRequest::isValid() const {
Q_D(const KQOAuthRequest);
return d->validateRequest();
}
void KQOAuthRequest::setTimeout(int timeoutMilliseconds) {
Q_D(KQOAuthRequest);
d->timeout = timeoutMilliseconds;
}
void KQOAuthRequest::clearRequest() {
Q_D(KQOAuthRequest);
d->oauthRequestEndpoint = "";
d->oauthHttpMethodString = "";
d->oauthConsumerKey = "";
d->oauthConsumerSecretKey = "";
d->oauthToken = "";
d->oauthTokenSecret = "";
d->oauthSignatureMethod = "";
d->oauthCallbackUrl = "";
d->oauthVerifier = "";
d->oauthTimestamp_ = "";
d->oauthNonce_ = "";
d->requestParameters.clear();
d->additionalParameters.clear();
d->timeout = 0;
}
void KQOAuthRequest::setEnableDebugOutput(bool enabled) {
Q_D(KQOAuthRequest);
d->debugOutput = enabled;
}
/**
* Protected implementations for inherited classes
*/
bool KQOAuthRequest::validateXAuthRequest() const {
Q_D(const KQOAuthRequest);
if (d->oauthRequestEndpoint.isEmpty()
|| d->oauthConsumerKey.isEmpty()
|| d->oauthNonce_.isEmpty()
|| d->oauthSignatureMethod.isEmpty()
|| d->oauthTimestamp_.isEmpty()
|| d->oauthVersion.isEmpty())
{
return false;
}
return true;
}
/**
* Private implementations for friend classes
*/
QString KQOAuthRequest::consumerKeyForManager() const {
Q_D(const KQOAuthRequest);
return d->oauthConsumerKey;
}
QString KQOAuthRequest::consumerKeySecretForManager() const {
Q_D(const KQOAuthRequest);
return d->oauthConsumerSecretKey;
}
QUrl KQOAuthRequest::callbackUrlForManager() const {
Q_D(const KQOAuthRequest);
return d->oauthCallbackUrl;
}
void KQOAuthRequest::requestTimerStart()
{
Q_D(KQOAuthRequest);
if (d->timeout > 0) {
d->timer.start(d->timeout);
}
}
void KQOAuthRequest::requestTimerStop()
{
Q_D(KQOAuthRequest);
if( d->timer.isActive() )
d->timer.stop();
}
pumpa-0.9.2/src/kQOAuth/kqoauthrequest_xauth.cpp 0000644 0001750 0001750 00000005216 12653206625 020456 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include "kqoauthrequest_xauth_p.h"
#include "kqoauthrequest_xauth.h"
/**
* Private d_ptr implementations.
*/
KQOAuthRequest_XAuthPrivate::KQOAuthRequest_XAuthPrivate()
{
}
KQOAuthRequest_XAuthPrivate::~KQOAuthRequest_XAuthPrivate()
{
}
/**
* Public implementations.
*/
KQOAuthRequest_XAuth::KQOAuthRequest_XAuth(QObject *parent) :
KQOAuthRequest(parent),
d_ptr(new KQOAuthRequest_XAuthPrivate)
{
}
bool KQOAuthRequest_XAuth::isValid() const {
// An xAuth can never request temporary credentials.
if (requestType() == KQOAuthRequest::TemporaryCredentials) {
qWarning() << "XAuth request cannot be of type KQOAuthRequest::TemporaryCredentials. Aborting.";
return false;
}
// Access token must always be retrieved using the POST HTTP method.
if (requestType() == KQOAuthRequest::AccessToken
&& httpMethod() != KQOAuthRequest::POST) {
qWarning() << "Access tokens must be fetched using the POST HTTP method. Aborting.";
return false;
}
if (!xauth_parameters_set) {
qWarning() << "No XAuth parameters set. Aborting.";
return false;
}
// And then check the validity of the XAuth request.
// Provided by the base class as a protected method for us.
return validateXAuthRequest();
}
void KQOAuthRequest_XAuth::setXAuthLogin(const QString &username,
const QString &password) {
if (username.isEmpty() || password.isEmpty()) {
qWarning() << "Username or password cannot be empty. Aborting.";
return;
}
xauth_parameters_set = true;
KQOAuthParameters xauthParams;
xauthParams.insert("x_auth_username", username);
xauthParams.insert("x_auth_password", password);
xauthParams.insert("x_auth_mode", "client_auth");
setAdditionalParameters(xauthParams);
}
pumpa-0.9.2/src/kQOAuth/kqoauthglobals.h 0000644 0001750 0001750 00000003676 12653206625 016655 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
// The Q_DECL_EXPORT/Q_DECL_IMPORT things are only needed when compiling
// a shared library or against one in Windows. We aren't doing either in
// Pumpa.
//
// Credit goes to Tim Schumacher for finding
// a solution for this.
#define KQOAUTH_EXPORT
// #if defined(KQOAUTH)
// # define KQOAUTH_EXPORT Q_DECL_EXPORT
// #else
// # define KQOAUTH_EXPORT Q_DECL_IMPORT
// #endif
//////////// Static constant definitions ///////////
const QString OAUTH_KEY_CONSUMER("oauth_consumer");
const QString OAUTH_KEY_CONSUMER_KEY("oauth_consumer_key");
const QString OAUTH_KEY_TOKEN("oauth_token");
const QString OAUTH_KEY_TOKEN_SECRET("oauth_token_secret");
const QString OAUTH_KEY_SIGNATURE_METHOD("oauth_signature_method");
const QString OAUTH_KEY_TIMESTAMP("oauth_timestamp");
const QString OAUTH_KEY_NONCE("oauth_nonce");
const QString OAUTH_KEY_SIGNATURE("oauth_signature");
const QString OAUTH_KEY_CALLBACK("oauth_callback");
const QString OAUTH_KEY_VERIFIER("oauth_verifier");
const QString OAUTH_KEY_VERSION("oauth_version");
#endif // KQOAUTHGLOBALS_H
pumpa-0.9.2/src/kQOAuth/Makefile 0000644 0001750 0001750 00000000030 12653206625 015101 0 ustar mats mats all:
$(MAKE) -C ../../
pumpa-0.9.2/src/kQOAuth/kqoauthrequest.h 0000644 0001750 0001750 00000011351 12653206625 016707 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#include
#include "kqoauthglobals.h"
typedef QMultiMap KQOAuthParameters;
class KQOAuthRequestPrivate;
class KQOAUTH_EXPORT KQOAuthRequest : public QObject
{
Q_OBJECT
public:
explicit KQOAuthRequest(QObject *parent = 0);
~KQOAuthRequest();
enum RequestType {
TemporaryCredentials = 0,
AccessToken,
AuthorizedRequest
};
enum RequestSignatureMethod {
PLAINTEXT = 0,
HMAC_SHA1,
RSA_SHA1
};
enum RequestHttpMethod {
GET = 0,
POST,
PUT
};
/**
* These methods can be overridden in child classes which are different types of
* OAuth requests.
*/
// Validate the request of this type.
virtual bool isValid() const;
/**
* These methods are OAuth request type specific and not overridden in child
* classes.
* NOTE: Refactorting still a TODO
*/
// Initialize the request of this type.
void initRequest(KQOAuthRequest::RequestType type, const QUrl &requestEndpoint);
void setConsumerKey(const QString &consumerKey);
void setConsumerSecretKey(const QString &consumerSecretKey);
// Mandatory methods for acquiring a request token
void setCallbackUrl(const QUrl &callbackUrl);
// Mandator methods for acquiring a access token
void setTokenSecret(const QString &tokenSecret);
void setToken(const QString &token);
void setVerifier(const QString &verifier);
// Request signature method to use - HMAC_SHA1 currently only supported
void setSignatureMethod(KQOAuthRequest::RequestSignatureMethod = KQOAuthRequest::HMAC_SHA1);
// Request's HTTP method.
void setHttpMethod(KQOAuthRequest::RequestHttpMethod = KQOAuthRequest::POST);
KQOAuthRequest::RequestHttpMethod httpMethod() const;
// Sets the timeout for this request. If the timeout expires, the signal "requestTimedout" will be
// emitted. The KQOAuthManager will then call the abort() function from QNetworkReply associated with this request
// 0 = If set to zero, timeout is disabled.
// TODO: Do we need some request ID now?
void setTimeout(int timeoutMilliseconds);
// Additional optional parameters to the request.
void setAdditionalParameters(const KQOAuthParameters &additionalParams);
KQOAuthParameters additionalParameters() const;
QList requestParameters(); // This will return all request's parameters in the raw format given
// to the QNetworkRequest.
QByteArray requestBody() const; // This will return the POST body as given to the QNetworkRequest.
KQOAuthRequest::RequestType requestType() const;
QUrl requestEndpoint() const;
void setContentType(const QString &contentType);
QString contentType();
void setContentLength(int contentLength);
int contentLength();
void setRawData(const QByteArray &rawData);
QByteArray rawData();
void clearRequest();
// Enable verbose debug output for request content.
void setEnableDebugOutput(bool enabled);
Q_SIGNALS:
// This signal is emited if the request is not completed before the request's timeout
// value has expired.
void requestTimedout();
protected:
bool validateXAuthRequest() const;
private:
KQOAuthRequestPrivate * const d_ptr;
Q_DECLARE_PRIVATE(KQOAuthRequest);
Q_DISABLE_COPY(KQOAuthRequest);
// These classes are only for the internal use of KQOAuthManager so it can
// work with the opaque request.
QString consumerKeyForManager() const;
QString consumerKeySecretForManager() const;
QUrl callbackUrlForManager() const;
// This method is for timeout handling by the KQOAuthManager.
void requestTimerStart();
void requestTimerStop();
friend class KQOAuthManager;
#ifdef UNIT_TEST
friend class Ut_KQOAuth;
#endif
};
#endif // KQOAUTHREQUEST_H
pumpa-0.9.2/src/kQOAuth/kqoauthutils.cpp 0000644 0001750 0001750 00000004777 12653206625 016730 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#include
#include
#include "kqoauthutils.h"
QString KQOAuthUtils::hmac_sha1(const QString &message, const QString &key)
{
QByteArray keyBytes = key.toLatin1();
int keyLength; // Lenght of key word
const int blockSize = 64; // Both MD5 and SHA-1 have a block size of 64.
keyLength = keyBytes.size();
// If key is longer than block size, we need to hash the key
if (keyLength > blockSize) {
QCryptographicHash hash(QCryptographicHash::Sha1);
hash.addData(keyBytes);
keyBytes = hash.result();
}
/* http://tools.ietf.org/html/rfc2104 - (1) */
// Create the opad and ipad for the hash function.
QByteArray ipad;
QByteArray opad;
ipad.fill( 0, blockSize);
opad.fill( 0, blockSize);
ipad.replace(0, keyBytes.length(), keyBytes);
opad.replace(0, keyBytes.length(), keyBytes);
/* http://tools.ietf.org/html/rfc2104 - (2) & (5) */
for (int i=0; i<64; i++) {
ipad[i] = ipad[i] ^ 0x36;
opad[i] = opad[i] ^ 0x5c;
}
QByteArray workArray;
workArray.clear();
workArray.append(ipad, 64);
/* http://tools.ietf.org/html/rfc2104 - (3) */
workArray.append(message.toLatin1());
/* http://tools.ietf.org/html/rfc2104 - (4) */
QByteArray sha1 = QCryptographicHash::hash(workArray, QCryptographicHash::Sha1);
/* http://tools.ietf.org/html/rfc2104 - (6) */
workArray.clear();
workArray.append(opad, 64);
workArray.append(sha1);
sha1.clear();
/* http://tools.ietf.org/html/rfc2104 - (7) */
sha1 = QCryptographicHash::hash(workArray, QCryptographicHash::Sha1);
return QString(sha1.toBase64());
}
pumpa-0.9.2/src/kQOAuth/kqoauthmanager.h 0000644 0001750 0001750 00000021565 12653206625 016641 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#include
#include
#include "kqoauthrequest.h"
class KQOAuthRequest;
class KQOAuthManagerThread;
class KQOAuthManagerPrivate;
class QNetworkAccessManager;
class QUrl;
class QByteArray;
class KQOAUTH_EXPORT KQOAuthManager : public QObject
{
Q_OBJECT
public:
enum KQOAuthError {
NoError, // No error
NetworkError, // Network error: timeout, cannot connect.
RequestEndpointError, // Request endpoint is not valid.
RequestValidationError, // Request is not valid: some parameter missing?
RequestUnauthorized, // Authorization error: trying to access a resource without tokens.
RequestError, // The given request to KQOAuthManager is invalid: NULL?,
ManagerError // Manager error, cannot use for sending requests.
};
explicit KQOAuthManager(QObject *parent = 0);
~KQOAuthManager();
KQOAuthError lastError();
QNetworkReply* getReply(KQOAuthRequest* request);
/**
* The manager executes the given request. It takes the HTTP parameters from the
* request and uses QNetworkAccessManager to submit the HTTP request to the net.
* When the request is done it will emit signal requestReady(QByteArray networkReply).
* NOTE: At the moment there is no timeout for the request.
*/
void executeRequest(KQOAuthRequest *request);
void executeAuthorizedRequest(KQOAuthRequest *request, int id);
/**
* Indicates to the user that KQOAuthManager should handle user authorization by
* opening the user's default browser and parsing the reply from the service.
* By setting the parameter to true, KQOAuthManager will store intermediate results
* of the OAuth 1.0 process in its own opaque request. This information is used in
* the user authorization process and also when calling sendAuthorizedRequest().
* NOTE: You need to set this to true if you want to use getUserAccessTokens() or
* sendAuthorizedRequest().
*/
void setHandleUserAuthorization(bool set);
/**
* Returns true if the KQOAuthManager has retrieved the oauth_token value. Otherwise
* return false.
*/
bool hasTemporaryToken();
/**
* Returns true if the user has authorized us to use the protected resources. Otherwise
* returns false.
* NOTE: In order for KQOAuthManager to know if the user has authorized us to use the
* protected resources, KQOAuthManager must be in control of the user authorization
* process. Hence, this returns true if setHandleUserAuthorization() is set to true
* and the user is authorized with getUserAuthorization().
*/
bool isVerified();
/**
* Returns true if KQOAuthManager has the access token and hence can access the protected
* resources. Otherwise returns false.
* NOTE: In order for KQOAuthManager to know if we have access to protected resource
* KQOAuthManager must be in control of the user authorization process and requesting
* the acess token. Hence, this returns true if setHandleUserAuthorization() is set to true
* and the user is authorized with getUserAuthorization() and the access token must be retrieved
* with getUserAccessTokens.
*/
bool isAuthorized();
/**
* This is a convenience API for authorizing the user.
* The call will open the user's default browser, setup a local HTTP server and parse the reply from the
* service after the user has authorized us to access protected resources. If the user authorizes
* us to access protected resources, the verifier token is stored in KQOAuthManager for further use.
* In order to use this method, you must set setHandleUserAuthorization() to true.
*/
void getUserAuthorization(QUrl authorizationEndpoint);
/**
* This is a convenience API for retrieving the access token in exchange for the temporary token and the
* verifier.
* This call will create a KQOAuthRequest and use the previously stored temporary token and verifier to
* exchange for the access token, which will be used to access the protected resources.
* Note that in order to use this method, KQOAuthManager must be in control of the user authorization process.
* Set setHandleUserAuthorization() to true and retrieve user authorization with void getUserAuthorization.
*/
void getUserAccessTokens(QUrl accessTokenEndpoint);
/**
* This is a conveience API for setting the token verifier.
* If setHandleUserAuthorization() is set to false you need to call this function before calling
* getUserAccessTokens()
*/
void verifyToken(const QString &token, const QString &verifier);
/**
* Sends a request to the protected resources. Parameters for the request are service specific and
* are given to the 'requestParameters' as parameters.
* Note that in order to use this method, KQOAuthManager must be in control of the user authorization process.
* Set setHandleUserAuthorization() to true and retrieve user authorization with void getUserAuthorization.
*/
void sendAuthorizedRequest(QUrl requestEndpoint, const KQOAuthParameters &requestParameters);
/**
* Sets a custom QNetworkAccessManager to handle network requests. This method can be useful if the
* application is using some proxy settings for example.
* The application is responsible for deleting this manager. KQOAuthManager will not delete any
* previously given manager.
* If the manager is NULL, the manager will not be set and the KQOAuthManager::Error.
* If no manager is given, KQOAuthManager will use the default one it will create by itself.
*/
void setNetworkManager(QNetworkAccessManager *manager);
/**
* Returns the given QNetworkAccessManager. Returns NULL if none is given.
*/
QNetworkAccessManager* networkManager() const;
Q_SIGNALS:
// This signal will be emitted after each request has got a reply.
// Parameter is the raw response from the service.
void requestReady(QByteArray networkReply);
void authorizedRequestReady(QByteArray networkReply, int id);
// This signal will be emited when we have an request tokens available
// (either temporary resource tokens, or authorization tokens).
void receivedToken(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret
// This signal is emited when temporary tokens are returned from the service.
// Note that this signal is also emited in case temporary tokens are not available.
void temporaryTokenReceived(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret
// This signal is emited when the user has authenticated the application to
// communicate with the protected resources. Next we need to exchange the
// temporary tokens for access tokens.
// Note that this signal is also emited if user denies access.
void authorizationReceived(QString oauth_token, QString oauth_verifier); // oauth_token, oauth_verifier
// This signal is emited when access tokens are received from the service. We are
// ready to start communicating with the protected resources.
void accessTokenReceived(QString oauth_token, QString oauth_token_secret); // oauth_token, oauth_token_secret
// This signal is emited when the authorized request is done.
// This ends the kQOAuth interactions.
void authorizedRequestDone();
void errorMessage(QString);
void sslErrors(QNetworkReply*, QList);
private Q_SLOTS:
void onRequestReplyReceived( QNetworkReply *reply );
void onAuthorizedRequestReplyReceived( QNetworkReply *reply );
void onVerificationReceived(QMultiMap response);
void slotError(QNetworkReply::NetworkError error);
void requestTimeout();
private:
KQOAuthManagerPrivate *d_ptr;
Q_DECLARE_PRIVATE(KQOAuthManager);
Q_DISABLE_COPY(KQOAuthManager);
};
#endif // KQOAUTHMANAGER_H
pumpa-0.9.2/src/kQOAuth/kqoauthauthreplyserver.h 0000644 0001750 0001750 00000002601 12653206625 020461 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include "kqoauthglobals.h"
class KQOAuthAuthReplyServerPrivate;
class KQOAUTH_EXPORT KQOAuthAuthReplyServer : public QTcpServer
{
Q_OBJECT
public:
explicit KQOAuthAuthReplyServer(QObject *parent);
~KQOAuthAuthReplyServer();
Q_SIGNALS:
void verificationReceived(QMultiMap);
private:
KQOAuthAuthReplyServerPrivate * const d_ptr;
Q_DECLARE_PRIVATE(KQOAuthAuthReplyServer);
Q_DISABLE_COPY(KQOAuthAuthReplyServer);
};
#endif // KQOAUTHAUTHREPLYSERVER_H
pumpa-0.9.2/src/kQOAuth/kqoauthrequest_1.cpp 0000644 0001750 0001750 00000001572 12653206625 017466 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#include
#include
#include
#include
class KQOAUTH_EXPORT KQOAuthRequestPrivate {
public:
KQOAuthRequestPrivate();
~KQOAuthRequestPrivate();
// Helper methods to get the values for the OAuth request parameters.
QString oauthTimestamp() const;
QString oauthNonce() const;
QString oauthSignature();
// Utility methods for making the request happen.
void prepareRequest();
void signRequest();
bool validateRequest() const;
QByteArray requestBaseString();
QByteArray encodedParamaterList(const QList< QPair > &requestParameters);
void insertAdditionalParams();
void insertPostBody();
QUrl oauthRequestEndpoint;
KQOAuthRequest::RequestHttpMethod oauthHttpMethod;
QString oauthHttpMethodString;
QString oauthConsumerKey;
QString oauthConsumerSecretKey;
QString oauthToken;
QString oauthTokenSecret;
QString oauthSignatureMethod;
QUrl oauthCallbackUrl;
QString oauthVersion;
QString oauthVerifier;
// These will be generated by the helper methods
QString oauthTimestamp_;
QString oauthNonce_;
// User specified additional parameters needed for the request.
QList< QPair > additionalParameters;
// The raw POST body content as given to the HTTP request.
QByteArray postBodyContent;
// Protocol parameters.
// These parameters are used in the "Authorized" header of the HTTP request.
QList< QPair > requestParameters;
KQOAuthRequest::RequestType requestType;
//The Content-Type HTTP header
QString contentType;
//The Content-Length HTTP header
int contentLength;
//Raw data to post if type is not url-encoded
QByteArray postRawData;
// Timeout for this request in milliseconds.
int timeout;
QTimer timer;
bool debugOutput;
};
#endif // KQOAUTHREQUEST_P_H
pumpa-0.9.2/src/kQOAuth/kqoauthmanager.cpp 0000644 0001750 0001750 00000062700 12653206625 017170 0 ustar mats mats /**
* KQOAuth - An OAuth authentication library for Qt.
*
* Author: Johan Paul (johan.paul@gmail.com)
* http://www.johanpaul.com
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* KQOAuth 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with KQOAuth. If not, see
#include
#if QT_VERSION >= 0x050000
#include
#endif
#include "kqoauthmanager.h"
#include "kqoauthmanager_p.h"
////////////// Private d_ptr implementation ////////////////
KQOAuthManagerPrivate::KQOAuthManagerPrivate(KQOAuthManager *parent) :
error(KQOAuthManager::NoError) ,
r(0) ,
opaqueRequest(new KQOAuthRequest) ,
q_ptr(parent) ,
callbackServer(new KQOAuthAuthReplyServer(parent)) ,
isVerified(false) ,
isAuthorized(false) ,
autoAuth(false),
networkManager(new QNetworkAccessManager),
managerUserSet(false)
{
}
KQOAuthManagerPrivate::~KQOAuthManagerPrivate() {
delete opaqueRequest;
opaqueRequest = 0;
if (!managerUserSet) {
delete networkManager;
networkManager = 0;
}
}
QList< QPair > KQOAuthManagerPrivate::createQueryParams(const KQOAuthParameters &requestParams) {
QList requestKeys = requestParams.keys();
QList requestValues = requestParams.values();
QList< QPair > result;
for(int i=0; i KQOAuthManagerPrivate::createTokensFromResponse(QByteArray reply) {
QMultiMap result;
QString replyString(reply);
QStringList parameterPairs = replyString.split('&', QString::SkipEmptyParts);
foreach (const QString ¶meterPair, parameterPairs) {
QStringList parameter = parameterPair.split('=');
result.insert(parameter.value(0), parameter.value(1));
}
return result;
}
bool KQOAuthManagerPrivate::setSuccessfulRequestToken(const QMultiMap &request) {
if (currentRequestType == KQOAuthRequest::TemporaryCredentials) {
hasTemporaryToken = (!QString(request.value("oauth_token")).isEmpty() && !QString(request.value("oauth_token_secret")).isEmpty());
} else {
return false;
}
if (hasTemporaryToken) {
requestToken = QUrl::fromPercentEncoding( QString(request.value("oauth_token")).toLocal8Bit() );
requestTokenSecret = QUrl::fromPercentEncoding( QString(request.value("oauth_token_secret")).toLocal8Bit() );
}
return hasTemporaryToken;
}
bool KQOAuthManagerPrivate::setSuccessfulAuthorized(const QMultiMap &request ) {
if (currentRequestType == KQOAuthRequest::AccessToken) {
isAuthorized = (!QString(request.value("oauth_token")).isEmpty() && !QString(request.value("oauth_token_secret")).isEmpty());
} else {
return false;
}
if (isAuthorized) {
requestToken = QUrl::fromPercentEncoding( QString(request.value("oauth_token")).toLocal8Bit() );
requestTokenSecret = QUrl::fromPercentEncoding( QString(request.value("oauth_token_secret")).toLocal8Bit() );
}
return isAuthorized;
}
void KQOAuthManagerPrivate::emitTokens() {
Q_Q(KQOAuthManager);
if (this->requestToken.isEmpty() || this->requestTokenSecret.isEmpty()) {
error = KQOAuthManager::RequestUnauthorized;
}
if (currentRequestType == KQOAuthRequest::TemporaryCredentials) {
// Signal that we are ready to use the protected resources.
emit q->temporaryTokenReceived(this->requestToken, this->requestTokenSecret);
}
if (currentRequestType == KQOAuthRequest::AccessToken) {
// Signal that we are ready to use the protected resources.
emit q->accessTokenReceived(this->requestToken, this->requestTokenSecret);
}
emit q->receivedToken(this->requestToken, this->requestTokenSecret);
}
bool KQOAuthManagerPrivate::setupCallbackServer() {
return callbackServer->listen();
}
/////////////// Public implementation ////////////////
KQOAuthManager::KQOAuthManager(QObject *parent) :
QObject(parent) ,
d_ptr(new KQOAuthManagerPrivate(this))
{
qsrand(QTime::currentTime().msec()); // We need to seed the nonce random number with something.
// However, we cannot do this while generating the nonce since
// we might get the same seed. So initializing here should be fine.
}
KQOAuthManager::~KQOAuthManager()
{
delete d_ptr;
}
void KQOAuthManager::executeRequest(KQOAuthRequest *request) {
Q_D(KQOAuthManager);
d->r = request;
if (request == 0) {
qWarning() << "Request is NULL. Cannot proceed.";
d->error = KQOAuthManager::RequestError;
return;
}
if (!request->requestEndpoint().isValid()) {
qWarning() << "Request endpoint URL is not valid. Cannot proceed.";
d->error = KQOAuthManager::RequestEndpointError;
return;
}
if (!request->isValid()) {
qWarning() << "Request is not valid. Cannot proceed.";
d->error = KQOAuthManager::RequestValidationError;
return;
}
d->currentRequestType = request->requestType();
QNetworkRequest networkRequest;
networkRequest.setUrl( request->requestEndpoint() );
if (d->autoAuth && d->currentRequestType == KQOAuthRequest::TemporaryCredentials) {
d->setupCallbackServer();
connect(d->callbackServer, SIGNAL(verificationReceived(QMultiMap)),
this, SLOT( onVerificationReceived(QMultiMap)));
QString serverString = "http://localhost:";
serverString.append(QString::number(d->callbackServer->serverPort()));
request->setCallbackUrl(QUrl(serverString));
}
// And now fill the request with "Authorization" header data.
QList requestHeaders = request->requestParameters();
QByteArray authHeader;
bool first = true;
foreach (const QByteArray header, requestHeaders) {
if (!first) {
authHeader.append(", ");
} else {
authHeader.append("OAuth ");
first = false;
}
authHeader.append(header);
}
networkRequest.setRawHeader("Authorization", authHeader);
connect(d->networkManager, SIGNAL(finished(QNetworkReply *)),
this, SLOT(onRequestReplyReceived(QNetworkReply *)),
Qt::UniqueConnection);
connect(d->networkManager,
SIGNAL(sslErrors(QNetworkReply*, QList)),
this, SIGNAL(sslErrors(QNetworkReply*, QList)),
Qt::UniqueConnection);
disconnect(d->networkManager, SIGNAL(finished(QNetworkReply *)),
this, SLOT(onAuthorizedRequestReplyReceived(QNetworkReply *)));
if (request->httpMethod() == KQOAuthRequest::GET) {
// Get the requested additional params as a list of pairs we can give QUrl
QList< QPair > urlParams = d->createQueryParams(request->additionalParameters());
// Take the original URL and append the query params to it.
QUrl urlWithParams = networkRequest.url();
#if QT_VERSION < 0x050000
urlWithParams.setQueryItems(urlParams);
#else
QUrlQuery query;
query.setQueryItems(urlParams);
urlWithParams.setQuery(query);
#endif
networkRequest.setUrl(urlWithParams);
// Submit the request including the params.
QNetworkReply *reply = d->networkManager->get(networkRequest);
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
d->requestMap.insert( request, reply );
} else if (request->httpMethod() == KQOAuthRequest::POST ||
request->httpMethod() == KQOAuthRequest::PUT) {
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, request->contentType());
/*
qDebug() << networkRequest.rawHeaderList();
qDebug() << networkRequest.rawHeader("Authorization");
qDebug() << networkRequest.rawHeader("Content-Type");
*/
QNetworkReply *reply;
if (request->contentType() == "application/x-www-form-urlencoded") {
reply = d->networkManager->post(networkRequest, request->requestBody());
} else {
reply = d->networkManager->post(networkRequest, request->rawData());
}
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
d->requestMap.insert( request, reply );
}
d->r->requestTimerStart();
}
void KQOAuthManager::executeAuthorizedRequest(KQOAuthRequest *request, int id) {
Q_D(KQOAuthManager);
d->r = request;
if (request == 0) {
qWarning() << "Request is NULL. Cannot proceed.";
d->error = KQOAuthManager::RequestError;
return;
}
if (!request->requestEndpoint().isValid()) {
qWarning() << "Request endpoint URL is not valid. Cannot proceed.";
d->error = KQOAuthManager::RequestEndpointError;
return;
}
if (!request->isValid()) {
qWarning() << "Request is not valid. Cannot proceed.";
d->error = KQOAuthManager::RequestValidationError;
return;
}
d->currentRequestType = request->requestType();
QNetworkRequest networkRequest;
networkRequest.setUrl( request->requestEndpoint() );
if ( d->currentRequestType != KQOAuthRequest::AuthorizedRequest){
qWarning() << "Not Authorized Request. Cannot proceed";
d->error = KQOAuthManager::RequestError;
return;
}
// And now fill the request with "Authorization" header data.
QList requestHeaders = request->requestParameters();
QByteArray authHeader;
bool first = true;
foreach (const QByteArray header, requestHeaders) {
if (!first) {
authHeader.append(", ");
} else {
authHeader.append("OAuth ");
first = false;
}
authHeader.append(header);
}
networkRequest.setRawHeader("Authorization", authHeader);
disconnect(d->networkManager, SIGNAL(finished(QNetworkReply *)),
this, SLOT(onRequestReplyReceived(QNetworkReply *)));
connect(d->networkManager,
SIGNAL(sslErrors(QNetworkReply*, QList)),
this, SIGNAL(sslErrors(QNetworkReply*, QList)),
Qt::UniqueConnection);
connect(d->networkManager, SIGNAL(finished(QNetworkReply *)),
this, SLOT(onAuthorizedRequestReplyReceived(QNetworkReply*)),
Qt::UniqueConnection);
QNetworkReply *reply = NULL;
if (request->httpMethod() == KQOAuthRequest::GET) {
// Get the requested additional params as a list of pairs we can give QUrl
QList< QPair > urlParams = d->createQueryParams(request->additionalParameters());
// Take the original URL and append the query params to it.
QUrl urlWithParams = networkRequest.url();
#if QT_VERSION < 0x050000
urlWithParams.setQueryItems(urlParams);
#else
QUrlQuery query;
query.setQueryItems(urlParams);
urlWithParams.setQuery(query);
#endif
networkRequest.setUrl(urlWithParams);
// Submit the request including the params.
reply = d->networkManager->get(networkRequest);
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
connect(request, SIGNAL(requestTimedout()),
this, SLOT(requestTimeout()));
d->requestMap.insert( request, reply );
} else if (request->httpMethod() == KQOAuthRequest::POST ||
request->httpMethod() == KQOAuthRequest::PUT) {
networkRequest.setHeader(QNetworkRequest::ContentTypeHeader, request->contentType());
int contentLength = request->contentLength();
if (contentLength != -1)
networkRequest.setHeader(QNetworkRequest::ContentLengthHeader, contentLength);
#ifdef DEBUG_NET_MOAR
QList nrhl = networkRequest.rawHeaderList();
for (int i=0; ihttpMethod() == KQOAuthRequest::PUT) {
if (request->contentType() == "application/x-www-form-urlencoded") {
reply = d->networkManager->put(networkRequest, request->requestBody());
} else {
reply = d->networkManager->put(networkRequest, request->rawData());
}
} else {
if (request->contentType() == "application/x-www-form-urlencoded") {
reply = d->networkManager->post(networkRequest, request->requestBody());
} else {
reply = d->networkManager->post(networkRequest, request->rawData());
}
}
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)),
this, SLOT(slotError(QNetworkReply::NetworkError)));
connect(request, SIGNAL(requestTimedout()),
this, SLOT(requestTimeout()));
d->requestMap.insert( request, reply );
}
d->requestIds.insert(reply, id);
d->r->requestTimerStart();
}
void KQOAuthManager::setHandleUserAuthorization(bool set) {
Q_D(KQOAuthManager);
d->autoAuth = set;
}
bool KQOAuthManager::hasTemporaryToken() {
Q_D(KQOAuthManager);
return d->hasTemporaryToken;
}
bool KQOAuthManager::isVerified() {
Q_D(KQOAuthManager);
return d->isVerified;
}
bool KQOAuthManager::isAuthorized() {
Q_D(KQOAuthManager);
return d->isAuthorized;
}
KQOAuthManager::KQOAuthError KQOAuthManager::lastError() {
Q_D(KQOAuthManager);
return d->error;
}
void KQOAuthManager::setNetworkManager(QNetworkAccessManager *manager) {
Q_D(KQOAuthManager);
if (manager == 0) {
d->error = KQOAuthManager::ManagerError;
return;
}
if (!d->managerUserSet) {
delete d->networkManager;
}
d->managerUserSet = true;
d->networkManager = manager;
}
QNetworkAccessManager * KQOAuthManager::networkManager() const {
Q_D(const KQOAuthManager);
if (d->managerUserSet) {
return d->networkManager;
} else {
return NULL;
}
}
//////////// Public convenience API /////////////
void KQOAuthManager::getUserAuthorization(QUrl authorizationEndpoint) {
Q_D(KQOAuthManager);
if (!d->hasTemporaryToken) {
qWarning() << "No temporary tokens retreieved. Cannot get user authorization.";
d->error = KQOAuthManager::RequestUnauthorized;
return;
}
if (!authorizationEndpoint.isValid()) {
qWarning() << "Authorization endpoint not valid. Cannot proceed.";
d->error = KQOAuthManager::RequestEndpointError;
return;
}
d->error = KQOAuthManager::NoError;
QPair