mirror/tomahawk
1
0
Fork 0
mirror of https://github.com/tomahawk-player/tomahawk.git synced 2025-09-02 10:24:01 +02:00
Code Issues Releases Wiki Activity

Remove our copy; will use git submodule

Browse Source
This commit is contained in:
Jeff Mitchell
2011-05-13 11:50:08 -04:00
parent 12d0dec63c
commit ade334dec1
203 changed files with 0 additions and 18559 deletions
Download Patch File Download Diff File Expand all files Collapse all files

459
thirdparty/qtweetlib/qtweetlib/LICENSE vendored
View File

@@ -1,459 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS

10
thirdparty/qtweetlib/qtweetlib/QTweetLib.pro vendored
View File

@@ -1,10 +0,0 @@
TEMPLATE = subdirs
SUBDIRS = sub_qjson sub_src sub_examples
sub_qjson.subdir = qjson
sub_src.subdir = src
sub_src.depends = sub_qjson
sub_examples.subdir = examples
sub_examples.depends = sub_src

12
thirdparty/qtweetlib/qtweetlib/README vendored
View File

@@ -1,12 +0,0 @@
- Supports only XAuth protocol (if there is need for PIN based OAuth I will include it)
- OAuth tokens must be set in oauth.cpp line 27 and 28 to work properly
- Uses QJson library by Flavio Castelli for parsing JSON responses
- JSON parsing is done in multithreaded way using QThreadPool
- User Streams support is not completed (fetches responses correctly, JSON parsing is not full implemented)
Requirements and dependencies:
- Qt needs to be compiled with OpenSSL support (there are two places where is used https protocol)
- You will also need xAuth privilege access to Twitter API ( see http://dev.twitter.com/pages/xauth )
- Valid OAuth consumer tokens, put them in oauth.cpp line 27 and 28
- If you have already access tokens ( see http://dev.twitter.com/pages/oauth_single_token ) put them directly
with OAuthTwitter::setOAuthToken() and OAuthTwitter::setOAuthTokenSecret()

3
thirdparty/qtweetlib/qtweetlib/examples/examples.pro vendored
View File

@@ -1,3 +0,0 @@
TEMPLATE = subdirs
SUBDIRS = search timelines statusupdate geosearch georeverse \
followers userstream

56
thirdparty/qtweetlib/qtweetlib/examples/followers/FollowerDelegate.qml vendored
View File

@@ -1,56 +0,0 @@
import Qt 4.7
Rectangle {
property string name: "Twitter name"
property string screenName: "Twitter screen name"
property string description: "Twitter description"
property string avatarUrl
width: ListView.view.width - 1;
height: 100
radius: 10
border.width: 1
border.color: "#000000"
Image {
id: avatar
anchors.top: parent.top
anchors.left: parent.left
width: 48; height: 48
anchors.leftMargin: 2
anchors.topMargin: 2
source: avatarUrl
}
Text {
id: screenNameText
text: screenName
anchors.leftMargin: 2
anchors.topMargin: 2
anchors.left: avatar.right
anchors.top: parent.top
}
Text {
id: nameText
text: name
anchors.leftMargin: 2
anchors.topMargin: 2
anchors.top: screenNameText.bottom
anchors.left: avatar.right
}
Text {
id: descriptionText
text: description
anchors.rightMargin: 2
anchors.leftMargin: 2
anchors.bottomMargin: 2
anchors.topMargin: 2
anchors.bottom: parent.bottom
anchors.top: avatar.bottom
anchors.left: parent.left
anchors.right: parent.right
wrapMode: "WordWrap"
}
}

19
thirdparty/qtweetlib/qtweetlib/examples/followers/FollowersList.qml vendored
View File

@@ -1,19 +0,0 @@
import Qt 4.7
//followersListModel - external
Item {
ListView {
id: followersListView
width: parent.width; height: parent.height
clip: true
model: followersListModel
delegate: FollowerDelegate {
id: followerDelegate
name: nameRole
screenName: screenNameRole
description: descriptionRole
avatarUrl: avatarRole
}
}
}

67
thirdparty/qtweetlib/qtweetlib/examples/followers/followers.cpp vendored
View File

@@ -1,67 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "followers.h"
#include "ui_followers.h"
#include <QDeclarativeContext>
#include <QNetworkAccessManager>
#include "followerslistmodel.h"
#include "oauthtwitter.h"
Followers::Followers(QWidget *parent) :
QWidget(parent),
ui(new Ui::Followers)
{
ui->setupUi(this);
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
m_oauthTwitter->setOAuthToken("");
m_oauthTwitter->setOAuthTokenSecret("");
m_followersListModel = new FollowersListModel(m_oauthTwitter, this);
ui->declarativeView->rootContext()->setContextProperty("followersListModel", m_followersListModel);
ui->declarativeView->setSource(QUrl("qrc:/FollowersList.qml"));
connect(ui->fetchFollowersPushButton, SIGNAL(clicked()), SLOT(onFetchFollowersPushButtonClicked()));
}
Followers::~Followers()
{
delete ui;
}
void Followers::changeEvent(QEvent *e)
{
QWidget::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void Followers::onFetchFollowersPushButtonClicked()
{
m_followersListModel->fetchFollowers();
}

53
thirdparty/qtweetlib/qtweetlib/examples/followers/followers.h vendored
View File

@@ -1,53 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef FOLLOWERS_H
#define FOLLOWERS_H
#include <QWidget>
class OAuthTwitter;
class FollowersListModel;
namespace Ui {
class Followers;
}
class Followers : public QWidget
{
Q_OBJECT
public:
explicit Followers(QWidget *parent = 0);
~Followers();
protected:
void changeEvent(QEvent *e);
private slots:
void onFetchFollowersPushButtonClicked();
private:
Ui::Followers *ui;
OAuthTwitter *m_oauthTwitter;
FollowersListModel *m_followersListModel;
};
#endif // FOLLOWERS_H

25
thirdparty/qtweetlib/qtweetlib/examples/followers/followers.pro vendored
View File

@@ -1,25 +0,0 @@
QT += core gui network declarative
TARGET = followers
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
SOURCES += \
main.cpp \
followers.cpp \
followerslistmodel.cpp
HEADERS += \
followers.h \
followerslistmodel.h
FORMS += \
followers.ui
OTHER_FILES += \
FollowerDelegate.qml \
FollowersList.qml
RESOURCES += \
followers.qrc

6
thirdparty/qtweetlib/qtweetlib/examples/followers/followers.qrc vendored
View File

@@ -1,6 +0,0 @@
<RCC>
<qresource prefix="/">
<file>FollowerDelegate.qml</file>
<file>FollowersList.qml</file>
</qresource>
</RCC>

42
thirdparty/qtweetlib/qtweetlib/examples/followers/followers.ui vendored
View File

@@ -1,42 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>Followers</class>
<widget class="QWidget" name="Followers">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>400</width>
<height>300</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QDeclarativeView" name="declarativeView">
<property name="resizeMode">
<enum>QDeclarativeView::SizeRootObjectToView</enum>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QPushButton" name="fetchFollowersPushButton">
<property name="text">
<string>Fetch Followers</string>
</property>
</widget>
</item>
</layout>
</widget>
<customwidgets>
<customwidget>
<class>QDeclarativeView</class>
<extends>QGraphicsView</extends>
<header>QtDeclarative/QDeclarativeView</header>
</customwidget>
</customwidgets>
<resources/>
<connections/>
</ui>

113
thirdparty/qtweetlib/qtweetlib/examples/followers/followerslistmodel.cpp vendored
View File

@@ -1,113 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "followerslistmodel.h"
#include "oauthtwitter.h"
#include "qtweetuser.h"
#include "qtweetuserstatusesfollowers.h"
FollowersListModel::FollowersListModel(QObject *parent) :
QAbstractListModel(parent)
{
QHash<int, QByteArray> roles;
roles[NameRole] = "nameRole";
roles[ScreenNameRole] = "screenNameRole";
roles[DescriptionRole] = "descriptionRole";
roles[AvatarRole] = "avatarRole";
setRoleNames(roles);
}
FollowersListModel::FollowersListModel(OAuthTwitter *oauthTwitter, QObject *parent) :
QAbstractListModel(parent)
{
QHash<int, QByteArray> roles;
roles[NameRole] = "nameRole";
roles[ScreenNameRole] = "screenNameRole";
roles[DescriptionRole] = "descriptionRole";
roles[AvatarRole] = "avatarRole";
setRoleNames(roles);
m_oauthTwitter = oauthTwitter;
}
void FollowersListModel::setOAuthTwitter(OAuthTwitter *oauthTwitter)
{
m_oauthTwitter = oauthTwitter;
}
int FollowersListModel::rowCount(const QModelIndex &parent) const
{
Q_UNUSED(parent);
return m_users.count();
}
QVariant FollowersListModel::data(const QModelIndex &index, int role) const
{
if (index.row() < 0 || index.row() > m_users.count())
return QVariant();
const QTweetUser &user = m_users.at(index.row());
if (role == NameRole)
return user.name();
else if (role == ScreenNameRole)
return user.screenName();
else if (role == DescriptionRole)
return user.description();
else if (role == AvatarRole)
return user.profileImageUrl();
return QVariant();
}
void FollowersListModel::fetchFollowers(const QString &cursor)
{
if (cursor == "-1") {
beginResetModel();
m_users.clear();
endResetModel();
}
QTweetUserStatusesFollowers *followers = new QTweetUserStatusesFollowers;
followers->setOAuthTwitter(m_oauthTwitter);
followers->fetch(0, cursor, false);
connect(followers, SIGNAL(parsedFollowersList(QList<QTweetUser>,QString)),
this, SLOT(followersFinished(QList<QTweetUser>,QString)));
}
void FollowersListModel::followersFinished(const QList<QTweetUser> &followers, const QString &nextCursor)
{
QTweetUserStatusesFollowers *users = qobject_cast<QTweetUserStatusesFollowers*>(sender());
if (users) {
beginInsertRows(QModelIndex(), m_users.count(), m_users.count() + followers.count());
m_users.append(followers);
endInsertRows();
if (nextCursor == "0")
return;
//continue fetchingg next page
fetchFollowers(nextCursor);
users->deleteLater();
}
}

56
thirdparty/qtweetlib/qtweetlib/examples/followers/followerslistmodel.h vendored
View File

@@ -1,56 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef FOLLOWERSLISTMODEL_H
#define FOLLOWERSLISTMODEL_H
#include <QAbstractListModel>
class OAuthTwitter;
class QTweetUser;
class FollowersListModel : public QAbstractListModel
{
Q_OBJECT
public:
enum Roles {
NameRole = Qt::UserRole + 1,
ScreenNameRole,
DescriptionRole,
AvatarRole
};
FollowersListModel(QObject *parent = 0);
FollowersListModel(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void setOAuthTwitter(OAuthTwitter *oauthTwitter);
int rowCount(const QModelIndex &parent) const;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const;
void fetchFollowers(const QString& cursor = QString("-1"));
private slots:
void followersFinished(const QList<QTweetUser>& followers,
const QString& nextCursor);
private:
OAuthTwitter *m_oauthTwitter;
QList<QTweetUser> m_users;
};
#endif // FOLLOWERSLISTMODEL_H

32
thirdparty/qtweetlib/qtweetlib/examples/followers/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "followers.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
Followers w;
w.show();
return a.exec();
}

106
thirdparty/qtweetlib/qtweetlib/examples/georeverse/georeverse.cpp vendored
View File

@@ -1,106 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QNetworkAccessManager>
#include "oauthtwitter.h"
#include "qtweetplace.h"
#include "qtweetgeocoord.h"
#include "qtweetgeoreversegeocode.h"
#include "georeverse.h"
#include "ui_georeverse.h"
GeoReverse::GeoReverse(QWidget *parent) :
QWidget(parent),
ui(new Ui::GeoReverse)
{
ui->setupUi(this);
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
m_oauthTwitter->setOAuthToken("");
m_oauthTwitter->setOAuthTokenSecret("");
QDoubleValidator *latValidator = new QDoubleValidator(ui->latitudeLineEdit);
latValidator->setNotation(QDoubleValidator::StandardNotation);
ui->latitudeLineEdit->setValidator(latValidator);
QDoubleValidator *longValidator = new QDoubleValidator(ui->longitudeLineEdit);
longValidator->setNotation(QDoubleValidator::StandardNotation);
ui->longitudeLineEdit->setValidator(longValidator);
connect(ui->searchPushButton, SIGNAL(clicked()), SLOT(onSearchPushButtonClicked()));
}
GeoReverse::~GeoReverse()
{
delete ui;
}
void GeoReverse::changeEvent(QEvent *e)
{
QWidget::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void GeoReverse::onSearchPushButtonClicked()
{
QTweetGeoReverseGeoCode *reverseGeo = new QTweetGeoReverseGeoCode(m_oauthTwitter, this);
reverseGeo->getPlaces(QTweetGeoCoord(ui->latitudeLineEdit->text().toDouble(),
ui->longitudeLineEdit->text().toDouble()));
connect(reverseGeo, SIGNAL(parsedPlaces(QList<QTweetPlace>)), SLOT(reverseGeoFinished(QList<QTweetPlace>)));
}
void GeoReverse::reverseGeoFinished(const QList<QTweetPlace> &places)
{
QTweetGeoReverseGeoCode *reverseGeo = qobject_cast<QTweetGeoReverseGeoCode*>(sender());
if (reverseGeo) {
ui->tableWidget->clear();
ui->tableWidget->setRowCount(places.count());
ui->tableWidget->setColumnCount(4);
int row = 0;
foreach (const QTweetPlace& place, places) {
QTableWidgetItem *fullname = new QTableWidgetItem(place.fullName());
ui->tableWidget->setItem(row, 0, fullname);
QTableWidgetItem *placeid = new QTableWidgetItem(place.id());
ui->tableWidget->setItem(row, 1, placeid);
//QGeoBoundingBox bb = place.boundingBox();
//QGeoCoordinate coord = bb.center();
//approximate, just shows center of the box
//QTableWidgetItem *lat = new QTableWidgetItem(QString::number(coord.latitude()));
//ui->tableWidget->setItem(row, 2, lat);
//QTableWidgetItem *longit = new QTableWidgetItem(QString::number(coord.longitude()));
//ui->tableWidget->setItem(row, 3, longit);
//++row;
}
reverseGeo->deleteLater();
}
}

54
thirdparty/qtweetlib/qtweetlib/examples/georeverse/georeverse.h vendored
View File

@@ -1,54 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef GEOREVERSE_H
#define GEOREVERSE_H
#include <QWidget>
namespace Ui {
class GeoReverse;
}
class OAuthTwitter;
class QTweetPlace;
class GeoReverse : public QWidget
{
Q_OBJECT
public:
explicit GeoReverse(QWidget *parent = 0);
~GeoReverse();
protected:
void changeEvent(QEvent *e);
private slots:
void onSearchPushButtonClicked();
void reverseGeoFinished(const QList<QTweetPlace>& places);
private:
Ui::GeoReverse *ui;
OAuthTwitter *m_oauthTwitter;
};
#endif // GEOREVERSE_H

18
thirdparty/qtweetlib/qtweetlib/examples/georeverse/georeverse.pro vendored
View File

@@ -1,18 +0,0 @@
QT += core gui network
TARGET = georeverse
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
CONFIG += mobility
MOBILITY += location
SOURCES += \
main.cpp \
georeverse.cpp
HEADERS += \
georeverse.h
FORMS += \
georeverse.ui

51
thirdparty/qtweetlib/qtweetlib/examples/georeverse/georeverse.ui vendored
View File

@@ -1,51 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>GeoReverse</class>
<widget class="QWidget" name="GeoReverse">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>598</width>
<height>506</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0" colspan="5">
<widget class="QTableWidget" name="tableWidget"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Latitude</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="latitudeLineEdit"/>
</item>
<item row="1" column="2">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Longitude</string>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QLineEdit" name="longitudeLineEdit"/>
</item>
<item row="1" column="4">
<widget class="QPushButton" name="searchPushButton">
<property name="text">
<string>Reverse geosearch</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

32
thirdparty/qtweetlib/qtweetlib/examples/georeverse/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "georeverse.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
GeoReverse w;
w.show();
return a.exec();
}

102
thirdparty/qtweetlib/qtweetlib/examples/geosearch/geosearch.cpp vendored
View File

@@ -1,102 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QNetworkAccessManager>
#include <QDoubleValidator>
#include "oauthtwitter.h"
#include "qtweetplace.h"
#include "qtweetgeosearch.h"
#include "geosearch.h"
#include "qtweetgeocoord.h"
#include "ui_geosearch.h"
GeoSearch::GeoSearch(QWidget *parent) :
QWidget(parent),
ui(new Ui::GeoSearch)
{
ui->setupUi(this);
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
m_oauthTwitter->setOAuthToken("");
m_oauthTwitter->setOAuthTokenSecret("");
QDoubleValidator *latValidator = new QDoubleValidator(ui->latitudeLineEdit);
latValidator->setNotation(QDoubleValidator::StandardNotation);
ui->latitudeLineEdit->setValidator(latValidator);
QDoubleValidator *longValidator = new QDoubleValidator(ui->longitudeLineEdit);
longValidator->setNotation(QDoubleValidator::StandardNotation);
ui->longitudeLineEdit->setValidator(longValidator);
connect(ui->searchPushButton, SIGNAL(clicked()), SLOT(onSearchPushButtonClicked()));
}
GeoSearch::~GeoSearch()
{
delete ui;
}
void GeoSearch::changeEvent(QEvent *e)
{
QWidget::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void GeoSearch::onSearchPushButtonClicked()
{
QTweetGeoSearch *geoSearch = new QTweetGeoSearch(m_oauthTwitter, this);
QTweetGeoCoord latLong;
latLong.setLatitude(ui->latitudeLineEdit->text().toDouble());
latLong.setLongitude(ui->longitudeLineEdit->text().toDouble());
geoSearch->search(latLong);
connect(geoSearch, SIGNAL(parsedPlaces(QList<QTweetPlace>)), SLOT(searchPlacesFinished(QList<QTweetPlace>)));
}
void GeoSearch::searchPlacesFinished(const QList<QTweetPlace> &places)
{
QTweetGeoSearch *geoSearch = qobject_cast<QTweetGeoSearch*>(sender());
if (geoSearch) {
ui->tableWidget->clear();
ui->tableWidget->setRowCount(places.count());
ui->tableWidget->setColumnCount(2);
int row = 0;
foreach (const QTweetPlace& place, places) {
QTableWidgetItem *fullname = new QTableWidgetItem(place.fullName());
ui->tableWidget->setItem(row, 0, fullname);
QTableWidgetItem *placeid = new QTableWidgetItem(place.id());
ui->tableWidget->setItem(row, 1, placeid);
++row;
}
geoSearch->deleteLater();
}
}

53
thirdparty/qtweetlib/qtweetlib/examples/geosearch/geosearch.h vendored
View File

@@ -1,53 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef GEOSEARCH_H
#define GEOSEARCH_H
#include <QWidget>
namespace Ui {
class GeoSearch;
}
class OAuthTwitter;
class QTweetPlace;
class GeoSearch : public QWidget
{
Q_OBJECT
public:
explicit GeoSearch(QWidget *parent = 0);
~GeoSearch();
protected:
void changeEvent(QEvent *e);
private slots:
void onSearchPushButtonClicked();
void searchPlacesFinished(const QList<QTweetPlace>& places);
private:
Ui::GeoSearch *ui;
OAuthTwitter *m_oauthTwitter;
};
#endif // GEOSEARCH_H

18
thirdparty/qtweetlib/qtweetlib/examples/geosearch/geosearch.pro vendored
View File

@@ -1,18 +0,0 @@
QT += core gui network
TARGET = geosearch
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
CONFIG += mobility
MOBILITY += location
SOURCES += \
main.cpp \
geosearch.cpp
HEADERS += \
geosearch.h
FORMS += \
geosearch.ui

55
thirdparty/qtweetlib/qtweetlib/examples/geosearch/geosearch.ui vendored
View File

@@ -1,55 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>GeoSearch</class>
<widget class="QWidget" name="GeoSearch">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>616</width>
<height>434</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0" colspan="5">
<widget class="QTableWidget" name="tableWidget">
<property name="alternatingRowColors">
<bool>true</bool>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Latitude</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="latitudeLineEdit"/>
</item>
<item row="1" column="2">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Longitude</string>
</property>
</widget>
</item>
<item row="1" column="3">
<widget class="QLineEdit" name="longitudeLineEdit"/>
</item>
<item row="1" column="4">
<widget class="QPushButton" name="searchPushButton">
<property name="text">
<string>Search</string>
</property>
</widget>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

32
thirdparty/qtweetlib/qtweetlib/examples/geosearch/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "geosearch.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
GeoSearch w;
w.show();
return a.exec();
}

31
thirdparty/qtweetlib/qtweetlib/examples/search/main.cpp vendored
View File

@@ -1,31 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "mainwindow.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}

100
thirdparty/qtweetlib/qtweetlib/examples/search/mainwindow.cpp vendored
View File

@@ -1,100 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QNetworkAccessManager>
#include <QDateTime>
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "oauthtwitter.h"
#include "qtweetsearch.h"
#include "qtweetsearchpageresults.h"
#include "qtweetsearchresult.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
connect(ui->startSearchButton, SIGNAL(clicked()), this, SLOT(searchButtonClicked()));
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::searchButtonClicked()
{
QTweetSearch *twitSearch = new QTweetSearch(m_oauthTwitter, m_oauthTwitter);
twitSearch->setAuthenticationEnabled(false);
twitSearch->start(ui->queryLineEdit->text());
connect(twitSearch, SIGNAL(parsedPageResults(QTweetSearchPageResults)),
this, SLOT(finishedSearch(QTweetSearchPageResults)));
}
void MainWindow::finishedSearch(const QTweetSearchPageResults &results)
{
QTweetSearch *twitSearch = qobject_cast<QTweetSearch*>(sender());
if (twitSearch) {
ui->resultsTextEdit->append("maxid: " + QString::number(results.maxid()));
ui->resultsTextEdit->append("next page: " + results.nextPage());
ui->resultsTextEdit->append("page: " + QString::number(results.page()));
ui->resultsTextEdit->append("query: " + results.query());
ui->resultsTextEdit->append("refresh url: " + results.refreshUrl());
ui->resultsTextEdit->append("rpp: " + QString::number(results.resultsPerPage()));
ui->resultsTextEdit->append("sinceid: " + QString::number(results.sinceid()));
ui->resultsTextEdit->append("total: " + QString::number(results.total()));
QList<QTweetSearchResult> listResults = results.results();
ui->resultsTextEdit->append("results: \n");
foreach (const QTweetSearchResult& singleResult, listResults) {
ui->resultsTextEdit->append("created: " + singleResult.createdAt().toString());
ui->resultsTextEdit->append("from user: " + singleResult.fromUser());
ui->resultsTextEdit->append("id: " + QString::number(singleResult.id()));
ui->resultsTextEdit->append("lang: " + singleResult.lang());
ui->resultsTextEdit->append("avatar url: " + singleResult.profileImageUrl());
ui->resultsTextEdit->append("source: " + singleResult.source());
ui->resultsTextEdit->append("text: " + singleResult.text());
ui->resultsTextEdit->append("to user: " + singleResult.toUser());
ui->resultsTextEdit->append("-------");
}
twitSearch->deleteLater();
}
}
void MainWindow::changeEvent(QEvent *e)
{
QMainWindow::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}

53
thirdparty/qtweetlib/qtweetlib/examples/search/mainwindow.h vendored
View File

@@ -1,53 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
class OAuthTwitter;
class QTweetSearchPageResults;
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
protected:
void changeEvent(QEvent *e);
private slots:
void searchButtonClicked();
void finishedSearch(const QTweetSearchPageResults& results);
private:
Ui::MainWindow *ui;
OAuthTwitter* m_oauthTwitter;
};
#endif // MAINWINDOW_H

64
thirdparty/qtweetlib/qtweetlib/examples/search/mainwindow.ui vendored
View File

@@ -1,64 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>621</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTextEdit" name="resultsTextEdit">
<property name="textInteractionFlags">
<set>Qt::LinksAccessibleByKeyboard|Qt::LinksAccessibleByMouse|Qt::TextBrowserInteraction|Qt::TextSelectableByKeyboard|Qt::TextSelectableByMouse</set>
</property>
</widget>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Query:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="queryLineEdit"/>
</item>
<item>
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item>
<widget class="QPushButton" name="startSearchButton">
<property name="text">
<string>Search</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
</widget>
<resources/>
<connections/>
</ui>

17
thirdparty/qtweetlib/qtweetlib/examples/search/search.pro vendored
View File

@@ -1,17 +0,0 @@
QT += core gui network
TARGET = searchexample
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
SOURCES +=\
mainwindow.cpp \
main.cpp
HEADERS += \
mainwindow.h
FORMS += \
mainwindow.ui

32
thirdparty/qtweetlib/qtweetlib/examples/statusupdate/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "mainwindow.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}

117
thirdparty/qtweetlib/qtweetlib/examples/statusupdate/mainwindow.cpp vendored
View File

@@ -1,117 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QNetworkAccessManager>
#include <QDoubleValidator>
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "oauthtwitter.h"
#include "qtweetstatusupdate.h"
#include "qtweetstatus.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
//m_authorized = false;
QDoubleValidator *latValidator = new QDoubleValidator(ui->latLineEdit);
latValidator->setNotation(QDoubleValidator::StandardNotation);
ui->latLineEdit->setValidator(latValidator);
QDoubleValidator *longValidator = new QDoubleValidator(ui->longLineEdit);
longValidator->setNotation(QDoubleValidator::StandardNotation);
ui->longLineEdit->setValidator(longValidator);
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
connect(m_oauthTwitter, SIGNAL(authorizeXAuthFinished()), SLOT(xauthFinished()));
connect(m_oauthTwitter, SIGNAL(authorizeXAuthError()), SLOT(xauthError()));
connect(ui->authPushButton, SIGNAL(clicked()), SLOT(authorizeButtonClicked()));
connect(ui->udpatePushButton, SIGNAL(clicked()), SLOT(updateButtonClicked()));
m_authorized = true;
m_oauthTwitter->setOAuthToken("16290455-CPyk9D9hJoCghpw7zAE73IZ0g0XtbVHU7xbI5RJE2");
m_oauthTwitter->setOAuthTokenSecret("NMCzZHio4YAB1ZrTsNP35HLHeN4Ze1GI3qT4zvMCctQ");
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::changeEvent(QEvent *e)
{
QMainWindow::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void MainWindow::authorizeButtonClicked()
{
m_oauthTwitter->authorizeXAuth(ui->userNameLineEdit->text(), ui->passwordLineEdit->text());
}
void MainWindow::xauthFinished()
{
ui->statusbar->showMessage("XAuth succesfull!");
m_authorized = true;
}
void MainWindow::xauthError()
{
ui->statusbar->showMessage("XAuth failed");
m_authorized = false;
}
void MainWindow::updateButtonClicked()
{
if (m_authorized) {
QTweetStatusUpdate *statusUpdate = new QTweetStatusUpdate(m_oauthTwitter, this);
statusUpdate->post(ui->statusTextEdit->toPlainText(),
0,
QTweetGeoCoord(ui->latLineEdit->text().toDouble(), ui->longLineEdit->text().toDouble()),
QString(),
true);
connect(statusUpdate, SIGNAL(postedStatus(QTweetStatus)), SLOT(postStatusFinished(QTweetStatus)));
} else {
ui->statusbar->showMessage("You cannot post, needs autorization!");
}
}
void MainWindow::postStatusFinished(const QTweetStatus &status)
{
QTweetStatusUpdate *statusUpdate = qobject_cast<QTweetStatusUpdate*>(sender());
if (statusUpdate) {
ui->statusbar->showMessage("Posted status with id " + QString::number(status.id()));
statusUpdate->deleteLater();
}
}

57
thirdparty/qtweetlib/qtweetlib/examples/statusupdate/mainwindow.h vendored
View File

@@ -1,57 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class OAuthTwitter;
class QTweetStatus;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
protected:
void changeEvent(QEvent *e);
private slots:
void authorizeButtonClicked();
void xauthFinished();
void xauthError();
void updateButtonClicked();
void postStatusFinished(const QTweetStatus& status);
private:
Ui::MainWindow *ui;
OAuthTwitter *m_oauthTwitter;
bool m_authorized;
};
#endif // MAINWINDOW_H

206
thirdparty/qtweetlib/qtweetlib/examples/statusupdate/mainwindow.ui vendored
View File

@@ -1,206 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>541</width>
<height>287</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout_2">
<item>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Username:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="userNameLineEdit"/>
</item>
</layout>
</item>
<item row="0" column="1">
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="1" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>Password:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="passwordLineEdit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</item>
<item row="1" column="1">
<widget class="QPushButton" name="authPushButton">
<property name="maximumSize">
<size>
<width>70</width>
<height>16777215</height>
</size>
</property>
<property name="text">
<string>Authorize</string>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<layout class="QHBoxLayout" name="horizontalLayout_3">
<item>
<widget class="QLabel" name="label_5">
<property name="text">
<string>Status text:</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<widget class="QPlainTextEdit" name="statusTextEdit">
<property name="maximumSize">
<size>
<width>16777215</width>
<height>128</height>
</size>
</property>
</widget>
</item>
</layout>
</item>
<item>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_4">
<item>
<widget class="QLabel" name="label_3">
<property name="text">
<string>Latitude:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="latLineEdit"/>
</item>
</layout>
</item>
<item row="0" column="1">
<spacer name="horizontalSpacer_4">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
<item row="1" column="0">
<layout class="QHBoxLayout" name="horizontalLayout_5">
<item>
<widget class="QLabel" name="label_4">
<property name="text">
<string>Longitude:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="longLineEdit"/>
</item>
</layout>
</item>
<item row="1" column="1">
<spacer name="horizontalSpacer_5">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_6">
<item>
<widget class="QPushButton" name="udpatePushButton">
<property name="text">
<string>Update</string>
</property>
</widget>
</item>
<item>
<spacer name="horizontalSpacer_3">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
</layout>
</widget>
<widget class="QStatusBar" name="statusbar"/>
</widget>
<resources/>
<connections/>
</ui>

16
thirdparty/qtweetlib/qtweetlib/examples/statusupdate/statusupdate.pro vendored
View File

@@ -1,16 +0,0 @@
QT += core gui network
TARGET = statusupdate
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
SOURCES += \
main.cpp \
mainwindow.cpp
HEADERS += \
mainwindow.h
FORMS += \
mainwindow.ui

32
thirdparty/qtweetlib/qtweetlib/examples/timelines/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "mainwindow.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.show();
return a.exec();
}

224
thirdparty/qtweetlib/qtweetlib/examples/timelines/mainwindow.cpp vendored
View File

@@ -1,224 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QNetworkAccessManager>
#include <QTimer>
#include <QDateTime>
#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "oauthtwitter.h"
#include "qtweethometimeline.h"
#include "qtweetmentions.h"
#include "qtweetusertimeline.h"
#include "qtweetdirectmessages.h"
#include "qtweetstatus.h"
#include "qtweetdmstatus.h"
#include "qtweetuser.h"
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
m_sinceidHomeTimeline = 0;
m_sinceidMentions = 0;
m_sinceidUserTimeline = 0;
m_sinceidDirectMessages = 0;
m_oauthTwitter = new OAuthTwitter(this);
m_oauthTwitter->setNetworkAccessManager(new QNetworkAccessManager(this));
connect(m_oauthTwitter, SIGNAL(authorizeXAuthFinished()), this, SLOT(xauthFinished()));
connect(m_oauthTwitter, SIGNAL(authorizeXAuthError()), this, SLOT(xauthError()));
m_timer = new QTimer(this);
m_timer->setInterval(60000);
connect(m_timer, SIGNAL(timeout()), this, SLOT(timerTimeOut()));
connect(ui->authorizePushButton, SIGNAL(clicked()), this, SLOT(authorizeButtonClicked()));
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::changeEvent(QEvent *e)
{
QMainWindow::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void MainWindow::authorizeButtonClicked()
{
m_oauthTwitter->authorizeXAuth(ui->usernameLineEdit->text(), ui->passwordLineEdit->text());
}
void MainWindow::xauthFinished()
{
ui->statusBar->showMessage("xauth succesfull");
m_timer->start();
timerTimeOut();
}
void MainWindow::xauthError()
{
ui->statusBar->showMessage("xauth failed");
}
void MainWindow::timerTimeOut()
{
QTweetHomeTimeline *homeTimeline = new QTweetHomeTimeline(m_oauthTwitter, this);
homeTimeline->fetch(m_sinceidHomeTimeline);
connect(homeTimeline, SIGNAL(parsedStatuses(QList<QTweetStatus>)),
this, SLOT(homeTimelineStatuses(QList<QTweetStatus>)));
QTweetMentions *mentions = new QTweetMentions(m_oauthTwitter, this);
mentions->fetch(m_sinceidMentions);
connect(mentions, SIGNAL(parsedStatuses(QList<QTweetStatus>)),
this, SLOT(mentionsStatuses(QList<QTweetStatus>)));
QTweetUserTimeline *userTimeline = new QTweetUserTimeline(m_oauthTwitter, this);
userTimeline->fetch(0, QString(), m_sinceidUserTimeline);
connect(userTimeline, SIGNAL(parsedStatuses(QList<QTweetStatus>)),
this, SLOT(userTimelineStatuses(QList<QTweetStatus>)));
QTweetDirectMessages *dmTimeline = new QTweetDirectMessages(m_oauthTwitter, this);
dmTimeline->fetch(m_sinceidDirectMessages);
connect(dmTimeline, SIGNAL(parsedDirectMessages(QList<QTweetDMStatus>)),
this, SLOT(directMessages(QList<QTweetDMStatus>)));
}
void MainWindow::homeTimelineStatuses(const QList<QTweetStatus> &statuses)
{
QTweetHomeTimeline *homeTimeline = qobject_cast<QTweetHomeTimeline*>(sender());
if (homeTimeline) {
if (statuses.count()) {
//order is messed up, but this is just example
foreach (const QTweetStatus& status, statuses) {
ui->homeTimelineTextEdit->append("id: " + QString::number(status.id()));
ui->homeTimelineTextEdit->append("text: " + status.text());
ui->homeTimelineTextEdit->append("created: " + status.createdAt().toString());
QTweetUser userinfo = status.user();
ui->homeTimelineTextEdit->append("screen name: " + userinfo.screenName());
ui->homeTimelineTextEdit->append("user id: " + QString::number(userinfo.id()));
//is it retweet?
QTweetStatus rtStatus = status.retweetedStatus();
if (rtStatus.id()) {
ui->homeTimelineTextEdit->append("retweet text: " + rtStatus.text());
}
ui->homeTimelineTextEdit->append("----------------------------------------");
}
m_sinceidHomeTimeline = statuses.at(0).id();
}
homeTimeline->deleteLater();
}
}
void MainWindow::mentionsStatuses(const QList<QTweetStatus> &statuses)
{
QTweetMentions *mentions = qobject_cast<QTweetMentions*>(sender());
if (mentions) {
if (statuses.count()) {
foreach (const QTweetStatus& status, statuses) {
ui->mentionsTextEdit->append("id: " + QString::number(status.id()));
ui->mentionsTextEdit->append("text: " + status.text());
ui->mentionsTextEdit->append("created: " + status.createdAt().toString());
QTweetUser userinfo = status.user();
ui->mentionsTextEdit->append("screen name: " + userinfo.screenName());
ui->mentionsTextEdit->append("user id: " + QString::number(userinfo.id()));
ui->mentionsTextEdit->append("----------------------------------------");
}
m_sinceidMentions = statuses.at(0).id();
}
mentions->deleteLater();
}
}
void MainWindow::userTimelineStatuses(const QList<QTweetStatus> &statuses)
{
QTweetUserTimeline *userTimeline = qobject_cast<QTweetUserTimeline*>(sender());
if (userTimeline) {
if (statuses.count()) {
//order is messed up, but this is just example
foreach (const QTweetStatus& status, statuses) {
ui->userTimelineTextEdit->append("id: " + QString::number(status.id()));
ui->userTimelineTextEdit->append("text: " + status.text());
ui->userTimelineTextEdit->append("created: " + status.createdAt().toString());
QTweetUser userinfo = status.user();
ui->userTimelineTextEdit->append("screen name: " + userinfo.screenName());
ui->userTimelineTextEdit->append("user id: " + QString::number(userinfo.id()));
ui->userTimelineTextEdit->append("----------------------------------------");
}
m_sinceidUserTimeline = statuses.at(0).id();
}
userTimeline->deleteLater();
}
}
void MainWindow::directMessages(const QList<QTweetDMStatus> &directMessages)
{
QTweetDirectMessages *dmTimeline = qobject_cast<QTweetDirectMessages*>(sender());
if (dmTimeline) {
if (directMessages.count()) {
foreach (const QTweetDMStatus& message, directMessages) {
ui->directMessagesTextEdit->append("id: " + QString::number(message.id()));
ui->directMessagesTextEdit->append("text: " + message.text());
ui->directMessagesTextEdit->append("created: " + message.createdAt().toString());
ui->directMessagesTextEdit->append("sender: " + message.senderScreenName());
ui->directMessagesTextEdit->append("sender id: " + QString::number(message.senderId()));
ui->directMessagesTextEdit->append("----------------------------------------");
}
m_sinceidDirectMessages = directMessages.at(0).id();
}
}
dmTimeline->deleteLater();
}

67
thirdparty/qtweetlib/qtweetlib/examples/timelines/mainwindow.h vendored
View File

@@ -1,67 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
namespace Ui {
class MainWindow;
}
class OAuthTwitter;
class QTimer;
class QTweetStatus;
class QTweetDMStatus;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
protected:
void changeEvent(QEvent *e);
private slots:
void authorizeButtonClicked();
void xauthFinished();
void xauthError();
void timerTimeOut();
void homeTimelineStatuses(const QList<QTweetStatus>& statuses);
void mentionsStatuses(const QList<QTweetStatus>& statuses);
void userTimelineStatuses(const QList<QTweetStatus>& statuses);
void directMessages(const QList<QTweetDMStatus>& directMessages);
private:
Ui::MainWindow *ui;
OAuthTwitter *m_oauthTwitter;
QTimer *m_timer;
qint64 m_sinceidHomeTimeline;
qint64 m_sinceidMentions;
qint64 m_sinceidUserTimeline;
qint64 m_sinceidDirectMessages;
};
#endif // MAINWINDOW_H

156
thirdparty/qtweetlib/qtweetlib/examples/timelines/mainwindow.ui vendored
View File

@@ -1,156 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>MainWindow</class>
<widget class="QMainWindow" name="MainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>627</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>MainWindow</string>
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QGridLayout" name="gridLayout_6">
<item row="0" column="0" colspan="2">
<widget class="QTabWidget" name="tabWidget">
<property name="currentIndex">
<number>0</number>
</property>
<widget class="QWidget" name="tab">
<attribute name="title">
<string> Home timeline</string>
</attribute>
<layout class="QGridLayout" name="gridLayout">
<item row="0" column="0">
<widget class="QTextEdit" name="homeTimelineTextEdit">
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_2">
<attribute name="title">
<string>Mentions timeline</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_2">
<item row="0" column="0">
<widget class="QTextEdit" name="mentionsTextEdit">
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_3">
<attribute name="title">
<string>User timeline</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_3">
<item row="0" column="0">
<widget class="QTextEdit" name="userTimelineTextEdit">
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
<widget class="QWidget" name="tab_4">
<attribute name="title">
<string>Direct Messages</string>
</attribute>
<layout class="QGridLayout" name="gridLayout_4">
<item row="0" column="0">
<widget class="QTextEdit" name="directMessagesTextEdit">
<property name="readOnly">
<bool>true</bool>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
</item>
<item row="1" column="0">
<layout class="QGridLayout" name="gridLayout_5">
<item row="0" column="0" colspan="2">
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<widget class="QLabel" name="label">
<property name="text">
<string>Username:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="usernameLineEdit"/>
</item>
</layout>
</item>
<item row="1" column="0" colspan="2">
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
<widget class="QLabel" name="label_2">
<property name="text">
<string>Password:</string>
</property>
</widget>
</item>
<item>
<widget class="QLineEdit" name="passwordLineEdit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</item>
<item row="2" column="0">
<widget class="QPushButton" name="authorizePushButton">
<property name="text">
<string>Authorize</string>
</property>
</widget>
</item>
<item row="2" column="1">
<spacer name="horizontalSpacer">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>40</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</item>
<item row="1" column="1">
<spacer name="horizontalSpacer_2">
<property name="orientation">
<enum>Qt::Horizontal</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>368</width>
<height>20</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<widget class="QStatusBar" name="statusBar"/>
</widget>
<resources/>
<connections/>
</ui>

16
thirdparty/qtweetlib/qtweetlib/examples/timelines/timelines.pro vendored
View File

@@ -1,16 +0,0 @@
QT += core gui network
TARGET = timelines
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
SOURCES += \
mainwindow.cpp \
main.cpp
HEADERS += \
mainwindow.h
FORMS += \
mainwindow.ui

32
thirdparty/qtweetlib/qtweetlib/examples/userstream/main.cpp vendored
View File

@@ -1,32 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtGui/QApplication>
#include "userstream.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
UserStream w;
w.show();
return a.exec();
}

110
thirdparty/qtweetlib/qtweetlib/examples/userstream/userstream.cpp vendored
View File

@@ -1,110 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "userstream.h"
#include "ui_userstream.h"
#include <QNetworkAccessManager>
#include <QTextStream>
#include <QFile>
#include "oauthtwitter.h"
#include "qtweetuserstream.h"
#include "qtweetstatus.h"
#include "qtweetuser.h"
UserStream::UserStream(QWidget *parent) :
QWidget(parent),
ui(new Ui::UserStream)
{
ui->setupUi(this);
m_oauthTwitter = new OAuthTwitter(new QNetworkAccessManager, this);
connect(m_oauthTwitter, SIGNAL(authorizeXAuthFinished()), SLOT(onAuthorizeFinished()));
connect(m_oauthTwitter, SIGNAL(authorizeXAuthError()), SLOT(onAuthorizeError()));
m_userStream = new QTweetUserStream(this);
m_userStream->setOAuthTwitter(m_oauthTwitter);
connect(m_userStream, SIGNAL(stream(QByteArray)), SLOT(stream(QByteArray)));
connect(m_userStream, SIGNAL(statusesStream(QTweetStatus)), SLOT(statusStream(QTweetStatus)));
connect(ui->connectButton, SIGNAL(clicked()), SLOT(onConnectButtonClicked()));
//for internal purposes
m_file.setFileName("logstream.txt");
m_file.open(QIODevice::WriteOnly | QIODevice::Text);
m_streamlogger.setDevice(&m_file);
}
UserStream::~UserStream()
{
delete ui;
}
void UserStream::changeEvent(QEvent *e)
{
QWidget::changeEvent(e);
switch (e->type()) {
case QEvent::LanguageChange:
ui->retranslateUi(this);
break;
default:
break;
}
}
void UserStream::onConnectButtonClicked()
{
m_oauthTwitter->authorizeXAuth(ui->usernameLineEdit->text(), ui->passwordLineEdit->text());
ui->infoTextBrowser->append("XAuth authorization started");
ui->connectButton->setEnabled(false);
}
void UserStream::onAuthorizeFinished()
{
ui->infoTextBrowser->append("XAuth authorization success.");
ui->infoTextBrowser->append("oauth token: " + m_oauthTwitter->oauthToken());
ui->infoTextBrowser->append("oauth token secret: " + m_oauthTwitter->oauthTokenSecret());
ui->infoTextBrowser->append("Starting user stream fetching");
m_userStream->startFetching();
}
void UserStream::onAuthorizeError()
{
ui->infoTextBrowser->append("XAuth authorization error");
ui->connectButton->setEnabled(true);
}
void UserStream::stream(const QByteArray &stream)
{
//for internal purposes
m_streamlogger << stream << "\n";
m_streamlogger << "################################################################" << "\n";
m_streamlogger.flush();
}
void UserStream::statusStream(const QTweetStatus &tweet)
{
ui->infoTextBrowser->append("New tweet");
ui->infoTextBrowser->append("id: " + QString::number(tweet.id()));
ui->infoTextBrowser->append("text: " + tweet.text());
ui->infoTextBrowser->append("name: " + tweet.user().name());
}

62
thirdparty/qtweetlib/qtweetlib/examples/userstream/userstream.h vendored
View File

@@ -1,62 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef USERSTREAM_H
#define USERSTREAM_H
#include <QWidget>
#include <QTextStream>
#include <QFile>
namespace Ui {
class UserStream;
}
class OAuthTwitter;
class QTweetUserStream;
class QTweetStatus;
class UserStream : public QWidget
{
Q_OBJECT
public:
explicit UserStream(QWidget *parent = 0);
~UserStream();
protected:
void changeEvent(QEvent *e);
private slots:
void onConnectButtonClicked();
void onAuthorizeFinished();
void onAuthorizeError();
void stream(const QByteArray& stream);
void statusStream(const QTweetStatus& tweet);
private:
Ui::UserStream *ui;
OAuthTwitter *m_oauthTwitter;
QTweetUserStream *m_userStream;
QTextStream m_streamlogger;
QFile m_file;
};
#endif // USERSTREAM_H

17
thirdparty/qtweetlib/qtweetlib/examples/userstream/userstream.pro vendored
View File

@@ -1,17 +0,0 @@
QT += core gui network
TARGET = userstream
TEMPLATE = app
win32:LIBS += ../../lib/QTweetLib.lib
INCLUDEPATH += ../../src
SOURCES += \
main.cpp \
userstream.cpp
HEADERS += \
userstream.h
FORMS += \
userstream.ui

63
thirdparty/qtweetlib/qtweetlib/examples/userstream/userstream.ui vendored
View File

@@ -1,63 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>UserStream</class>
<widget class="QWidget" name="UserStream">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>418</width>
<height>529</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTextBrowser" name="infoTextBrowser"/>
</item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout">
<item>
<layout class="QFormLayout" name="formLayout">
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>Username:</string>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QLineEdit" name="usernameLineEdit"/>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>Password:</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QLineEdit" name="passwordLineEdit">
<property name="echoMode">
<enum>QLineEdit::Password</enum>
</property>
</widget>
</item>
</layout>
</item>
<item>
<widget class="QPushButton" name="connectButton">
<property name="text">
<string>Connect</string>
</property>
</widget>
</item>
</layout>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>

1116
thirdparty/qtweetlib/qtweetlib/qjson/json_parser.cc vendored
View File

File diff suppressed because it is too large Load Diff

325
thirdparty/qtweetlib/qtweetlib/qjson/json_parser.hh vendored
View File

@@ -1,325 +0,0 @@
/* A Bison parser, made by GNU Bison 2.3. */
/* Skeleton interface for Bison LALR(1) parsers in C++
Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/* C++ LALR(1) parser skeleton written by Akim Demaille. */
#ifndef PARSER_HEADER_H
# define PARSER_HEADER_H
#include <string>
#include <iostream>
#include "stack.hh"
namespace yy
{
class position;
class location;
}
/* First part of user declarations. */
#line 25 "json_parser.yy"
#include "parser_p.h"
#include "json_scanner.h"
#include "qjson_debug.h"
#include <QtCore/QByteArray>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QVariant>
#include <limits>
class JSonScanner;
namespace QJson {
class Parser;
}
#define YYERROR_VERBOSE 1
/* Line 35 of lalr1.cc. */
#line 75 "json_parser.hh"
#include "location.hh"
/* Enabling traces. */
#ifndef YYDEBUG
# define YYDEBUG 1
#endif
/* Enabling verbose error messages. */
#ifdef YYERROR_VERBOSE
# undef YYERROR_VERBOSE
# define YYERROR_VERBOSE 1
#else
# define YYERROR_VERBOSE 1
#endif
/* Enabling the token table. */
#ifndef YYTOKEN_TABLE
# define YYTOKEN_TABLE 0
#endif
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
If N is 0, then set CURRENT to the empty location which ends
the previous symbol: RHS[0] (always defined). */
#ifndef YYLLOC_DEFAULT
# define YYLLOC_DEFAULT(Current, Rhs, N) \
do { \
if (N) \
{ \
(Current).begin = (Rhs)[1].begin; \
(Current).end = (Rhs)[N].end; \
} \
else \
{ \
(Current).begin = (Current).end = (Rhs)[0].end; \
} \
} while (false)
#endif
namespace yy
{
/// A Bison parser.
class json_parser
{
public:
/// Symbol semantic values.
#ifndef YYSTYPE
typedef int semantic_type;
#else
typedef YYSTYPE semantic_type;
#endif
/// Symbol locations.
typedef location location_type;
/// Tokens.
struct token
{
/* Tokens. */
enum yytokentype {
END = 0,
CURLY_BRACKET_OPEN = 1,
CURLY_BRACKET_CLOSE = 2,
SQUARE_BRACKET_OPEN = 3,
SQUARE_BRACKET_CLOSE = 4,
COLON = 5,
COMMA = 6,
MINUS = 7,
DOT = 8,
DIGIT = 9,
E = 10,
TRUE_VAL = 11,
FALSE_VAL = 12,
NULL_VAL = 13,
QUOTMARKOPEN = 14,
QUOTMARKCLOSE = 15,
STRING = 16,
INFINITY_VAL = 17,
NAN_VAL = 18
};
};
/// Token type.
typedef token::yytokentype token_type;
/// Build a parser object.
json_parser (QJson::ParserPrivate* driver_yyarg);
virtual ~json_parser ();
/// Parse.
/// \returns 0 iff parsing succeeded.
virtual int parse ();
/// The current debugging stream.
std::ostream& debug_stream () const;
/// Set the current debugging stream.
void set_debug_stream (std::ostream &);
/// Type for debugging levels.
typedef int debug_level_type;
/// The current debugging level.
debug_level_type debug_level () const;
/// Set the current debugging level.
void set_debug_level (debug_level_type l);
private:
/// Report a syntax error.
/// \param loc where the syntax error is found.
/// \param msg a description of the syntax error.
virtual void error (const location_type& loc, const std::string& msg);
/// Generate an error message.
/// \param state the state where the error occurred.
/// \param tok the look-ahead token.
virtual std::string yysyntax_error_ (int yystate, int tok);
#if YYDEBUG
/// \brief Report a symbol value on the debug stream.
/// \param yytype The token type.
/// \param yyvaluep Its semantic value.
/// \param yylocationp Its location.
virtual void yy_symbol_value_print_ (int yytype,
const semantic_type* yyvaluep,
const location_type* yylocationp);
/// \brief Report a symbol on the debug stream.
/// \param yytype The token type.
/// \param yyvaluep Its semantic value.
/// \param yylocationp Its location.
virtual void yy_symbol_print_ (int yytype,
const semantic_type* yyvaluep,
const location_type* yylocationp);
#endif /* ! YYDEBUG */
/// State numbers.
typedef int state_type;
/// State stack type.
typedef stack<state_type> state_stack_type;
/// Semantic value stack type.
typedef stack<semantic_type> semantic_stack_type;
/// location stack type.
typedef stack<location_type> location_stack_type;
/// The state stack.
state_stack_type yystate_stack_;
/// The semantic value stack.
semantic_stack_type yysemantic_stack_;
/// The location stack.
location_stack_type yylocation_stack_;
/// Internal symbol numbers.
typedef unsigned char token_number_type;
/* Tables. */
/// For a state, the index in \a yytable_ of its portion.
static const signed char yypact_[];
static const signed char yypact_ninf_;
/// For a state, default rule to reduce.
/// Unless\a yytable_ specifies something else to do.
/// Zero means the default is an error.
static const unsigned char yydefact_[];
static const signed char yypgoto_[];
static const signed char yydefgoto_[];
/// What to do in a state.
/// \a yytable_[yypact_[s]]: what to do in state \a s.
/// - if positive, shift that token.
/// - if negative, reduce the rule which number is the opposite.
/// - if zero, do what YYDEFACT says.
static const unsigned char yytable_[];
static const signed char yytable_ninf_;
static const signed char yycheck_[];
/// For a state, its accessing symbol.
static const unsigned char yystos_[];
/// For a rule, its LHS.
static const unsigned char yyr1_[];
/// For a rule, its RHS length.
static const unsigned char yyr2_[];
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/// For a symbol, its name in clear.
static const char* const yytname_[];
#endif
#if YYERROR_VERBOSE
/// Convert the symbol name \a n to a form suitable for a diagnostic.
virtual std::string yytnamerr_ (const char *n);
#endif
#if YYDEBUG
/// A type to store symbol numbers and -1.
typedef signed char rhs_number_type;
/// A `-1'-separated list of the rules' RHS.
static const rhs_number_type yyrhs_[];
/// For each rule, the index of the first RHS symbol in \a yyrhs_.
static const unsigned char yyprhs_[];
/// For each rule, its source line number.
static const unsigned char yyrline_[];
/// For each scanner token number, its symbol number.
static const unsigned short int yytoken_number_[];
/// Report on the debug stream that the rule \a r is going to be reduced.
virtual void yy_reduce_print_ (int r);
/// Print the state stack on the debug stream.
virtual void yystack_print_ ();
#endif
/// Convert a scanner token number \a t to a symbol number.
token_number_type yytranslate_ (int t);
/// \brief Reclaim the memory associated to a symbol.
/// \param yymsg Why this token is reclaimed.
/// \param yytype The symbol type.
/// \param yyvaluep Its semantic value.
/// \param yylocationp Its location.
inline void yydestruct_ (const char* yymsg,
int yytype,
semantic_type* yyvaluep,
location_type* yylocationp);
/// Pop \a n symbols the three stacks.
inline void yypop_ (unsigned int n = 1);
/* Constants. */
static const int yyeof_;
/* LAST_ -- Last index in TABLE_. */
static const int yylast_;
static const int yynnts_;
static const int yyempty_;
static const int yyfinal_;
static const int yyterror_;
static const int yyerrcode_;
static const int yyntokens_;
static const unsigned int yyuser_token_number_max_;
static const token_number_type yyundef_token_;
/* Debugging. */
int yydebug_;
std::ostream* yycdebug_;
/* User arguments. */
QJson::ParserPrivate* driver;
};
}
#endif /* ! defined PARSER_HEADER_H */

219
thirdparty/qtweetlib/qtweetlib/qjson/json_parser.yy vendored
View File

@@ -1,219 +0,0 @@
/* This file is part of QJSon
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
%skeleton "lalr1.cc"
%defines
%define "parser_class_name" "json_parser"
%{
#include "parser_p.h"
#include "json_scanner.h"
#include "qjson_debug.h"
#include <QtCore/QByteArray>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QVariant>
#include <limits>
class JSonScanner;
namespace QJson {
class Parser;
}
#define YYERROR_VERBOSE 1
%}
%parse-param { QJson::ParserPrivate* driver }
%lex-param { QJson::ParserPrivate* driver }
%locations
%debug
%error-verbose
%token END 0 "end of file"
%token CURLY_BRACKET_OPEN 1 "{"
%token CURLY_BRACKET_CLOSE 2 "}"
%token SQUARE_BRACKET_OPEN 3 "["
%token SQUARE_BRACKET_CLOSE 4 "]"
%token COLON 5 ":"
%token COMMA 6 ","
%token MINUS 7 "-"
%token DOT 8 "."
%token DIGIT 9 "digit"
%token E 10 "exponential"
%token TRUE_VAL 11 "true"
%token FALSE_VAL 12 "false"
%token NULL_VAL 13 "null"
%token QUOTMARKOPEN 14 "open quotation mark"
%token QUOTMARKCLOSE 15 "close quotation mark"
%token STRING 16 "string"
%token INFINITY_VAL 17 "Infinity"
%token NAN_VAL 18 "NaN"
// define the initial token
%start start
%%
// grammar rules
start: data {
driver->m_result = $1;
qjsonDebug() << "json_parser - parsing finished";
};
data: value { $$ = $1; }
| error
{
qCritical()<< "json_parser - syntax error found, "
<< "forcing abort, Line" << @$.begin.line << "Column" << @$.begin.column;
YYABORT;
}
| END;
object: CURLY_BRACKET_OPEN members CURLY_BRACKET_CLOSE { $$ = $2; };
members: /* empty */ { $$ = QVariant (QVariantMap()); }
| pair r_members {
QVariantMap members = $2.toMap();
$2 = QVariant(); // Allow reuse of map
$$ = QVariant(members.unite ($1.toMap()));
};
r_members: /* empty */ { $$ = QVariant (QVariantMap()); }
| COMMA pair r_members {
QVariantMap members = $3.toMap();
$3 = QVariant(); // Allow reuse of map
$$ = QVariant(members.unite ($2.toMap()));
};
pair: string COLON value {
QVariantMap pair;
pair.insert ($1.toString(), QVariant($3));
$$ = QVariant (pair);
};
array: SQUARE_BRACKET_OPEN values SQUARE_BRACKET_CLOSE { $$ = $2; };
values: /* empty */ { $$ = QVariant (QVariantList()); }
| value r_values {
QVariantList members = $2.toList();
$2 = QVariant(); // Allow reuse of list
members.prepend ($1);
$$ = QVariant(members);
};
r_values: /* empty */ { $$ = QVariant (QVariantList()); }
| COMMA value r_values {
QVariantList members = $3.toList();
$3 = QVariant(); // Allow reuse of list
members.prepend ($2);
$$ = QVariant(members);
};
value: string { $$ = $1; }
| special_or_number { $$ = $1; }
| object { $$ = $1; }
| array { $$ = $1; }
| TRUE_VAL { $$ = QVariant (true); }
| FALSE_VAL { $$ = QVariant (false); }
| NULL_VAL {
QVariant null_variant;
$$ = null_variant;
};
special_or_number: MINUS INFINITY_VAL { $$ = QVariant(QVariant::Double); $$.setValue( -std::numeric_limits<double>::infinity() ); }
| INFINITY_VAL { $$ = QVariant(QVariant::Double); $$.setValue( std::numeric_limits<double>::infinity() ); }
| NAN_VAL { $$ = QVariant(QVariant::Double); $$.setValue( std::numeric_limits<double>::quiet_NaN() ); }
| number;
number: int {
if ($1.toByteArray().startsWith('-')) {
$$ = QVariant (QVariant::LongLong);
$$.setValue($1.toLongLong());
}
else {
$$ = QVariant (QVariant::ULongLong);
$$.setValue($1.toULongLong());
}
}
| int fract {
const QByteArray value = $1.toByteArray() + $2.toByteArray();
$$ = QVariant(QVariant::Double);
$$.setValue(value.toDouble());
}
| int exp { $$ = QVariant ($1.toByteArray() + $2.toByteArray()); }
| int fract exp {
const QByteArray value = $1.toByteArray() + $2.toByteArray() + $3.toByteArray();
$$ = QVariant (value);
};
int: DIGIT digits { $$ = QVariant ($1.toByteArray() + $2.toByteArray()); }
| MINUS DIGIT digits { $$ = QVariant (QByteArray("-") + $2.toByteArray() + $3.toByteArray()); };
digits: /* empty */ { $$ = QVariant (QByteArray("")); }
| DIGIT digits {
$$ = QVariant($1.toByteArray() + $2.toByteArray());
};
fract: DOT digits {
$$ = QVariant(QByteArray(".") + $2.toByteArray());
};
exp: E digits { $$ = QVariant($1.toByteArray() + $2.toByteArray()); };
string: QUOTMARKOPEN string_arg QUOTMARKCLOSE { $$ = $2; };
string_arg: /*empty */ { $$ = QVariant (QString(QLatin1String(""))); }
| STRING {
$$ = $1;
};
%%
int yy::yylex(YYSTYPE *yylval, yy::location *yylloc, QJson::ParserPrivate* driver)
{
JSonScanner* scanner = driver->m_scanner;
yylval->clear();
int ret = scanner->yylex(yylval, yylloc);
qjsonDebug() << "json_parser::yylex - calling scanner yylval==|"
<< yylval->toByteArray() << "|, ret==|" << QString::number(ret) << "|";
return ret;
}
void yy::json_parser::error (const yy::location& yyloc,
const std::string& error)
{
/*qjsonDebug() << yyloc.begin.line;
qjsonDebug() << yyloc.begin.column;
qjsonDebug() << yyloc.end.line;
qjsonDebug() << yyloc.end.column;*/
qjsonDebug() << "json_parser::error [line" << yyloc.end.line << "] -" << error.c_str() ;
driver->setError(QString::fromLatin1(error.c_str()), yyloc.end.line);
}

377
thirdparty/qtweetlib/qtweetlib/qjson/json_scanner.cpp vendored
View File

@@ -1,377 +0,0 @@
/* This file is part of QJson
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "qjson_debug.h"
#include "json_scanner.h"
#include "json_parser.hh"
#include <ctype.h>
#include <QtCore/QDebug>
#include <QtCore/QRegExp>
#include <cassert>
bool ishexnstring(const QString& string) {
for (int i = 0; i < string.length(); i++) {
if (isxdigit(string[i] == 0))
return false;
}
return true;
}
JSonScanner::JSonScanner(QIODevice* io)
: m_allowSpecialNumbers(false),
m_io (io)
{
m_quotmarkClosed = true;
m_quotmarkCount = 0;
}
void JSonScanner::allowSpecialNumbers(bool allow) {
m_allowSpecialNumbers = allow;
}
static QString unescape( const QByteArray& ba, bool* ok ) {
assert( ok );
*ok = false;
QString res;
QByteArray seg;
bool bs = false;
for ( int i = 0, size = ba.size(); i < size; ++i ) {
const char ch = ba[i];
if ( !bs ) {
if ( ch == '\\' )
bs = true;
else
seg += ch;
} else {
bs = false;
switch ( ch ) {
case 'b':
seg += '\b';
break;
case 'f':
seg += '\f';
break;
case 'n':
seg += '\n';
break;
case 'r':
seg += '\r';
break;
case 't':
seg += '\t';
break;
case 'u':
{
res += QString::fromUtf8( seg );
seg.clear();
if ( i > size - 5 ) {
//error
return QString();
}
const QString hex_digit1 = QString::fromUtf8( ba.mid( i + 1, 2 ) );
const QString hex_digit2 = QString::fromUtf8( ba.mid( i + 3, 2 ) );
i += 4;
if ( !ishexnstring( hex_digit1 ) || !ishexnstring( hex_digit2 ) ) {
qCritical() << "Not an hex string:" << hex_digit1 << hex_digit2;
return QString();
}
bool hexOk;
const ushort hex_code1 = hex_digit1.toShort( &hexOk, 16 );
if (!hexOk) {
qCritical() << "error converting hex value to short:" << hex_digit1;
return QString();
}
const ushort hex_code2 = hex_digit2.toShort( &hexOk, 16 );
if (!hexOk) {
qCritical() << "error converting hex value to short:" << hex_digit2;
return QString();
}
res += QChar(hex_code2, hex_code1);
break;
}
case '\\':
seg += '\\';
break;
default:
seg += ch;
break;
}
}
}
res += QString::fromUtf8( seg );
*ok = true;
return res;
}
int JSonScanner::yylex(YYSTYPE* yylval, yy::location *yylloc)
{
char ch;
if (!m_io->isOpen()) {
qCritical() << "JSonScanner::yylex - io device is not open";
return -1;
}
yylloc->step();
do {
bool ret;
if (m_io->atEnd()) {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::END";
return yy::json_parser::token::END;
}
else
ret = m_io->getChar(&ch);
if (!ret) {
qCritical() << "JSonScanner::yylex - error reading from io device";
return -1;
}
qjsonDebug() << "JSonScanner::yylex - got |" << ch << "|";
yylloc->columns();
if (ch == '\n' || ch == '\r')
yylloc->lines();
} while (m_quotmarkClosed && (isspace(ch) != 0));
if (m_quotmarkClosed && ((ch == 't') || (ch == 'T'))) {
const QByteArray buf = m_io->peek(3).toLower();
if (buf == "rue") {
m_io->read (3);
yylloc->columns(3);
qjsonDebug() << "JSonScanner::yylex - TRUE_VAL";
return yy::json_parser::token::TRUE_VAL;
}
}
else if (m_quotmarkClosed && ((ch == 'n') || (ch == 'N'))) {
const QByteArray buf = m_io->peek(3).toLower();
if (buf == "ull") {
m_io->read (3);
yylloc->columns(3);
qjsonDebug() << "JSonScanner::yylex - NULL_VAL";
return yy::json_parser::token::NULL_VAL;
} else if (buf.startsWith("an") && m_allowSpecialNumbers) {
m_io->read(2);
yylloc->columns(2);
qjsonDebug() << "JSonScanner::yylex - NAN_VAL";
return yy::json_parser::token::NAN_VAL;
}
}
else if (m_quotmarkClosed && ((ch == 'f') || (ch == 'F'))) {
// check false value
const QByteArray buf = m_io->peek(4).toLower();
if (buf.length() == 4) {
if (buf == "alse") {
m_io->read (4);
yylloc->columns(4);
qjsonDebug() << "JSonScanner::yylex - FALSE_VAL";
return yy::json_parser::token::FALSE_VAL;
}
}
}
else if (m_quotmarkClosed && ((ch == 'e') || (ch == 'E'))) {
QByteArray ret(1, ch);
const QByteArray buf = m_io->peek(1);
if (!buf.isEmpty()) {
if ((buf[0] == '+' ) || (buf[0] == '-' )) {
ret += m_io->read (1);
yylloc->columns();
}
}
*yylval = QVariant(QString::fromUtf8(ret));
return yy::json_parser::token::E;
}
else if (m_allowSpecialNumbers && m_quotmarkClosed && ((ch == 'I') || (ch == 'i'))) {
QByteArray ret(1, ch);
const QByteArray buf = m_io->peek(7);
if (buf == "nfinity") {
m_io->read(7);
yylloc->columns(7);
qjsonDebug() << "JSonScanner::yylex - INFINITY_VAL";
return yy::json_parser::token::INFINITY_VAL;
}
}
if (ch != '"' && !m_quotmarkClosed) {
// we're inside a " " block
QByteArray raw;
raw += ch;
char prevCh = ch;
bool escape_on = (ch == '\\') ? true : false;
while ( true ) {
char nextCh;
qint64 ret = m_io->peek(&nextCh, 1);
if (ret != 1) {
if (m_io->atEnd())
return yy::json_parser::token::END;
else
return -1;
} else if ( !escape_on && nextCh == '\"' ) {
bool ok;
const QString str = unescape( raw, &ok );
*yylval = ok ? str : QString();
return ok ? yy::json_parser::token::STRING : -1;
}
#if 0
if ( prevCh == '\\' && nextCh != '"' && nextCh != '\\' && nextCh != '/' &&
nextCh != 'b' && nextCh != 'f' && nextCh != 'n' &&
nextCh != 'r' && nextCh != 't' && nextCh != 'u') {
qjsonDebug() << "Just read" << nextCh;
qjsonDebug() << "JSonScanner::yylex - error decoding escaped sequence";
return -1;
}
#endif
m_io->read(1); // consume
raw += nextCh;
prevCh = nextCh;
if (escape_on)
escape_on = false;
else
escape_on = (prevCh == '\\') ? true : false;
#if 0
if (nextCh == '\\') {
char buf;
if (m_io->getChar (&buf)) {
yylloc->columns();
if (((buf != '"') && (buf != '\\') && (buf != '/') &&
(buf != 'b') && (buf != 'f') && (buf != 'n') &&
(buf != 'r') && (buf != 't') && (buf != 'u'))) {
qjsonDebug() << "Just read" << buf;
qjsonDebug() << "JSonScanner::yylex - error decoding escaped sequence";
return -1;
}
} else {
qCritical() << "JSonScanner::yylex - error decoding escaped sequence : io error";
return -1;
}
}
#endif
}
}
else if (isdigit(ch) != 0 && m_quotmarkClosed) {
bool ok;
QByteArray numArray = QByteArray::fromRawData( &ch, 1 * sizeof(char) );
qulonglong number = numArray.toULongLong(&ok);
if (!ok) {
//This shouldn't happen
qCritical() << "JSonScanner::yylex - error while converting char to ulonglong, returning -1";
return -1;
}
if (number == 0) {
// we have to return immediately otherwise numbers like
// 2.04 will be converted to 2.4
*yylval = QVariant(number);
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DIGIT";
return yy::json_parser::token::DIGIT;
}
char nextCh;
qint64 ret = m_io->peek(&nextCh, 1);
while (ret == 1 && isdigit(nextCh)) {
m_io->read(1); //consume
yylloc->columns(1);
numArray = QByteArray::fromRawData( &nextCh, 1 * sizeof(char) );
number = number * 10 + numArray.toULongLong(&ok);
if (!ok) {
//This shouldn't happen
qCritical() << "JSonScanner::yylex - error while converting char to ulonglong, returning -1";
return -1;
}
ret = m_io->peek(&nextCh, 1);
}
*yylval = QVariant(number);
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DIGIT";
return yy::json_parser::token::DIGIT;
}
else if (isalnum(ch) != 0) {
*yylval = QVariant(QString(QChar::fromLatin1(ch)));
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::WORD ("
<< ch << ")";
return yy::json_parser::token::STRING;
}
else if (ch == ':') {
// set yylval
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::COLON";
return yy::json_parser::token::COLON;
}
else if (ch == '"') {
// yy::json_parser::token::QUOTMARK (")
// set yylval
m_quotmarkCount++;
if (m_quotmarkCount %2 == 0) {
m_quotmarkClosed = true;
m_quotmarkCount = 0;
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::QUOTMARKCLOSE";
return yy::json_parser::token::QUOTMARKCLOSE;
}
else {
m_quotmarkClosed = false;
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::QUOTMARKOPEN";
return yy::json_parser::token::QUOTMARKOPEN;
}
}
else if (ch == ',') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::COMMA";
return yy::json_parser::token::COMMA;
}
else if (ch == '.') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::DOT";
return yy::json_parser::token::DOT;
}
else if (ch == '-') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::MINUS";
return yy::json_parser::token::MINUS;
}
else if (ch == '[') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::SQUARE_BRACKET_OPEN";
return yy::json_parser::token::SQUARE_BRACKET_OPEN;
}
else if (ch == ']') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::SQUARE_BRACKET_CLOSE";
return yy::json_parser::token::SQUARE_BRACKET_CLOSE;
}
else if (ch == '{') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::CURLY_BRACKET_OPEN";
return yy::json_parser::token::CURLY_BRACKET_OPEN;
}
else if (ch == '}') {
qjsonDebug() << "JSonScanner::yylex - yy::json_parser::token::CURLY_BRACKET_CLOSE";
return yy::json_parser::token::CURLY_BRACKET_CLOSE;
}
//unknown char!
//TODO yyerror?
qCritical() << "JSonScanner::yylex - unknown char, returning -1";
return -1;
}

54
thirdparty/qtweetlib/qtweetlib/qjson/json_scanner.h vendored
View File

@@ -1,54 +0,0 @@
/* This file is part of QJson
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef _JSON_SCANNER
#define _JSON_SCANNER
#include <fstream>
#include <string>
#include <QtCore/QIODevice>
#include <QtCore/QVariant>
#define YYSTYPE QVariant
#include "parser_p.h"
namespace yy {
class location;
int yylex(YYSTYPE *yylval, yy::location *yylloc, QJson::ParserPrivate* driver);
}
class JSonScanner
{
public:
explicit JSonScanner(QIODevice* io);
int yylex(YYSTYPE* yylval, yy::location *yylloc);
void allowSpecialNumbers(bool allow);
protected:
bool m_quotmarkClosed;
bool m_allowSpecialNumbers;
unsigned int m_quotmarkCount;
QIODevice* m_io;
};
#endif

145
thirdparty/qtweetlib/qtweetlib/qjson/location.hh vendored
View File

@@ -1,145 +0,0 @@
/* A Bison parser, made by GNU Bison 2.3. */
/* Locations for Bison parsers in C++
Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/**
** \file location.hh
** Define the yy::location class.
*/
#ifndef BISON_LOCATION_HH
# define BISON_LOCATION_HH
# include <iostream>
# include <string>
# include "position.hh"
namespace yy
{
/// Abstract a location.
class location
{
public:
/// Construct a location.
location ()
: begin (), end ()
{
}
/// Initialization.
inline void initialize (std::string* fn)
{
begin.initialize (fn);
end = begin;
}
/** \name Line and Column related manipulators
** \{ */
public:
/// Reset initial location to final location.
inline void step ()
{
begin = end;
}
/// Extend the current location to the COUNT next columns.
inline void columns (unsigned int count = 1)
{
end += count;
}
/// Extend the current location to the COUNT next lines.
inline void lines (unsigned int count = 1)
{
end.lines (count);
}
/** \} */
public:
/// Beginning of the located region.
position begin;
/// End of the located region.
position end;
};
/// Join two location objects to create a location.
inline const location operator+ (const location& begin, const location& end)
{
location res = begin;
res.end = end.end;
return res;
}
/// Add two location objects.
inline const location operator+ (const location& begin, unsigned int width)
{
location res = begin;
res.columns (width);
return res;
}
/// Add and assign a location.
inline location& operator+= (location& res, unsigned int width)
{
res.columns (width);
return res;
}
/** \brief Intercept output stream redirection.
** \param ostr the destination output stream
** \param loc a reference to the location to redirect
**
** Avoid duplicate information.
*/
inline std::ostream& operator<< (std::ostream& ostr, const location& loc)
{
position last = loc.end - 1;
ostr << loc.begin;
if (last.filename
&& (!loc.begin.filename
|| *loc.begin.filename != *last.filename))
ostr << '-' << last;
else if (loc.begin.line != last.line)
ostr << '-' << last.line << '.' << last.column;
else if (loc.begin.column != last.column)
ostr << '-' << last.column;
return ostr;
}
}
#endif // not BISON_LOCATION_HH

124
thirdparty/qtweetlib/qtweetlib/qjson/parser.cpp vendored
View File

@@ -1,124 +0,0 @@
/* This file is part of QJson
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "parser.h"
#include "parser_p.h"
#include "json_parser.hh"
#include "json_scanner.h"
#include <QtCore/QBuffer>
#include <QtCore/QStringList>
#include <QtCore/QTextStream>
#include <QtCore/QDebug>
using namespace QJson;
ParserPrivate::ParserPrivate() :
m_scanner(0)
, m_negate(false)
, m_error(false)
, m_specialNumbersAllowed(false)
{
}
ParserPrivate::~ParserPrivate()
{
delete m_scanner;
}
void ParserPrivate::setError(QString errorMsg, int errorLine) {
m_error = true;
m_errorMsg = errorMsg;
m_errorLine = errorLine;
}
Parser::Parser() :
d(new ParserPrivate)
{
}
Parser::~Parser()
{
delete d;
}
QVariant Parser::parse (QIODevice* io, bool* ok)
{
d->m_errorMsg.clear();
delete d->m_scanner;
d->m_scanner = 0;
if (!io->isOpen()) {
if (!io->open(QIODevice::ReadOnly)) {
if (ok != 0)
*ok = false;
qCritical ("Error opening device");
return QVariant();
}
}
if (!io->isReadable()) {
if (ok != 0)
*ok = false;
qCritical ("Device is not readable");
io->close();
return QVariant();
}
d->m_scanner = new JSonScanner (io);
d->m_scanner->allowSpecialNumbers(d->m_specialNumbersAllowed);
yy::json_parser parser(d);
parser.parse();
delete d->m_scanner;
d->m_scanner = 0;
if (ok != 0)
*ok = !d->m_error;
io->close();
return d->m_result;
}
QVariant Parser::parse(const QByteArray& jsonString, bool* ok) {
QBuffer buffer;
buffer.open(QBuffer::ReadWrite);
buffer.write(jsonString);
buffer.seek(0);
return parse (&buffer, ok);
}
QString Parser::errorString() const
{
return d->m_errorMsg;
}
int Parser::errorLine() const
{
return d->m_errorLine;
}
void QJson::Parser::allowSpecialNumbers(bool allowSpecialNumbers) {
d->m_specialNumbersAllowed = allowSpecialNumbers;
}
bool Parser::specialNumbersAllowed() const {
return d->m_specialNumbersAllowed;
}

94
thirdparty/qtweetlib/qtweetlib/qjson/parser.h vendored
View File

@@ -1,94 +0,0 @@
/* This file is part of QJson
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef QJSON_PARSER_H
#define QJSON_PARSER_H
#include "qjson_export.h"
class QIODevice;
class QVariant;
namespace QJson {
class ParserPrivate;
/**
* @brief Main class used to convert JSON data to QVariant objects
*/
class QJSON_EXPORT Parser
{
public:
Parser();
~Parser();
/**
* Read JSON string from the I/O Device and converts it to a QVariant object
* @param io Input output device
* @param ok if a conversion error occurs, *ok is set to false; otherwise *ok is set to true.
* @returns a QVariant object generated from the JSON string
*/
QVariant parse(QIODevice* io, bool* ok = 0);
/**
* This is a method provided for convenience.
* @param jsonData data containing the JSON object representation
* @param ok if a conversion error occurs, *ok is set to false; otherwise *ok is set to true.
* @returns a QVariant object generated from the JSON string
* @sa errorString
* @sa errorLine
*/
QVariant parse(const QByteArray& jsonData, bool* ok = 0);
/**
* This method returns the error message
* @returns a QString object containing the error message of the last parse operation
* @sa errorLine
*/
QString errorString() const;
/**
* This method returns line number where the error occurred
* @returns the line number where the error occurred
* @sa errorString
*/
int errorLine() const;
/**
* Sets whether special numbers (Infinity, -Infinity, NaN) are allowed as an extension to
* the standard
* @param allowSpecialNumbers new value of whether special numbers are allowed
* @sa specialNumbersAllowed
*/
void allowSpecialNumbers(bool allowSpecialNumbers);
/**
* @returns whether special numbers (Infinity, -Infinity, NaN) are allowed
* @sa allowSpecialNumbers
*/
bool specialNumbersAllowed() const;
private:
Q_DISABLE_COPY(Parser)
ParserPrivate* const d;
};
}
#endif // QJSON_PARSER_H

56
thirdparty/qtweetlib/qtweetlib/qjson/parser_p.h vendored
View File

@@ -1,56 +0,0 @@
/* This file is part of QJson
*
* Copyright (C) 2008 Flavio Castelli <flavio.castelli@gmail.com>
* Copyright (C) 2009 Michael Leupold <lemma@confuego.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef QJSON_PARSER_P_H
#define QJSON_PARSER_P_H
#include "parser.h"
#include <QtCore/QString>
#include <QtCore/QVariant>
class JSonScanner;
namespace yy {
class json_parser;
}
namespace QJson {
class ParserPrivate
{
public:
ParserPrivate();
~ParserPrivate();
void setError(QString errorMsg, int line);
JSonScanner* m_scanner;
bool m_negate;
bool m_error;
int m_errorLine;
QString m_errorMsg;
QVariant m_result;
bool m_specialNumbersAllowed;
};
}
#endif // QJSON_PARSER_H

68
thirdparty/qtweetlib/qtweetlib/qjson/parserrunnable.cpp vendored
View File

@@ -1,68 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "parserrunnable.h"
#include "parser.h"
#include <QtCore/QDebug>
#include <QtCore/QVariant>
using namespace QJson;
class QJson::ParserRunnable::Private
{
public:
QByteArray m_data;
};
ParserRunnable::ParserRunnable(QObject* parent)
: QObject(parent),
QRunnable(),
d(new Private)
{
qRegisterMetaType<QVariant>("QVariant");
}
ParserRunnable::~ParserRunnable()
{
delete d;
}
void ParserRunnable::setData( const QByteArray& data ) {
d->m_data = data;
}
void ParserRunnable::run()
{
qDebug() << Q_FUNC_INFO;
bool ok;
Parser parser;
QVariant result = parser.parse (d->m_data, &ok);
if (ok) {
qDebug() << "successfully converted json item to QVariant object";
emit parsingFinished(result, true, QString());
} else {
const QString errorText = tr("An error occured while parsing json: %1").arg(parser.errorString());
qCritical() << errorText;
emit parsingFinished(QVariant(), false, errorText);
}
}

67
thirdparty/qtweetlib/qtweetlib/qjson/parserrunnable.h vendored
View File

@@ -1,67 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef PARSERRUNNABLE_H
#define PARSERRUNNABLE_H
#include "qjson_export.h"
#include <QtCore/QObject>
#include <QtCore/QRunnable>
class QVariant;
namespace QJson {
/**
* @brief Convenience class for converting JSON data to QVariant objects using a dedicated thread
*/
class QJSON_EXPORT ParserRunnable : public QObject, public QRunnable
{
Q_OBJECT
public:
/**
* This signal is emitted when the conversion process has been completed
* @param data contains the JSON data that has to be converted
* @param parent parent of the object
**/
explicit ParserRunnable(QObject* parent = 0);
~ParserRunnable();
void setData( const QByteArray& data );
void run();
Q_SIGNALS:
/**
* This signal is emitted when the parsing process has been completed
* @param json contains the result of the parsing
* @param ok if a parsing error occurs ok is set to false, otherwise it's set to true.
* @param error_msg contains a string explaining the failure reason
**/
void parsingFinished(const QVariant& json, bool ok, const QString& error_msg);
private:
Q_DISABLE_COPY(ParserRunnable)
class Private;
Private* const d;
};
}
#endif // PARSERRUNNABLE_H

142
thirdparty/qtweetlib/qtweetlib/qjson/position.hh vendored
View File

@@ -1,142 +0,0 @@
/* A Bison parser, made by GNU Bison 2.3. */
/* Positions for Bison parsers in C++
Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
/**
** \file position.hh
** Define the yy::position class.
*/
#ifndef BISON_POSITION_HH
# define BISON_POSITION_HH
# include <iostream>
# include <string>
namespace yy
{
/// Abstract a position.
class position
{
public:
/// Construct a position.
position ()
: filename (0), line (1), column (0)
{
}
/// Initialization.
inline void initialize (std::string* fn)
{
filename = fn;
line = 1;
column = 0;
}
/** \name Line and Column related manipulators
** \{ */
public:
/// (line related) Advance to the COUNT next lines.
inline void lines (int count = 1)
{
column = 0;
line += count;
}
/// (column related) Advance to the COUNT next columns.
inline void columns (int count = 1)
{
int leftmost = 0;
int current = column;
if (leftmost <= current + count)
column += count;
else
column = 0;
}
/** \} */
public:
/// File name to which this position refers.
std::string* filename;
/// Current line number.
unsigned int line;
/// Current column number.
unsigned int column;
};
/// Add and assign a position.
inline const position&
operator+= (position& res, const int width)
{
res.columns (width);
return res;
}
/// Add two position objects.
inline const position
operator+ (const position& begin, const int width)
{
position res = begin;
return res += width;
}
/// Add and assign a position.
inline const position&
operator-= (position& res, const int width)
{
return res += -width;
}
/// Add two position objects.
inline const position
operator- (const position& begin, const int width)
{
return begin + -width;
}
/** \brief Intercept output stream redirection.
** \param ostr the destination output stream
** \param pos a reference to the position to redirect
*/
inline std::ostream&
operator<< (std::ostream& ostr, const position& pos)
{
if (pos.filename)
ostr << *pos.filename << ':';
return ostr << pos.line << '.' << pos.column;
}
}
#endif // not BISON_POSITION_HH

34
thirdparty/qtweetlib/qtweetlib/qjson/qjson.pro vendored
View File

@@ -1,34 +0,0 @@
TEMPLATE = lib
QT -= gui
TARGET = qjson
DESTDIR = ../lib
CONFIG += create_prl
windows: {
DEFINES += QJSON_MAKEDLL
}
HEADERS += \
stack.hh \
serializerrunnable.h \
serializer.h \
qobjecthelper.h \
qjson_export.h \
qjson_debug.h \
position.hh \
parserrunnable.h \
parser_p.h \
parser.h \
location.hh \
json_scanner.h \
json_parser.hh \
SOURCES += \
serializerrunnable.cpp \
serializer.cpp \
qobjecthelper.cpp \
parserrunnable.cpp \
parser.cpp \
json_scanner.cpp \
json_parser.cc \

33
thirdparty/qtweetlib/qtweetlib/qjson/qjson_debug.h vendored
View File

@@ -1,33 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Michael Leupold <lemma@confuego.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef QJSON_DEBUG_H
#define QJSON_DEBUG_H
#include <QtCore/QDebug>
// define qjsonDebug()
#ifdef QJSON_VERBOSE_DEBUG_OUTPUT
inline QDebug qjsonDebug() { return QDebug(QtDebugMsg); }
#else
inline QNoDebug qjsonDebug() { return QNoDebug(); }
#endif
#endif

35
thirdparty/qtweetlib/qtweetlib/qjson/qjson_export.h vendored
View File

@@ -1,35 +0,0 @@
/* This file is part of the KDE project
Copyright (C) 2009 Pino Toscano <pino@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef QJSON_EXPORT_H
#define QJSON_EXPORT_H
#include <QtCore/qglobal.h>
#ifndef QJSON_EXPORT
# if defined(QJSON_MAKEDLL)
/* We are building this library */
# define QJSON_EXPORT Q_DECL_EXPORT
# else
/* We are using this library */
# define QJSON_EXPORT Q_DECL_IMPORT
# endif
#endif
#endif

84
thirdparty/qtweetlib/qtweetlib/qjson/qobjecthelper.cpp vendored
View File

@@ -1,84 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Till Adam <adam@kde.org>
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "qobjecthelper.h"
#include <QtCore/QMetaObject>
#include <QtCore/QMetaProperty>
#include <QtCore/QObject>
using namespace QJson;
class QObjectHelper::QObjectHelperPrivate {
};
QObjectHelper::QObjectHelper()
: d (new QObjectHelperPrivate)
{
}
QObjectHelper::~QObjectHelper()
{
delete d;
}
QVariantMap QObjectHelper::qobject2qvariant( const QObject* object,
const QStringList& ignoredProperties)
{
QVariantMap result;
const QMetaObject *metaobject = object->metaObject();
int count = metaobject->propertyCount();
for (int i=0; i<count; ++i) {
QMetaProperty metaproperty = metaobject->property(i);
const char *name = metaproperty.name();
if (ignoredProperties.contains(QLatin1String(name)) || (!metaproperty.isReadable()))
continue;
QVariant value = object->property(name);
result[QLatin1String(name)] = value;
}
return result;
}
void QObjectHelper::qvariant2qobject(const QVariantMap& variant, QObject* object)
{
const QMetaObject *metaobject = object->metaObject();
QVariantMap::const_iterator iter;
for (iter = variant.constBegin(); iter != variant.constEnd(); iter++) {
int pIdx = metaobject->indexOfProperty( iter.key().toAscii() );
if ( pIdx < 0 ) {
continue;
}
QMetaProperty metaproperty = metaobject->property( pIdx );
QVariant::Type type = metaproperty.type();
QVariant v( iter.value() );
if ( v.canConvert( type ) ) {
v.convert( type );
metaproperty.write( object, v );
}
}
}

143
thirdparty/qtweetlib/qtweetlib/qjson/qobjecthelper.h vendored
View File

@@ -1,143 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef QOBJECTHELPER_H
#define QOBJECTHELPER_H
#include "qjson_export.h"
#include <QtCore/QLatin1String>
#include <QtCore/QStringList>
#include <QtCore/QVariantMap>
class QObject;
namespace QJson {
/**
* @brief Class used to convert QObject into QVariant and vivce-versa.
* During these operations only the class attributes defined as properties will
* be considered.
*
* Suppose the declaration of the Person class looks like this:
* \code
* class Person : public QObject
{
Q_OBJECT
Q_PROPERTY(QString name READ name WRITE setName)
Q_PROPERTY(int phoneNumber READ phoneNumber WRITE setPhoneNumber)
Q_PROPERTY(Gender gender READ gender WRITE setGender)
Q_PROPERTY(QDate dob READ dob WRITE setDob)
Q_ENUMS(Gender)
public:
Person(QObject* parent = 0);
~Person();
QString name() const;
void setName(const QString& name);
int phoneNumber() const;
void setPhoneNumber(const int phoneNumber);
enum Gender {Male, Female};
void setGender(Gender gender);
Gender gender() const;
QDate dob() const;
void setDob(const QDate& dob);
private:
QString m_name;
int m_phoneNumber;
Gender m_gender;
QDate m_dob;
};
\endcode
The following code will serialize an instance of Person to JSON :
\code
Person person;
person.setName("Flavio");
person.setPhoneNumber(123456);
person.setGender(Person::Male);
person.setDob(QDate(1982, 7, 12));
QVariantMap variant = QObjectHelper::qobject2qvariant(&person);
Serializer serializer;
qDebug() << serializer.serialize( variant);
\endcode
The generated output will be:
\code
{ "dob" : "1982-07-12", "gender" : 0, "name" : "Flavio", "phoneNumber" : 123456 }
\endcode
It's also possible to initialize a QObject using the values stored inside of
a QVariantMap.
Suppose you have the following JSON data stored into a QString:
\code
{ "dob" : "1982-07-12", "gender" : 0, "name" : "Flavio", "phoneNumber" : 123456 }
\endcode
The following code will initialize an already allocated instance of Person
using the JSON values:
\code
Parser parser;
QVariant variant = parser.parse(json);
Person person;
QObjectHelper::qvariant2qobject(variant.toMap(), &person);
\endcode
\sa Parser
\sa Serializer
*/
class QJSON_EXPORT QObjectHelper {
public:
QObjectHelper();
~QObjectHelper();
/**
* This method converts a QObject instance into a QVariantMap.
*
* @param object The QObject instance to be converted.
* @param ignoredProperties Properties that won't be converted.
*/
static QVariantMap qobject2qvariant( const QObject* object,
const QStringList& ignoredProperties = QStringList(QString(QLatin1String("objectName"))));
/**
* This method converts a QVariantMap instance into a QObject
*
* @param object The QObject instance to be converted.
*/
static void qvariant2qobject(const QVariantMap& variant, QObject* object);
private:
Q_DISABLE_COPY(QObjectHelper)
class QObjectHelperPrivate;
QObjectHelperPrivate* const d;
};
}
#endif // QOBJECTHELPER_H

220
thirdparty/qtweetlib/qtweetlib/qjson/serializer.cpp vendored
View File

@@ -1,220 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Till Adam <adam@kde.org>
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "serializer.h"
#include <QtCore/QDataStream>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <cmath>
#include <float.h>
using namespace QJson;
class Serializer::SerializerPrivate {
public:
SerializerPrivate() : specialNumbersAllowed(false) {}
bool specialNumbersAllowed;
QString sanitizeString( QString str );
};
QString Serializer::SerializerPrivate::sanitizeString( QString str )
{
str.replace( QLatin1String( "\\" ), QLatin1String( "\\\\" ) );
// escape unicode chars
QString result;
const ushort* unicode = str.utf16();
unsigned int i = 0;
while ( unicode[ i ] ) {
if ( unicode[ i ] < 128 ) {
result.append( QChar( unicode[ i ] ) );
}
else {
QString hexCode = QString::number( unicode[ i ], 16 ).rightJustified( 4,
QLatin1Char('0') );
result.append( QLatin1String ("\\u") ).append( hexCode );
}
++i;
}
str = result;
str.replace( QLatin1String( "\"" ), QLatin1String( "\\\"" ) );
str.replace( QLatin1String( "\b" ), QLatin1String( "\\b" ) );
str.replace( QLatin1String( "\f" ), QLatin1String( "\\f" ) );
str.replace( QLatin1String( "\n" ), QLatin1String( "\\n" ) );
str.replace( QLatin1String( "\r" ), QLatin1String( "\\r" ) );
str.replace( QLatin1String( "\t" ), QLatin1String( "\\t" ) );
return QString( QLatin1String( "\"%1\"" ) ).arg( str );
}
Serializer::Serializer()
: d( new SerializerPrivate )
{
}
Serializer::~Serializer() {
delete d;
}
void Serializer::serialize( const QVariant& v, QIODevice* io, bool* ok )
{
Q_ASSERT( io );
if (!io->isOpen()) {
if (!io->open(QIODevice::WriteOnly)) {
if ( ok != 0 )
*ok = false;
qCritical ("Error opening device");
return;
}
}
if (!io->isWritable()) {
if (ok != 0)
*ok = false;
qCritical ("Device is not readable");
io->close();
return;
}
const QByteArray str = serialize( v );
if ( !str.isNull() ) {
QDataStream stream( io );
stream << str;
} else {
if ( ok )
*ok = false;
}
}
static QByteArray join( const QList<QByteArray>& list, const QByteArray& sep ) {
QByteArray res;
Q_FOREACH( const QByteArray& i, list ) {
if ( !res.isEmpty() )
res += sep;
res += i;
}
return res;
}
QByteArray Serializer::serialize( const QVariant &v )
{
QByteArray str;
bool error = false;
if ( ! v.isValid() ) { // invalid or null?
str = "null";
} else if (( v.type() == QVariant::List ) || ( v.type() == QVariant::StringList )){ // an array or a stringlist?
const QVariantList list = v.toList();
QList<QByteArray> values;
Q_FOREACH( const QVariant& v, list )
{
QByteArray serializedValue = serialize( v );
if ( serializedValue.isNull() ) {
error = true;
break;
}
values << serializedValue;
}
str = "[ " + join( values, ", " ) + " ]";
} else if ( v.type() == QVariant::Map ) { // variant is a map?
const QVariantMap vmap = v.toMap();
QMapIterator<QString, QVariant> it( vmap );
str = "{ ";
QList<QByteArray> pairs;
while ( it.hasNext() ) {
it.next();
QByteArray serializedValue = serialize( it.value() );
if ( serializedValue.isNull() ) {
error = true;
break;
}
pairs << d->sanitizeString( it.key() ).toUtf8() + " : " + serializedValue;
}
str += join( pairs, ", " );
str += " }";
} else if (( v.type() == QVariant::String ) || ( v.type() == QVariant::ByteArray )) { // a string or a byte array?
str = d->sanitizeString( v.toString() ).toUtf8();
} else if (( v.type() == QVariant::Double) || (v.type() == QMetaType::Float)) { // a double or a float?
const double value = v.toDouble();
#ifdef _WIN32
const bool special = _isnan(value) || !_finite(value);
#elif defined(Q_OS_SYMBIAN)
const bool special = isnan(value) || isinf(value);
#else
const bool special = std::isnan(value) || std::isinf(value);
#endif
if (special) {
if (specialNumbersAllowed()) {
#ifdef _WIN32
if (_isnan(value)) {
#elif defined(Q_OS_SYMBIAN)
if (isnan(value)) {
#else
if (std::isnan(value)) {
#endif
str += "NaN";
} else {
if (value<0) {
str += "-";
}
str += "Infinity";
}
} else {
qCritical("Attempt to write NaN or infinity, which is not supported by json");
error = true;
}
} else {
str = QByteArray::number( value );
if( ! str.contains( "." ) && ! str.contains( "e" ) ) {
str += ".0";
}
}
} else if ( v.type() == QVariant::Bool ) { // boolean value?
str = ( v.toBool() ? "true" : "false" );
} else if ( v.type() == QVariant::ULongLong ) { // large unsigned number?
str = QByteArray::number( v.value<qulonglong>() );
} else if ( v.canConvert<qlonglong>() ) { // any signed number?
str = QByteArray::number( v.value<qlonglong>() );
} else if ( v.canConvert<QString>() ){ // can value be converted to string?
// this will catch QDate, QDateTime, QUrl, ...
str = d->sanitizeString( v.toString() ).toUtf8();
//TODO: catch other values like QImage, QRect, ...
} else {
error = true;
}
if ( !error )
return str;
else
return QByteArray();
}
void QJson::Serializer::allowSpecialNumbers(bool allow) {
d->specialNumbersAllowed = allow;
}
bool QJson::Serializer::specialNumbersAllowed() const {
return d->specialNumbersAllowed;
}

81
thirdparty/qtweetlib/qtweetlib/qjson/serializer.h vendored
View File

@@ -1,81 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Till Adam <adam@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef QJSON_SERIALIZER_H
#define QJSON_SERIALIZER_H
#include "qjson_export.h"
class QIODevice;
class QString;
class QVariant;
namespace QJson {
/**
* @brief Main class used to convert QVariant objects to JSON data.
*
* QVariant objects are converted to a string containing the JSON data.
* If QVariant object is empty or not valid a <em>null</em> json object is returned.
*/
class QJSON_EXPORT Serializer {
public:
Serializer();
~Serializer();
/**
* This method generates a textual JSON representation and outputs it to the
* passed in I/O Device.
* @param variant The JSON document in its in-memory representation as generated by the
* parser.
* @param out Input output device
* @param ok if a conversion error occurs, *ok is set to false; otherwise *ok is set to true
*/
void serialize( const QVariant& variant, QIODevice* out, bool* ok = 0 );
/**
* This is a method provided for convenience. It turns the passed in in-memory
* representation of the JSON document into a textual one, which is returned.
* If the returned string is empty, the document was empty. If it was null, there
* was a parsing error.
*
* @param variant The JSON document in its in-memory representation as generated by the
* parser.
*/
QByteArray serialize( const QVariant& variant );
/**
* Allow or disallow writing of NaN and/or Infinity (as an extension to QJson)
*/
void allowSpecialNumbers(bool allow);
/**
* Is Nan and/or Infinity allowed?
*/
bool specialNumbersAllowed() const;
private:
Q_DISABLE_COPY(Serializer)
class SerializerPrivate;
SerializerPrivate* const d;
};
}
#endif // QJSON_SERIALIZER_H

60
thirdparty/qtweetlib/qtweetlib/qjson/serializerrunnable.cpp vendored
View File

@@ -1,60 +0,0 @@
#include "serializerrunnable.h"
/* This file is part of qjson
*
* Copyright (C) 2009 Flavio Castelli <flavio@castelli.name>
* 2009 Frank Osterfeld <osterfeld@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "parserrunnable.h"
#include "serializer.h"
#include <QtCore/QDebug>
#include <QtCore/QVariant>
using namespace QJson;
class SerializerRunnable::Private
{
public:
QVariant json;
};
SerializerRunnable::SerializerRunnable(QObject* parent)
: QObject(parent),
QRunnable(),
d(new Private)
{
qRegisterMetaType<QVariant>("QVariant");
}
SerializerRunnable::~SerializerRunnable()
{
delete d;
}
void SerializerRunnable::setJsonObject( const QVariant& json )
{
d->json = json;
}
void SerializerRunnable::run()
{
Serializer serializer;
emit parsingFinished( Serializer().serialize( d->json ), true, QString() );
}

74
thirdparty/qtweetlib/qtweetlib/qjson/serializerrunnable.h vendored
View File

@@ -1,74 +0,0 @@
/* This file is part of qjson
*
* Copyright (C) 2009 Frank Osterfeld <osterfeld@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef SERIALIZERRUNNABLE_H
#define SERIALIZERRUNNABLE_H
#include "qjson_export.h"
#include <QtCore/QObject>
#include <QtCore/QRunnable>
class QByteArray;
class QString;
class QVariant;
namespace QJson {
/**
* @brief Convenience class for converting JSON data to QVariant objects using a dedicated thread
*/
class QJSON_EXPORT SerializerRunnable : public QObject, public QRunnable
{
Q_OBJECT
public:
/**
* This signal is emitted when the conversion process has been completed
* @param data contains the JSON data that has to be converted
* @param parent parent of the object
**/
explicit SerializerRunnable(QObject* parent = 0);
~SerializerRunnable();
/**
* Sets the json object to serialize.
*
* @param json QVariant containing the json representation to be serialized
*/
void setJsonObject( const QVariant& json );
/* reimp */ void run();
Q_SIGNALS:
/**
* This signal is emitted when the serialization process has been completed
* @param serialized contains the result of the serialization
* @param ok if a serialization error occurs ok is set to false, otherwise it's set to true.
* @param error_msg contains a string explaining the failure reason
**/
void parsingFinished(const QByteArray& serialized, bool ok, const QString& error_msg);
private:
Q_DISABLE_COPY(SerializerRunnable)
class Private;
Private* const d;
};
}
#endif // SERIALIZERRUNNABLE_H

70
thirdparty/qtweetlib/qtweetlib/qjson/src.pro vendored
View File

@@ -1,70 +0,0 @@
QJSON_BASE = ..
QJSON_SRCBASE = .
TEMPLATE = lib
QT -= gui
TARGET = qjson
DESTDIR = $$QJSON_BASE/lib
CONFIG += create_prl
VERSION = 0.7.1
windows: {
DEFINES += QJSON_MAKEDLL
}
QJSON_CPP = $$QJSON_SRCBASE
INCLUDEPATH += $$QJSON_CPP
PRIVATE_HEADERS += \
json_parser.hh \
json_scanner.h \
location.hh \
parser_p.h \
position.hh \
qjson_debug.h \
stack.hh
PUBLIC_HEADERS += \
parser.h \
parserrunnable.h \
qobjecthelper.h \
serializer.h \
serializerrunnable.h \
qjson_export.h
HEADERS += $$PRIVATE_HEADERS $$PUBLIC_HEADERS
SOURCES += \
json_parser.cc \
json_scanner.cpp \
parser.cpp \
parserrunnable.cpp \
qobjecthelper.cpp \
serializer.cpp \
serializerrunnable.cpp
symbian: {
DEFINES += QJSON_MAKEDLL
#export public header to \epocroot\epoc32\include to be able to use them
headers.files = $$PUBLIC_HEADERS
headers.path = $$PWD
for(header, headers.files) {
{BLD_INF_RULES.prj_exports += "$$header"}
}
TARGET.EPOCALLOWDLLDATA = 1
# uid for the dll
#TARGET.UID3=
TARGET.CAPABILITY = ReadDeviceData WriteDeviceData
# do not freeze api-> no libs produced. Comment when freezing!
# run "abld freeze winscw" to create def files
symbian:MMP_RULES += "EXPORTUNFROZEN"
# add dll to the sis
QjsonDeployment.sources = $${TARGET}.dll
QjsonDeployment.path = /sys/bin
DEPLOYMENT += QjsonDeployment
}

129
thirdparty/qtweetlib/qtweetlib/qjson/stack.hh vendored
View File

@@ -1,129 +0,0 @@
/* A Bison parser, made by GNU Bison 2.3. */
/* Stack handling for Bison parsers in C++
Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA. */
/* As a special exception, you may create a larger work that contains
part or all of the Bison parser skeleton and distribute that work
under terms of your choice, so long as that work isn't itself a
parser generator using the skeleton or a modified version thereof
as a parser skeleton. Alternatively, if you modify or redistribute
the parser skeleton itself, you may (at your option) remove this
special exception, which will cause the skeleton and the resulting
Bison output files to be licensed under the GNU General Public
License without this special exception.
This special exception was added by the Free Software Foundation in
version 2.2 of Bison. */
#ifndef BISON_STACK_HH
# define BISON_STACK_HH
#include <deque>
namespace yy
{
template <class T, class S = std::deque<T> >
class stack
{
public:
// Hide our reversed order.
typedef typename S::reverse_iterator iterator;
typedef typename S::const_reverse_iterator const_iterator;
stack () : seq_ ()
{
}
stack (unsigned int n) : seq_ (n)
{
}
inline
T&
operator [] (unsigned int i)
{
return seq_[i];
}
inline
const T&
operator [] (unsigned int i) const
{
return seq_[i];
}
inline
void
push (const T& t)
{
seq_.push_front (t);
}
inline
void
pop (unsigned int n = 1)
{
for (; n; --n)
seq_.pop_front ();
}
inline
unsigned int
height () const
{
return seq_.size ();
}
inline const_iterator begin () const { return seq_.rbegin (); }
inline const_iterator end () const { return seq_.rend (); }
private:
S seq_;
};
/// Present a slice of the top of a stack.
template <class T, class S = stack<T> >
class slice
{
public:
slice (const S& stack,
unsigned int range) : stack_ (stack),
range_ (range)
{
}
inline
const T&
operator [] (unsigned int i) const
{
return stack_[range_ - i];
}
private:
const S& stack_;
unsigned int range_;
};
}
#endif // not BISON_STACK_HH

340
thirdparty/qtweetlib/qtweetlib/src/oauth.cpp vendored
View File

@@ -1,340 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QDateTime>
#include <QtAlgorithms>
#include <QCryptographicHash>
#include <QtDebug>
#include "oauth.h"
#ifndef CONSUMER_KEY
#define CONSUMER_KEY ""
#endif //CONSUMER_KEY
#ifndef CONSUMER_SECRET
#define CONSUMER_SECRET ""
#endif //CONSUMER_SECRET
/**
* Generates HMAC-SHA1 signature
* @param message for which to create signature
* @param key
*/
static QByteArray hmacSha1(const QByteArray& message, const QByteArray& key)
{
QByteArray normKey;
if (key.size() > 64) {
normKey = QCryptographicHash::hash(key, QCryptographicHash::Sha1);
} else {
normKey = key; // no need for zero padding ipad and opad are filled with zeros
}
unsigned char* K = (unsigned char *)normKey.constData();
unsigned char ipad[65];
unsigned char opad[65];
memset(ipad, 0, 65);
memset(opad, 0, 65);
memcpy(ipad, K, normKey.size());
memcpy(opad, K, normKey.size());
for (int i = 0; i < 64; ++i) {
ipad[i] ^= 0x36;
opad[i] ^= 0x5c;
}
QByteArray context;
context.append((const char *)ipad, 64);
context.append(message);
QByteArray sha1 = QCryptographicHash::hash(context, QCryptographicHash::Sha1);
context.clear();
context.append((const char *)opad, 64);
context.append(sha1);
sha1.clear();
sha1 = QCryptographicHash::hash(context, QCryptographicHash::Sha1);
return sha1;
}
/**
* Generates time stamp
* @return time stamp in epoch time
*/
static QByteArray generateTimeStamp()
{
//OAuth spec. 8 http://oauth.net/core/1.0/#nonce
QDateTime current = QDateTime::currentDateTime();
uint seconds = current.toTime_t();
return QString("%1").arg(seconds).toUtf8();
}
/**
* Generates random 16 length string
* @return random string
*/
static QByteArray generateNonce()
{
//OAuth spec. 8 http://oauth.net/core/1.0/#nonce
QByteArray chars("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
int max = chars.size();
int len = 16;
QByteArray nonce;
for(int i = 0; i < len; ++i){
nonce.append( chars[qrand() % max] );
}
return nonce;
}
/**
* Constructor
* @param parent parent QObject
*/
OAuth::OAuth(QObject *parent)
: QObject(parent),
m_oauthConsumerKey(CONSUMER_KEY),
m_oauthConsumerSecret(CONSUMER_SECRET)
{
QDateTime current = QDateTime::currentDateTime();
qsrand(current.toTime_t());
}
/**
* Constructor
* @param consumerKey oauth consumer key
* @param consumerSecret oauth consumer secret
* @param parent parent QObject
*/
OAuth::OAuth(const QByteArray &consumerKey, const QByteArray &consumerSecret, QObject *parent)
: QObject(parent),
m_oauthConsumerKey(consumerKey),
m_oauthConsumerSecret(consumerSecret)
{
QDateTime current = QDateTime::currentDateTime();
qsrand(current.toTime_t());
}
/**
* Parses oauth_token and oauth_token_secret from response of the service provider
* and sets m_oauthToken and m_oauthTokenSecret accordingly
* @param response response from service provider
*/
void OAuth::parseTokens(const QByteArray& response)
{
//OAuth spec 5.3, 6.1.2, 6.3.2
//use QUrl for parsing
QByteArray parseQuery("http://parse.com?");
QUrl parseUrl = QUrl::fromEncoded(parseQuery + response);
m_oauthToken = parseUrl.encodedQueryItemValue("oauth_token");
m_oauthTokenSecret = parseUrl.encodedQueryItemValue("oauth_token_secret");
}
/**
* Sets oauth token
* @param token OAuth token
*/
void OAuth::setOAuthToken(const QByteArray& token)
{
m_oauthToken = token;
}
/**
* Sets OAauth token secret
* @param tokenSecret OAuth token secret
*/
void OAuth::setOAuthTokenSecret(const QByteArray& tokenSecret)
{
m_oauthTokenSecret = tokenSecret;
}
/**
* Gets oauth_token
* @return OAuth token
*/
QByteArray OAuth::oauthToken() const
{
return m_oauthToken;
}
/**
* Gets oauth_token_secret
* @return OAuth token secret
*/
QByteArray OAuth::oauthTokenSecret() const
{
return m_oauthTokenSecret;
}
/**
* Clears the oauth tokens
*/
void OAuth::clearTokens()
{
m_oauthToken.clear();
m_oauthTokenSecret.clear();
}
/**
* Generates HMAC-SHA1 signature
* @param signatureBase signature base
* @return HMAC-SHA1 signature
*/
QByteArray OAuth::generateSignatureHMACSHA1(const QByteArray& signatureBase)
{
//OAuth spec. 9.2 http://oauth.net/core/1.0/#anchor16
QByteArray key = m_oauthConsumerSecret + '&' + m_oauthTokenSecret;
QByteArray result = hmacSha1(signatureBase, key);
QByteArray resultBE64 = result.toBase64();
QByteArray resultPE = resultBE64.toPercentEncoding();
return resultPE;
}
/**
* Generates OAuth signature base
* @param url Url with encoded parameters
* @param method Http method
* @param timestamp timestamp
* @param nonce random string
* @return signature base
*/
QByteArray OAuth::generateSignatureBase(const QUrl& url, HttpMethod method, const QByteArray& timestamp, const QByteArray& nonce)
{
//OAuth spec. 9.1 http://oauth.net/core/1.0/#anchor14
//OAuth spec. 9.1.1
QList<QPair<QByteArray, QByteArray> > urlParameters = url.encodedQueryItems();
QList<QByteArray> normParameters;
QListIterator<QPair<QByteArray, QByteArray> > i(urlParameters);
while(i.hasNext()){
QPair<QByteArray, QByteArray> queryItem = i.next();
QByteArray normItem = queryItem.first + '=' + queryItem.second;
normParameters.append(normItem);
}
//consumer key
normParameters.append(QByteArray("oauth_consumer_key=") + m_oauthConsumerKey);
//token
if(!m_oauthToken.isEmpty()){
normParameters.append(QByteArray("oauth_token=") + m_oauthToken);
}
//signature method, only HMAC_SHA1
normParameters.append(QByteArray("oauth_signature_method=HMAC-SHA1"));
//time stamp
normParameters.append(QByteArray("oauth_timestamp=") + timestamp);
//nonce
normParameters.append(QByteArray("oauth_nonce=") + nonce);
//version
normParameters.append(QByteArray("oauth_version=1.0"));
//OAuth spec. 9.1.1.1
qSort(normParameters);
//OAuth spec. 9.1.1.2
//QByteArray normString;
//QListIterator<QByteArray> j(normParameters);
//while(j.hasNext()){
// normString += j.next();
// normString += '&';
//}
//normString.chop(1);
QByteArray normString;
QListIterator<QByteArray> j(normParameters);
while (j.hasNext()) {
normString += j.next().toPercentEncoding();
normString += "%26";
}
normString.chop(3);
//OAuth spec. 9.1.2
QString urlScheme = url.scheme();
QString urlPath = url.path();
QString urlHost = url.host();
QByteArray normUrl = urlScheme.toUtf8() + "://" + urlHost.toUtf8() + urlPath.toUtf8();
QByteArray httpm;
switch (method)
{
case OAuth::GET:
httpm = "GET";
break;
case OAuth::POST:
httpm = "POST";
break;
case OAuth::DELETE:
httpm = "DELETE";
break;
case OAuth::PUT:
httpm = "PUT";
break;
}
//OAuth spec. 9.1.3
return httpm + '&' + normUrl.toPercentEncoding() + '&' + normString;
}
/**
* Generates Authorization Header
* @param url url with query items embedded
* @param method type of http method
* @remarks If HttpMethod is POST put query items in url (QUrl::addEncodedQueryItem)
*/
QByteArray OAuth::generateAuthorizationHeader( const QUrl& url, HttpMethod method )
{
if (m_oauthToken.isEmpty() && m_oauthTokenSecret.isEmpty())
qDebug() << "OAuth tokens are empty!";
QByteArray timeStamp = generateTimeStamp();
QByteArray nonce = generateNonce();
QByteArray sigBase = generateSignatureBase(url, method, timeStamp, nonce);
QByteArray signature = generateSignatureHMACSHA1(sigBase);
QByteArray header;
header += "OAuth ";
header += "oauth_consumer_key=\"" + m_oauthConsumerKey + "\",";
if(!m_oauthToken.isEmpty())
header += "oauth_token=\"" + m_oauthToken + "\",";
header += "oauth_signature_method=\"HMAC-SHA1\",";
header += "oauth_signature=\"" + signature + "\",";
header += "oauth_timestamp=\"" + timeStamp + "\",";
header += "oauth_nonce=\"" + nonce + "\",";
header += "oauth_version=\"1.0\"";
return header;
}

67
thirdparty/qtweetlib/qtweetlib/src/oauth.h vendored
View File

@@ -1,67 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef OAUTH_H
#define OAUTH_H
#include <QObject>
#include <QUrl>
#include "qtweetlib_global.h"
class QByteArray;
/**
* Base OAuth class
*/
class QTWEETLIBSHARED_EXPORT OAuth : public QObject
{
Q_OBJECT
Q_ENUMS(HttpMethod)
Q_PROPERTY(QByteArray oauthToken READ oauthToken WRITE setOAuthToken)
Q_PROPERTY(QByteArray oauthTokenSecret READ oauthTokenSecret WRITE setOAuthTokenSecret)
public:
OAuth(QObject *parent = 0);
OAuth(const QByteArray& consumerKey, const QByteArray& consumerSecret, QObject *parent = 0);
#undef GET
#undef POST
#undef PUT
#undef DELETE
enum HttpMethod {GET, POST, PUT, DELETE};
void parseTokens(const QByteArray& response);
QByteArray generateAuthorizationHeader(const QUrl& url, HttpMethod method);
void setOAuthToken(const QByteArray& token);
void setOAuthTokenSecret(const QByteArray& tokenSecret);
void clearTokens();
QByteArray oauthToken() const;
QByteArray oauthTokenSecret() const;
private:
QByteArray generateSignatureHMACSHA1(const QByteArray& signatureBase);
QByteArray generateSignatureBase(const QUrl& url, HttpMethod method, const QByteArray& timestamp, const QByteArray& nonce);
QByteArray m_oauthToken;
QByteArray m_oauthTokenSecret;
QByteArray m_oauthConsumerSecret;
QByteArray m_oauthConsumerKey;
};
#endif //OAUTH_H

216
thirdparty/qtweetlib/qtweetlib/src/oauthtwitter.cpp vendored
View File

@@ -1,216 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "oauthtwitter.h"
#include <QtDebug>
#include <QUrl>
#include <QNetworkReply>
#include <QTimer>
#include <QNetworkAccessManager>
#include <QEventLoop>
#include <QDesktopServices>
#define TWITTER_REQUEST_TOKEN_URL "http://twitter.com/oauth/request_token"
#define TWITTER_ACCESS_TOKEN_URL "http://twitter.com/oauth/access_token"
#define TWITTER_AUTHORIZE_URL "http://twitter.com/oauth/authorize"
#define TWITTER_ACCESS_TOKEN_XAUTH_URL "https://api.twitter.com/oauth/access_token"
/**
* Constructor
*/
OAuthTwitter::OAuthTwitter(QObject *parent)
: OAuth(parent), m_netManager(0)
{
}
/**
* Constructor
*/
OAuthTwitter::OAuthTwitter(QNetworkAccessManager *netManager, QObject *parent) :
OAuth(parent), m_netManager(netManager)
{
}
/**
* Sets network access manager
* @remarks Must be set to work properly
*/
void OAuthTwitter::setNetworkAccessManager(QNetworkAccessManager* netManager)
{
m_netManager = netManager;
}
/**
* Gets network access manager
*/
QNetworkAccessManager* OAuthTwitter::networkAccessManager() const
{
return m_netManager;
}
/**
* Gets oauth tokens using XAuth method (starts authorization process)
* @param username username
* @param password password
* @remarks Async, emits authorizeXAuthFinished or authorizeXAuthError when there is error
*/
void OAuthTwitter::authorizeXAuth(const QString &username, const QString &password)
{
Q_ASSERT(m_netManager != 0);
QUrl url(TWITTER_ACCESS_TOKEN_XAUTH_URL);
url.addQueryItem("x_auth_username", username);
url.addQueryItem("x_auth_password", password);
url.addQueryItem("x_auth_mode", "client_auth");
QByteArray oauthHeader = generateAuthorizationHeader(url, OAuth::POST);
QNetworkRequest req(url);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = m_netManager->post(req, QByteArray());
connect(reply, SIGNAL(finished()), this, SLOT(finishedAuthorization()));
}
/**
* Called when authorization is finished
*/
void OAuthTwitter::finishedAuthorization()
{
QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender());
if (reply) {
if (reply->error() == QNetworkReply::NoError) {
QByteArray response = reply->readAll();
parseTokens(response);
emit authorizeXAuthFinished();
} else {
//dump error
qDebug() << "Network Error: " << reply->error();
qDebug() << "Response error: " << reply->readAll();
emit authorizeXAuthError();
}
reply->deleteLater();
}
}
/**
* Starts PIN based OAuth authorization
*/
void OAuthTwitter::authorizePin()
{
Q_ASSERT(m_netManager != 0);
QUrl url(TWITTER_REQUEST_TOKEN_URL);
QByteArray oauthHeader = generateAuthorizationHeader(url, OAuth::POST);
QNetworkRequest req(url);
req.setRawHeader(AUTH_HEADER, oauthHeader);
//enters event loop
QEventLoop q;
QTimer t;
t.setSingleShot(true);
connect(&t, SIGNAL(timeout()), &q, SLOT(quit()));
QNetworkReply *reply = m_netManager->post(req, QByteArray());
connect(reply, SIGNAL(finished()), &q, SLOT(quit()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error()));
t.start(5000);
q.exec();
if (t.isActive()) {
t.stop();
QByteArray response = reply->readAll();
parseTokens(response);
reply->deleteLater();
requestAuthorization();
int pin = authorizationWidget();
if (pin) {
requestAccessToken(pin);
}
} else {
qDebug() << "Timeout";
}
}
/**
* Opens authorization url
* @remarks Override if you want to show another browser
*/
void OAuthTwitter::requestAuthorization()
{
QUrl authorizeUrl(TWITTER_AUTHORIZE_URL);
authorizeUrl.addEncodedQueryItem("oauth_token", oauthToken());
QDesktopServices::openUrl(authorizeUrl);
}
/**
* Gets access tokens for user entered pin number
* @param pin entered pin number
*/
void OAuthTwitter::requestAccessToken(int pin)
{
Q_ASSERT(m_netManager != 0);
QUrl url(TWITTER_ACCESS_TOKEN_URL);
url.addEncodedQueryItem("oauth_verifier", QByteArray::number(pin));
QByteArray oauthHeader = generateAuthorizationHeader(url, OAuth::POST);
QEventLoop q;
QTimer t;
t.setSingleShot(true);
connect(&t, SIGNAL(timeout()), &q, SLOT(quit()));
QNetworkRequest req(url);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = m_netManager->post(req, QByteArray());
connect(reply, SIGNAL(finished()), &q, SLOT(quit()));
connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(error()));
t.start(5000);
q.exec();
if(t.isActive()){
QByteArray response = reply->readAll();
parseTokens(response);
reply->deleteLater();
} else {
qDebug() << "Timeout";
}
}
/**
* Override to show the authorization widget where users enters pin number
* @return entered pin number by the user
*/
int OAuthTwitter::authorizationWidget()
{
return 0;
}

65
thirdparty/qtweetlib/qtweetlib/src/oauthtwitter.h vendored
View File

@@ -1,65 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef OAUTHTWITTER_H
#define OAUTHTWITTER_H
#include "oauth.h"
class QNetworkAccessManager;
/**
* OAuth Twitter authorization class
*/
class QTWEETLIBSHARED_EXPORT OAuthTwitter : public OAuth
{
Q_OBJECT
Q_PROPERTY(QNetworkAccessManager* networkAccessManager
READ networkAccessManager
WRITE setNetworkAccessManager)
public:
OAuthTwitter(QObject *parent = 0);
OAuthTwitter(QNetworkAccessManager* netManager, QObject *parent = 0);
void setNetworkAccessManager(QNetworkAccessManager* netManager);
QNetworkAccessManager* networkAccessManager() const;
void authorizeXAuth(const QString& username, const QString& password);
void authorizePin();
signals:
/** Emited when XAuth authorization is finished */
void authorizeXAuthFinished();
/** Emited when there is error in XAuth authorization */
// ### TODO Error detection
// Sigh, bad documentation on errors in twitter api
void authorizeXAuthError();
protected:
virtual int authorizationWidget();
virtual void requestAuthorization();
private slots:
void finishedAuthorization();
void requestAccessToken(int pin);
private:
QNetworkAccessManager *m_netManager;
};
#endif //OAUTHTWITTER_H

78
thirdparty/qtweetlib/qtweetlib/src/qtweetaccountratelimitstatus.cpp vendored
View File

@@ -1,78 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetaccountratelimitstatus.h"
/**
* Constructor
*/
QTweetAccountRateLimitStatus::QTweetAccountRateLimitStatus(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetAccountRateLimitStatus::QTweetAccountRateLimitStatus(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts checking rate limit status
* @remarks Should be emiting rateLimitInfo signal after finishing
*/
void QTweetAccountRateLimitStatus::check()
{
QUrl url("http://api.twitter.com/1/account/rate_limit_status.json");
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetAccountRateLimitStatus::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QVariantMap respMap = json.toMap();
int remainingHits = respMap["remaining_hits"].toInt();
int resetTime = respMap["reset_time_in_seconds"].toInt();
int hourlyLimit = respMap["hourly_limit"].toInt();
emit rateLimitInfo(remainingHits, resetTime, hourlyLimit);
} else {
qDebug() << "QTweetAccountRateLimitStatus parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

50
thirdparty/qtweetlib/qtweetlib/src/qtweetaccountratelimitstatus.h vendored
View File

@@ -1,50 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETACCOUNTRATELIMITSTATUS_H
#define QTWEETACCOUNTRATELIMITSTATUS_H
#include "qtweetnetbase.h"
/**
* Returns the remaining number of API requests available to the requesting user
* before the API limit is reached for the current hour.
*/
class QTweetAccountRateLimitStatus : public QTweetNetBase
{
Q_OBJECT
public:
QTweetAccountRateLimitStatus(QObject *parent = 0);
QTweetAccountRateLimitStatus(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void check();
signals:
/** Emits rate limit info
* @param remainingHits Remaining hits
* @param resetTime Reset time in seconds
* @param hourlyLimit
*/
void rateLimitInfo(int remainingHits, int resetTime, int hourlyLimit);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETACCOUNTRATELIMITSTATUS_H

82
thirdparty/qtweetlib/qtweetlib/src/qtweetaccountverifycredentials.cpp vendored
View File

@@ -1,82 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkReply>
#include <QNetworkRequest>
#include "qtweetaccountverifycredentials.h"
#include "qtweetuser.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetAccountVerifyCredentials::QTweetAccountVerifyCredentials(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetAccountVerifyCredentials::QTweetAccountVerifyCredentials(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Verifies credentials
* @param includeEntities when set to either true, t or 1, each tweet will include a node called "entities,".
*/
void QTweetAccountVerifyCredentials::verify(bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/account/verify_credentials.json");
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetAccountVerifyCredentials::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetUser user = QTweetConvert::variantMapToUserInfo(json.toMap());
emit parsedUser(user);
} else {
qDebug() << "QTweetAccountVerifyCredentials parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

47
thirdparty/qtweetlib/qtweetlib/src/qtweetaccountverifycredentials.h vendored
View File

@@ -1,47 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETACCOUNTVERIFYCREDENTIALS_H
#define QTWEETACCOUNTVERIFYCREDENTIALS_H
#include "qtweetnetbase.h"
/**
* Checks credentials of a authenticated user. Should emit parsedUser signal
* if authentication was successful, error if not. Use this to test if
* supplied user credentials are valid
*/
class QTWEETLIBSHARED_EXPORT QTweetAccountVerifyCredentials : public QTweetNetBase
{
Q_OBJECT
public:
QTweetAccountVerifyCredentials(QObject *parent = 0);
QTweetAccountVerifyCredentials(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void verify(bool includeEntities = false);
signals:
/** Emits parsed user when credentials are valid */
void parsedUser(const QTweetUser& user);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETACCOUNTVERIFYCREDENTIALS_H

522
thirdparty/qtweetlib/qtweetlib/src/qtweetconvert.cpp vendored
View File

@@ -1,522 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "qtweetconvert.h"
#include "qtweetstatus.h"
#include "qtweetdmstatus.h"
#include "qtweetuser.h"
#include "qtweetlist.h"
#include "qtweetplace.h"
#include "qtweetsearchresult.h"
#include "qtweetsearchpageresults.h"
#include "qtweetentityurl.h"
#include "qtweetentityhashtag.h"
#include "qtweetentityusermentions.h"
/**
* Converts list of statuses
*/
QList<QTweetStatus> QTweetConvert::variantToStatusList(const QVariant &fromParser)
{
QList<QTweetStatus> statuses;
QList<QVariant> listStatus = fromParser.toList();
foreach (const QVariant& status, listStatus) {
QVariantMap statusMap = status.toMap();
QTweetStatus tweetStatus = variantMapToStatus(statusMap);
statuses.append(tweetStatus);
}
return statuses;
}
/**
* Converts status
*/
QTweetStatus QTweetConvert::variantMapToStatus(const QVariantMap &var)
{
QTweetStatus status;
status.setCreatedAt(var["created_at"].toString());
status.setText(var["text"].toString());
status.setId(var["id"].toLongLong());
status.setInReplyToUserId(var["in_reply_to_user_id"].toLongLong());
status.setInReplyToScreenName(var["in_reply_to_screen_name"].toString());
status.setFavorited(var["favorited"].toBool());
QVariantMap userMap = var["user"].toMap();
QTweetUser user = variantMapToUserInfo(userMap);
status.setUser(user);
status.setSource(var["source"].toString());
status.setInReplyToStatusId(var["in_reply_to_status_id"].toLongLong());
//check if contains native retweet
if (var.contains("retweeted_status")) {
QVariantMap retweetMap = var["retweeted_status"].toMap();
QTweetStatus rtStatus = variantMapToStatus(retweetMap);
status.setRetweetedStatus(rtStatus);
}
//parse place id if it's not null
QVariant placeVar = var["place"];
if (!placeVar.isNull()) {
QTweetPlace place = variantMapToPlace(placeVar.toMap());
status.setPlace(place);
}
//check if contains entities
if (var.contains("entities")) {
QVariantMap entitiesVarMap = var["entities"].toMap();
//url entities
QVariantList urlEntitiesVarList = entitiesVarMap["urls"].toList();
foreach (const QVariant& urlEntityVar, urlEntitiesVarList) {
QVariantMap urlEntityVarMap = urlEntityVar.toMap();
QTweetEntityUrl urlEntity = variantMapToEntityUrl(urlEntityVarMap);
status.addUrlEntity(urlEntity);
}
//hashtag entities
QVariantList hashtagEntitiesVarList = entitiesVarMap["hashtags"].toList();
foreach (const QVariant& hashtagEntityVar, hashtagEntitiesVarList) {
QVariantMap hashtagEntityVarMap = hashtagEntityVar.toMap();
QTweetEntityHashtag hashtagEntity = variantMapToEntityHashtag(hashtagEntityVarMap);
status.addHashtagEntity(hashtagEntity);
}
//user mentions
QVariantList userMentionsEntitiesVarList = entitiesVarMap["user_mentions"].toList();
foreach (const QVariant& userMentionsEntityVar, userMentionsEntitiesVarList) {
QVariantMap userMentionsEntityVarMap = userMentionsEntityVar.toMap();
QTweetEntityUserMentions userMentionsEntity = variantMapToEntityUserMentions(userMentionsEntityVarMap);
status.addUserMentionsEntity(userMentionsEntity);
}
}
return status;
}
/**
* Converts user info
*/
QTweetUser QTweetConvert::variantMapToUserInfo(const QVariantMap &var)
{
QTweetUser userInfo;
userInfo.setId(var["id"].toLongLong());
//don't fill rest of it, when user info is trimmed
if (var.contains("name")) {
userInfo.setName(var["name"].toString());
userInfo.setLocation(var["location"].toString());
userInfo.setprofileImageUrl(var["profile_image_url"].toString());
userInfo.setCreatedAt(var["created_at"].toString());
userInfo.setFavouritesCount(var["favourites_count"].toInt());
userInfo.setUrl(var["url"].toString());
userInfo.setUtcOffset(var["utc_offset"].toInt());
userInfo.setProtected(var["protected"].toBool());
userInfo.setFollowersCount(var["followers_count"].toInt());
userInfo.setVerified(var["verified"].toBool());
userInfo.setGeoEnabled(var["geo_enabled"].toBool());
userInfo.setDescription(var["description"].toString());
userInfo.setTimezone(var["time_zone"].toString());
userInfo.setFriendsCount(var["friends_count"].toInt());
userInfo.setStatusesCount(var["statuses_count"].toInt());
userInfo.setScreenName(var["screen_name"].toString());
userInfo.setContributorsEnabled(var["contributors_enabled"].toBool());
userInfo.setListedCount(var["listed_count"].toInt());
userInfo.setLang(var["lang"].toString());
//check if contains status
if (var.contains("status")) {
QVariantMap statusMap = var["status"].toMap();
QTweetStatus status = variantMapToStatus(statusMap);
userInfo.setStatus(status);
}
}
return userInfo;
}
/**
* Converts list of direct messages
*/
QList<QTweetDMStatus> QTweetConvert::variantToDirectMessagesList(const QVariant& fromParser)
{
QList<QTweetDMStatus> directMessages;
QList<QVariant> listMessages = fromParser.toList();
foreach (const QVariant& message, listMessages) {
QTweetDMStatus dmStatus = variantMapToDirectMessage(message.toMap());
directMessages.append(dmStatus);
}
return directMessages;
}
/**
* Converts direct message
*/
QTweetDMStatus QTweetConvert::variantMapToDirectMessage(const QVariantMap& var)
{
QTweetDMStatus directMessage;
directMessage.setCreatedAt(var["created_at"].toString());
directMessage.setSenderScreenName(var["sender_screen_name"].toString());
QVariantMap senderMap = var["sender"].toMap();
QTweetUser sender = variantMapToUserInfo(senderMap);
directMessage.setSender(sender);
directMessage.setText(var["text"].toString());
directMessage.setRecipientScreenName(var["recipient_screen_name"].toString());
directMessage.setId(var["id"].toLongLong());
QVariantMap recipientMap = var["recipient"].toMap();
QTweetUser recipient = variantMapToUserInfo(recipientMap);
directMessage.setRecipient(recipient);
directMessage.setRecipientId(var["recipient_id"].toLongLong());
directMessage.setSenderId(var["sender_id"].toLongLong());
return directMessage;
}
/**
* Converts tweet list
*/
QTweetList QTweetConvert::variantMapToTweetList(const QVariantMap& var)
{
QTweetList list;
list.setMode(var["mode"].toString());
list.setDescription(var["description"].toString());
list.setFollowing(var["following"].toBool());
list.setMemberCount(var["member_count"].toInt());
list.setFullName(var["full_name"].toString());
list.setSubscriberCount(var["subscriber_count"].toInt());
list.setSlug(var["slug"].toString());
list.setName(var["name"].toString());
list.setId(var["id"].toLongLong());
list.setUri(var["uri"].toString());
if (var.contains("user")) {
QVariantMap userMap = var["user"].toMap();
QTweetUser user = variantMapToUserInfo(userMap);
list.setUser(user);
}
return list;
}
/**
* Converts list of user infos
*/
QList<QTweetUser> QTweetConvert::variantToUserInfoList(const QVariant& fromParser)
{
QList<QTweetUser> users;
QList<QVariant> listUsers = fromParser.toList();
foreach (const QVariant& user, listUsers) {
QTweetUser userInfo = variantMapToUserInfo(user.toMap());
users.append(userInfo);
}
return users;
}
/**
* Converts list of tweet lists
*/
QList<QTweetList> QTweetConvert::variantToTweetLists(const QVariant& var)
{
QList<QTweetList> lists;
QList<QVariant> varLists = var.toList();
foreach (const QVariant& varlist, varLists) {
QTweetList tweetlist = variantMapToTweetList(varlist.toMap());
lists.append(tweetlist);
}
return lists;
}
/**
* Converts search result
*/
QTweetSearchResult QTweetConvert::variantMapToSearchResult(const QVariantMap& var)
{
QTweetSearchResult result;
result.setCreatedAt(var["created_at"].toString());
result.setFromUser(var["from_user"].toString());
result.setId(var["id"].toLongLong());
result.setLang(var["iso_language_code"].toString());
result.setProfileImageUrl(var["profile_image_url"].toString());
result.setSource(var["source"].toString());
result.setText(var["text"].toString());
result.setToUser(var["to_user"].toString());
return result;
}
/**
* Converts page results
*/
QTweetSearchPageResults QTweetConvert::variantToSearchPageResults(const QVariant& var)
{
QTweetSearchPageResults page;
QVariantMap varMap = var.toMap();
page.setMaxId(varMap["max_id"].toLongLong());
page.setNextPage(varMap["next_page"].toByteArray());
page.setPage(varMap["page"].toInt());
page.setQuery(varMap["query"].toByteArray());
page.setRefreshUrl(varMap["refresh_url"].toByteArray());
page.setResultsPerPage(varMap["results_per_page"].toInt());
page.setSinceId(varMap["since_id"].toLongLong());
page.setTotal(varMap["total"].toInt());
QList<QTweetSearchResult> resultList;
QList<QVariant> resultVarList = varMap["results"].toList();
foreach (const QVariant& resultVar, resultVarList) {
QTweetSearchResult result = variantMapToSearchResult(resultVar.toMap());
resultList.append(result);
}
page.setResults(resultList);
return page;
}
/**
* Converts place
*/
QTweetPlace QTweetConvert::variantMapToPlace(const QVariantMap& var)
{
QTweetPlace place;
place.setName(var["name"].toString());
place.setCountryCode(var["country_code"].toString());
place.setCountry(var["country"].toString());
place.setID(var["id"].toString());
place.setFullName(var["full_name"].toString());
QString placeType = var["place_type"].toString();
if (placeType == "poi")
place.setType(QTweetPlace::Poi);
else if (placeType == "neighborhood")
place.setType(QTweetPlace::Neighborhood);
else if (placeType == "city")
place.setType(QTweetPlace::City);
else if (placeType == "admin")
place.setType(QTweetPlace::Admin);
else if (placeType == "country")
place.setType(QTweetPlace::Country);
else
place.setType(QTweetPlace::Neighborhood); //twitter default
QVariant bbVar = var["bounding_box"];
if (!bbVar.isNull()) {
QVariantMap bbMap = bbVar.toMap();
if (bbMap["type"].toString() == "Polygon") {
QVariantList coordList = bbMap["coordinates"].toList();
if (coordList.count() == 1) {
QVariantList latLongList = coordList.at(0).toList();
if (latLongList.count() == 4) {
QTweetGeoBoundingBox box;
QVariantList coordsBottomLeft = latLongList.at(0).toList();
box.setBottomLeft(QTweetGeoCoord(coordsBottomLeft.at(1).toDouble(), coordsBottomLeft.at(0).toDouble()));
QVariantList coordsBottomRight = latLongList.at(1).toList();
box.setBottomRight(QTweetGeoCoord(coordsBottomRight.at(1).toDouble(), coordsBottomRight.at(0).toDouble()));
QVariantList coordsTopRight = latLongList.at(2).toList();
box.setTopRight(QTweetGeoCoord(coordsTopRight.at(1).toDouble(), coordsTopRight.at(0).toDouble()));
QVariantList coordsTopLeft = latLongList.at(3).toList();
box.setTopLeft(QTweetGeoCoord(coordsTopLeft.at(1).toDouble(), coordsTopLeft.at(0).toDouble()));
place.setBoundingBox(box);
}
}
}
}
return place;
}
//not to be used in timelines api, but in geo api, where place contains other places
//is it recursive responsive?
QTweetPlace QTweetConvert::variantMapToPlaceRecursive(const QVariantMap& var)
{
QTweetPlace place;
place.setName(var["name"].toString());
place.setCountryCode(var["country_code"].toString());
place.setCountry(var["country"].toString());
place.setID(var["id"].toString());
place.setFullName(var["full_name"].toString());
QString placeType = var["place_type"].toString();
if (placeType == "poi")
place.setType(QTweetPlace::Poi);
else if (placeType == "neighborhood")
place.setType(QTweetPlace::Neighborhood);
else if (placeType == "city")
place.setType(QTweetPlace::City);
else if (placeType == "admin")
place.setType(QTweetPlace::Admin);
else if (placeType == "country")
place.setType(QTweetPlace::Country);
else
place.setType(QTweetPlace::Neighborhood); //twitter default
QVariant bbVar = var["bounding_box"];
if (!bbVar.isNull()) {
QVariantMap bbMap = bbVar.toMap();
if (bbMap["type"].toString() == "Polygon") {
QVariantList coordList = bbMap["coordinates"].toList();
if (coordList.count() == 1) {
QVariantList latLongList = coordList.at(0).toList();
if (latLongList.count() == 4) {
QTweetGeoBoundingBox box;
QVariantList coordsBottomLeft = latLongList.at(0).toList();
box.setBottomLeft(QTweetGeoCoord(coordsBottomLeft.at(1).toDouble(), coordsBottomLeft.at(0).toDouble()));
QVariantList coordsBottomRight = latLongList.at(1).toList();
box.setBottomRight(QTweetGeoCoord(coordsBottomRight.at(1).toDouble(), coordsBottomRight.at(0).toDouble()));
QVariantList coordsTopRight = latLongList.at(2).toList();
box.setTopRight(QTweetGeoCoord(coordsTopRight.at(1).toDouble(), coordsTopRight.at(0).toDouble()));
QVariantList coordsTopLeft = latLongList.at(3).toList();
box.setTopLeft(QTweetGeoCoord(coordsTopLeft.at(1).toDouble(), coordsTopLeft.at(0).toDouble()));
place.setBoundingBox(box);
}
}
}
}
QVariantList containedVarList = var["contained_within"].toList();
QList<QTweetPlace> containedInPlacesList;
if (!containedVarList.isEmpty()) {
foreach (const QVariant& containedVar, containedVarList) {
QVariantMap containedPlaceMap = containedVar.toMap();
QTweetPlace containedPlace = variantMapToPlaceRecursive(containedPlaceMap);
containedInPlacesList.append(containedPlace);
}
}
place.setContainedWithin(containedInPlacesList);
return place;
}
/**
* Convers list of places
*/
QList<QTweetPlace> QTweetConvert::variantToPlaceList(const QVariant& fromParser)
{
QList<QTweetPlace> placeList;
QVariantMap responseVarMap = fromParser.toMap();
QVariantMap resultVarMap = responseVarMap["result"].toMap();
QVariantList placesVarList = resultVarMap["places"].toList();
foreach (const QVariant& placeVar, placesVarList) {
QTweetPlace place = variantMapToPlaceRecursive(placeVar.toMap());
placeList.append(place);
}
return placeList;
}
QTweetEntityUrl QTweetConvert::variantMapToEntityUrl(const QVariantMap &var)
{
QString url = var["url"].toString();
QString displayUrl = var["display_url"].toString();
QString expandedUrl = var["expanded_url"].toString();
QTweetEntityUrl urlEntity;
urlEntity.setUrl(url);
urlEntity.setDisplayUrl(displayUrl);
urlEntity.setExpandedUrl(expandedUrl);
return urlEntity;
}
QTweetEntityHashtag QTweetConvert::variantMapToEntityHashtag(const QVariantMap &var)
{
QTweetEntityHashtag hashtagEntity;
hashtagEntity.setText(var["text"].toString());
return hashtagEntity;
}
QTweetEntityUserMentions QTweetConvert::variantMapToEntityUserMentions(const QVariantMap &var)
{
QTweetEntityUserMentions userMentionsEntity;
userMentionsEntity.setScreenName(var["screen_name"].toString());
userMentionsEntity.setName(var["name"].toString());
userMentionsEntity.setUserid(var["id"].toLongLong());
return userMentionsEntity;
}

63
thirdparty/qtweetlib/qtweetlib/src/qtweetconvert.h vendored
View File

@@ -1,63 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETCONVERT_H
#define QTWEETCONVERT_H
#include <QVariant>
class QTweetStatus;
class QTweetUser;
class QTweetDMStatus;
class QTweetList;
class QTweetSearchResult;
class QTweetSearchPageResults;
class QTweetPlace;
class QTweetEntityUrl;
class QTweetEntityHashtag;
class QTweetEntityUserMentions;
/**
* Contains static converting functions
*/
class QTweetConvert
{
public:
static QList<QTweetStatus> variantToStatusList(const QVariant& fromParser);
static QTweetStatus variantMapToStatus(const QVariantMap& var);
static QTweetUser variantMapToUserInfo(const QVariantMap& var);
static QList<QTweetDMStatus> variantToDirectMessagesList(const QVariant& fromParser);
static QTweetDMStatus variantMapToDirectMessage(const QVariantMap& var);
static QTweetList variantMapToTweetList(const QVariantMap& var);
static QList<QTweetUser> variantToUserInfoList(const QVariant& fromParser);
static QList<QTweetList> variantToTweetLists(const QVariant& var);
static QTweetSearchResult variantMapToSearchResult(const QVariantMap& var);
static QTweetSearchPageResults variantToSearchPageResults(const QVariant& var);
static QTweetPlace variantMapToPlace(const QVariantMap& var);
static QTweetPlace variantMapToPlaceRecursive(const QVariantMap& var);
static QList<QTweetPlace> variantToPlaceList(const QVariant& fromParser);
static QTweetEntityUrl variantMapToEntityUrl(const QVariantMap& var);
static QTweetEntityHashtag variantMapToEntityHashtag(const QVariantMap& var);
static QTweetEntityUserMentions variantMapToEntityUserMentions(const QVariantMap& var);
};
#endif // QTWEETCONVERT_H

83
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagedestroy.cpp vendored
View File

@@ -1,83 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetdirectmessagedestroy.h"
#include "qtweetdmstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetDirectMessageDestroy::QTweetDirectMessageDestroy(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetDirectMessageDestroy::QTweetDirectMessageDestroy(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* @param id the ID of the direct message to delete.
* @param includeEntities When set to true, each tweet will include a node called "entities,"
*/
void QTweetDirectMessageDestroy::destroyMessage(qint64 id, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/direct_messages/destroy/%1.json").arg(id));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::DELETE);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->deleteResource(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetDirectMessageDestroy::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetDMStatus dm = QTweetConvert::variantMapToDirectMessage(json.toMap());
emit parsedDirectMessage(dm);
} else {
qDebug() << "QTweetDirectMessageDestroy parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

46
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagedestroy.h vendored
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETDIRECTMESSAGEDESTROY_H
#define QTWEETDIRECTMESSAGEDESTROY_H
#include "qtweetnetbase.h"
/**
* Destroys the direct message.
* The authenticating user must be the recipient of the specified direct message.
*/
class QTWEETLIBSHARED_EXPORT QTweetDirectMessageDestroy : public QTweetNetBase
{
Q_OBJECT
public:
QTweetDirectMessageDestroy(QObject *parent = 0);
QTweetDirectMessageDestroy(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void destroyMessage(qint64 id, bool includeEntities = false);
signals:
/** emits destroyed direct message */
void parsedDirectMessage(const QTweetDMStatus& message);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETDIRECTMESSAGEDESTROY_H

129
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagenew.cpp vendored
View File

@@ -1,129 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetdirectmessagenew.h"
#include "qtweetdmstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetDirectMessageNew::QTweetDirectMessageNew(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetDirectMessageNew::QTweetDirectMessageNew(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Sends direct message
* @param user The ID of the user who should receive the direct message.
* @param text The text of direct message
* @param includeEntities When set to true each tweet will include a node called "entities,"
*/
void QTweetDirectMessageNew::post(qint64 user,
const QString &text,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/direct_messages/new.json");
QUrl urlQuery(url);
urlQuery.addQueryItem("user_id", QString::number(user));
urlQuery.addEncodedQueryItem("text", QUrl::toPercentEncoding(text));
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Sends direct message
* @param user The ID of the user who should receive the direct message.
* @param text The text of direct message
* @param includeEntities When set to true each tweet will include a node called "entities,"
*/
void QTweetDirectMessageNew::post(const QString &screenName, const QString &text, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/direct_messages/new.json");
QUrl urlQuery(url);
urlQuery.addEncodedQueryItem("screen_name", QUrl::toPercentEncoding(screenName));
urlQuery.addEncodedQueryItem("text", QUrl::toPercentEncoding(text));
if (includeEntities)
urlQuery.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(urlQuery, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QByteArray postBody = urlQuery.toEncoded(QUrl::RemoveScheme | QUrl::RemoveAuthority | QUrl::RemovePath);
postBody.remove(0, 1);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, postBody);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetDirectMessageNew::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetDMStatus dm = QTweetConvert::variantMapToDirectMessage(json.toMap());
emit parsedDirectMessage(dm);
} else {
qDebug() << "QTweetDirectMessageNew parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

50
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagenew.h vendored
View File

@@ -1,50 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETDIRECTMESSAGENEW_H
#define QTWEETDIRECTMESSAGENEW_H
#include "qtweetnetbase.h"
/**
* Sends a new direct message to the specified user from the authenticating user.
*/
class QTWEETLIBSHARED_EXPORT QTweetDirectMessageNew : public QTweetNetBase
{
Q_OBJECT
public:
QTweetDirectMessageNew(QObject *parent = 0);
QTweetDirectMessageNew(OAuthTwitter *oauhtTwitter, QObject *parent = 0);
void post(qint64 user,
const QString& text,
bool includeEntities = false);
void post(const QString& screenName,
const QString& text,
bool includeEntities = false);
signals:
/** Emits direct message who was sent */
void parsedDirectMessage(const QTweetDMStatus& message);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETDIRECTMESSAGENEW_H

103
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessages.cpp vendored
View File

@@ -1,103 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetdirectmessages.h"
#include "qtweetdmstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetDirectMessages::QTweetDirectMessages(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetDirectMessages::QTweetDirectMessages(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Start fetching direct messages
* @param sinceid Fetch DM newer then sinceid
* @param maxid Fetch DM older then maxid
* @param count Number of DM to fetch (up to 200)
* @param page Page number
* @param includeEntities When true each tweet will include a node called "entities"
* @remarks Setting parameter to default value will not be put in query
*/
void QTweetDirectMessages::fetch(qint64 sinceid,
qint64 maxid,
int count,
int page,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/direct_messages.json");
if (sinceid != 0)
url.addQueryItem("since_id", QString::number(sinceid));
if (maxid != 0)
url.addQueryItem("max_id", QString::number(maxid));
if (count != 0)
url.addQueryItem("count", QString::number(count));
if (page != 0)
url.addQueryItem("page", QString::number(page));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetDirectMessages::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetDMStatus> directMessages = QTweetConvert::variantToDirectMessagesList(json);
emit parsedDirectMessages(directMessages);
} else {
qDebug() << "QTweetDirectMessages JSON parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

51
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessages.h vendored
View File

@@ -1,51 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETDIRECTMESSAGES_H
#define QTWEETDIRECTMESSAGES_H
#include "qtweetnetbase.h"
class QTweetDMStatus;
/**
* Class for fetching direct messages
*/
class QTWEETLIBSHARED_EXPORT QTweetDirectMessages : public QTweetNetBase
{
Q_OBJECT
public:
QTweetDirectMessages(QObject *parent = 0);
QTweetDirectMessages(OAuthTwitter* oauthTwitter, QObject *parent = 0);
void fetch(qint64 sinceid = 0,
qint64 maxid = 0,
int count = 0,
int page = 0,
bool includeEntities = false);
signals:
/** Emits parsed direct messages list */
void parsedDirectMessages(const QList<QTweetDMStatus>& messages);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETDIRECTMESSAGES_H

104
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagessent.cpp vendored
View File

@@ -1,104 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetdirectmessagessent.h"
#include "qtweetdmstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetDirectMessagesSent::QTweetDirectMessagesSent(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetDirectMessagesSent::QTweetDirectMessagesSent(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts fetching direct messages
* @param sinceid returns results with an ID greater than (that is, more recent than) the specified ID.
* @param maxid returns results with an ID less than (that is, older than) or equal to the specified ID.
* @param count specifies the number of records to retrieve. Must be less than or equal to 200.
* @param page specifies the page of results to retrieve.
* @param includeEntities When set to true, each tweet will include a node called "entities,".
* @remarks Setting parameters to default value will not be put in the query
*/
void QTweetDirectMessagesSent::fetch(qint64 sinceid,
qint64 maxid,
int count,
int page,
bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url("http://api.twitter.com/1/direct_messages/sent.json");
if (sinceid)
url.addQueryItem("since_id", QString::number(sinceid));
if (maxid)
url.addQueryItem("max_id", QString::number(maxid));
if (count)
url.addQueryItem("count", QString::number(count));
if (page)
url.addQueryItem("page", QString::number(page));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetDirectMessagesSent::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetDMStatus> directMessages = QTweetConvert::variantToDirectMessagesList(json);
emit parsedDirectMessages(directMessages);
} else {
qDebug() << "QTweetDirectMessagesSent parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

49
thirdparty/qtweetlib/qtweetlib/src/qtweetdirectmessagessent.h vendored
View File

@@ -1,49 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETDIRECTMESSAGESSENT_H
#define QTWEETDIRECTMESSAGESSENT_H
#include "qtweetnetbase.h"
/**
* Fetches direct messages sent by the authenticating user.
*/
class QTWEETLIBSHARED_EXPORT QTweetDirectMessagesSent : public QTweetNetBase
{
Q_OBJECT
public:
QTweetDirectMessagesSent(QObject *parent = 0);
QTweetDirectMessagesSent(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void fetch(qint64 sinceid = 0,
qint64 maxid = 0,
int count = 0,
int page = 0,
bool includeEntities = false);
signals:
/** Emits direct messages list */
void parsedDirectMessages(const QList<QTweetDMStatus>& messages);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETDIRECTMESSAGESSENT_H

154
thirdparty/qtweetlib/qtweetlib/src/qtweetdmstatus.cpp vendored
View File

@@ -1,154 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QSharedData>
#include <QDateTime>
#include "qtweetuser.h"
#include "qtweetdmstatus.h"
class QTweetDMStatusData : public QSharedData
{
public:
QDateTime createdAt;
QString senderScreenName;
QTweetUser sender;
QString text;
QString recipientScreenName;
qint64 id;
QTweetUser recipient;
qint64 recipientId;
qint64 senderId;
};
QTweetDMStatus::QTweetDMStatus() :
d(new QTweetDMStatusData)
{
}
QTweetDMStatus::QTweetDMStatus(const QTweetDMStatus &other) :
d(other.d)
{
}
QTweetDMStatus& QTweetDMStatus::operator =(const QTweetDMStatus &other)
{
if (this != &other)
d.operator =(other.d);
return *this;
}
QTweetDMStatus::~QTweetDMStatus()
{
}
void QTweetDMStatus::setCreatedAt(const QString &twitterDate)
{
d->createdAt = QTweetUser::twitterDateToQDateTime(twitterDate);
}
void QTweetDMStatus::setCreatedAt(const QDateTime &datetime)
{
d->createdAt = datetime;
}
QDateTime QTweetDMStatus::createdAt() const
{
return d->createdAt;
}
void QTweetDMStatus::setSenderScreenName(const QString &screenName)
{
d->senderScreenName = screenName;
}
QString QTweetDMStatus::senderScreenName() const
{
return d->senderScreenName;
}
void QTweetDMStatus::setSender(const QTweetUser &sender)
{
d->sender = sender;
}
QTweetUser QTweetDMStatus::sender() const
{
return d->sender;
}
void QTweetDMStatus::setText(const QString &text)
{
d->text = text;
}
QString QTweetDMStatus::text() const
{
return d->text;
}
void QTweetDMStatus::setRecipientScreenName(const QString &screenName)
{
d->recipientScreenName = screenName;
}
QString QTweetDMStatus::recipientScreenName() const
{
return d->recipientScreenName;
}
void QTweetDMStatus::setId(qint64 id)
{
d->id = id;
}
qint64 QTweetDMStatus::id() const
{
return d->id;
}
void QTweetDMStatus::setRecipient(const QTweetUser &recipient)
{
d->recipient = recipient;
}
QTweetUser QTweetDMStatus::recipient() const
{
return d->recipient;
}
void QTweetDMStatus::setRecipientId(qint64 id)
{
d->recipientId = id;
}
qint64 QTweetDMStatus::recipientId() const
{
return d->recipientId;
}
void QTweetDMStatus::setSenderId(qint64 id)
{
d->senderId = id;
}
qint64 QTweetDMStatus::senderId() const
{
return d->senderId;
}

68
thirdparty/qtweetlib/qtweetlib/src/qtweetdmstatus.h vendored
View File

@@ -1,68 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* 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.
*
* This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETDMSTATUS_H
#define QTWEETDMSTATUS_H
#include <QVariant>
#include <QSharedDataPointer>
#include "qtweetlib_global.h"
class QTweetUser;
class QTweetDMStatusData;
/**
* Stores direct message info
*/
class QTWEETLIBSHARED_EXPORT QTweetDMStatus
{
public:
QTweetDMStatus();
QTweetDMStatus(const QTweetDMStatus& other);
QTweetDMStatus& operator=(const QTweetDMStatus& other);
~QTweetDMStatus();
void setCreatedAt(const QString& twitterDate);
void setCreatedAt(const QDateTime& datetime);
QDateTime createdAt() const;
void setSenderScreenName(const QString& screenName);
QString senderScreenName() const;
void setSender(const QTweetUser& sender);
QTweetUser sender() const;
void setText(const QString& text);
QString text() const;
void setRecipientScreenName(const QString& screenName);
QString recipientScreenName() const;
void setId(qint64 id);
qint64 id() const;
void setRecipient(const QTweetUser& recipient);
QTweetUser recipient() const;
void setRecipientId(qint64 id);
qint64 recipientId() const;
void setSenderId(qint64 id);
qint64 senderId() const;
private:
QSharedDataPointer<QTweetDMStatusData> d;
};
Q_DECLARE_METATYPE(QTweetDMStatus)
#endif // QTWEETDMSTATUS_H

57
thirdparty/qtweetlib/qtweetlib/src/qtweetentityhashtag.cpp vendored
View File

@@ -1,57 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "qtweetentityhashtag.h"
#include <QString>
#include <QSharedData>
class QTweetEntityHashtagData : public QSharedData {
public:
QString hashtag;
};
QTweetEntityHashtag::QTweetEntityHashtag() : data(new QTweetEntityHashtagData)
{
}
QTweetEntityHashtag::QTweetEntityHashtag(const QTweetEntityHashtag &rhs) : data(rhs.data)
{
}
QTweetEntityHashtag &QTweetEntityHashtag::operator=(const QTweetEntityHashtag &rhs)
{
if (this != &rhs)
data.operator=(rhs.data);
return *this;
}
QTweetEntityHashtag::~QTweetEntityHashtag()
{
}
void QTweetEntityHashtag::setText(const QString &text)
{
data->hashtag = text;
}
QString QTweetEntityHashtag::text() const
{
return data->hashtag;
}

43
thirdparty/qtweetlib/qtweetlib/src/qtweetentityhashtag.h vendored
View File

@@ -1,43 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETENTITYHASHTAG_H
#define QTWEETENTITYHASHTAG_H
#include <QSharedDataPointer>
class QTweetEntityHashtagData;
class QTweetEntityHashtag
{
public:
QTweetEntityHashtag();
QTweetEntityHashtag(const QTweetEntityHashtag &);
QTweetEntityHashtag &operator=(const QTweetEntityHashtag &);
~QTweetEntityHashtag();
void setText(const QString& text);
QString text() const;
private:
QSharedDataPointer<QTweetEntityHashtagData> data;
};
#endif // QTWEETENTITYHASHTAG_H

82
thirdparty/qtweetlib/qtweetlib/src/qtweetentityurl.cpp vendored
View File

@@ -1,82 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "qtweetentityurl.h"
#include <QString>
#include <QSharedData>
class QTweetEntityUrlData : public QSharedData {
public:
QTweetEntityUrlData() : empty(false) {}
QString displayUrl;
QString url;
QString expandedUrl;
bool empty;
};
QTweetEntityUrl::QTweetEntityUrl() : data(new QTweetEntityUrlData)
{
}
QTweetEntityUrl::QTweetEntityUrl(const QTweetEntityUrl &rhs) : data(rhs.data)
{
}
QTweetEntityUrl &QTweetEntityUrl::operator=(const QTweetEntityUrl &rhs)
{
if (this != &rhs)
data.operator=(rhs.data);
return *this;
}
QTweetEntityUrl::~QTweetEntityUrl()
{
}
void QTweetEntityUrl::setDisplayUrl(const QString &url)
{
data->displayUrl = url;
}
QString QTweetEntityUrl::displayUrl() const
{
return data->displayUrl;
}
void QTweetEntityUrl::setUrl(const QString &url)
{
data->url = url;
}
QString QTweetEntityUrl::url() const
{
return data->url;
}
void QTweetEntityUrl::setExpandedUrl(const QString &url)
{
data->url = url;
}
QString QTweetEntityUrl::expandedUrl() const
{
return data->url;
}

47
thirdparty/qtweetlib/qtweetlib/src/qtweetentityurl.h vendored
View File

@@ -1,47 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETENTITYURL_H
#define QTWEETENTITYURL_H
#include <QSharedDataPointer>
class QTweetEntityUrlData;
class QTweetEntityUrl
{
public:
QTweetEntityUrl();
QTweetEntityUrl(const QTweetEntityUrl &);
QTweetEntityUrl &operator=(const QTweetEntityUrl &);
~QTweetEntityUrl();
void setDisplayUrl(const QString& url);
QString displayUrl() const;
void setUrl(const QString& url);
QString url() const;
void setExpandedUrl(const QString& url);
QString expandedUrl() const;
private:
QSharedDataPointer<QTweetEntityUrlData> data;
};
#endif // QTWEETENTITYURL_H

81
thirdparty/qtweetlib/qtweetlib/src/qtweetentityusermentions.cpp vendored
View File

@@ -1,81 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include "qtweetentityusermentions.h"
#include <QSharedData>
#include <QString>
class QTweetEntityUserMentionsData : public QSharedData {
public:
QTweetEntityUserMentionsData() : userid(0) {}
QString screenName;
QString name;
qint64 userid;
};
QTweetEntityUserMentions::QTweetEntityUserMentions() : data(new QTweetEntityUserMentionsData)
{
}
QTweetEntityUserMentions::QTweetEntityUserMentions(const QTweetEntityUserMentions &rhs) : data(rhs.data)
{
}
QTweetEntityUserMentions &QTweetEntityUserMentions::operator=(const QTweetEntityUserMentions &rhs)
{
if (this != &rhs)
data.operator=(rhs.data);
return *this;
}
QTweetEntityUserMentions::~QTweetEntityUserMentions()
{
}
void QTweetEntityUserMentions::setScreenName(const QString &screenName)
{
data->screenName = screenName;
}
QString QTweetEntityUserMentions::screenName() const
{
return data->screenName;
}
void QTweetEntityUserMentions::setName(const QString &name)
{
data->name = name;
}
QString QTweetEntityUserMentions::name() const
{
return data->name;
}
void QTweetEntityUserMentions::setUserid(qint64 id)
{
data->userid = id;
}
qint64 QTweetEntityUserMentions::userid() const
{
return data->userid;
}

47
thirdparty/qtweetlib/qtweetlib/src/qtweetentityusermentions.h vendored
View File

@@ -1,47 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETENTITYUSERMENTIONS_H
#define QTWEETENTITYUSERMENTIONS_H
#include <QSharedDataPointer>
class QTweetEntityUserMentionsData;
class QTweetEntityUserMentions
{
public:
QTweetEntityUserMentions();
QTweetEntityUserMentions(const QTweetEntityUserMentions &);
QTweetEntityUserMentions &operator=(const QTweetEntityUserMentions &);
~QTweetEntityUserMentions();
void setScreenName(const QString& screenName);
QString screenName() const;
void setName(const QString& name);
QString name() const;
void setUserid(qint64 id);
qint64 userid() const;
private:
QSharedDataPointer<QTweetEntityUserMentionsData> data;
};
#endif // QTWEETENTITYUSERMENTIONS_H

93
thirdparty/qtweetlib/qtweetlib/src/qtweetfavorites.cpp vendored
View File

@@ -1,93 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetfavorites.h"
#include "qtweetstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetFavorites::QTweetFavorites(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetFavorites::QTweetFavorites(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts fetching favorites
* @param id the ID of the user for whom to request a list of favorite statuses. 0 for authenticated user
* @param page Specifies the page of results to retrieve.
* @param includeEntities When set to true, each tweet will include a node called "entities,".
*/
void QTweetFavorites::fetch(qint64 id, int page, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url;
if (id) {
url.setUrl(QString("http://api.twitter.com/1/favorites/%1.json").arg(id));
} else {
url.setUrl("http://api.twitter.com/1/favorites.json");
}
if (page)
url.addQueryItem("page", QString::number(page));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetFavorites::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<QTweetStatus> statuses = QTweetConvert::variantToStatusList(json);
emit parsedFavorites(statuses);
} else {
qDebug() << "QTweetFavorites JSON parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

48
thirdparty/qtweetlib/qtweetlib/src/qtweetfavorites.h vendored
View File

@@ -1,48 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETFAVORITES_H
#define QTWEETFAVORITES_H
#include "qtweetnetbase.h"
/**
* Fetches favorite statuses for the authenticating user or
* user specified by the ID parameter
*/
class QTWEETLIBSHARED_EXPORT QTweetFavorites : public QTweetNetBase
{
Q_OBJECT
public:
QTweetFavorites(QObject *parent = 0);
QTweetFavorites(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void fetch(qint64 id = 0,
int page = 0,
bool includeEntities = false);
signals:
/** Emits list of favorited statuses */
void parsedFavorites(const QList<QTweetStatus>& favorites);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETFAVORITES_H

83
thirdparty/qtweetlib/qtweetlib/src/qtweetfavoritescreate.cpp vendored
View File

@@ -1,83 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetfavoritescreate.h"
#include "qtweetstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetFavoritesCreate::QTweetFavoritesCreate(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetFavoritesCreate::QTweetFavoritesCreate(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts creating favorited statues
* @param statusid ID of the desired status to be favorited.
* @param includeEntities When set to true, each tweet will include a node called "entities,".
*/
void QTweetFavoritesCreate::create(qint64 statusid, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/favorites/create/%1.json").arg(statusid));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::POST);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->post(req, QByteArray());
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetFavoritesCreate::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetStatus status = QTweetConvert::variantMapToStatus(json.toMap());
emit parsedStatus(status);
} else {
qDebug() << "QTweetFavoritesCreate parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

46
thirdparty/qtweetlib/qtweetlib/src/qtweetfavoritescreate.h vendored
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETFAVORITESCREATE_H
#define QTWEETFAVORITESCREATE_H
#include "qtweetnetbase.h"
/**
* Favorites the status specified in the ID parameter as the authenticating user.
* Emits the favorite status when successful.
*/
class QTWEETLIBSHARED_EXPORT QTweetFavoritesCreate : public QTweetNetBase
{
Q_OBJECT
public:
QTweetFavoritesCreate(QObject *parent = 0);
QTweetFavoritesCreate(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void create(qint64 statusid, bool includeEntities = false);
signals:
/** Emits favorited status */
void parsedStatus(const QTweetStatus& status);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETFAVORITESCREATE_H

84
thirdparty/qtweetlib/qtweetlib/src/qtweetfavoritesdestroy.cpp vendored
View File

@@ -1,84 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetfavoritesdestroy.h"
#include "qtweetstatus.h"
#include "qtweetconvert.h"
/**
* Constructor
*/
QTweetFavoritesDestroy::QTweetFavoritesDestroy(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetFavoritesDestroy::QTweetFavoritesDestroy(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts unfavoriting status
* @param statusid ID of the desired status
* @param includeEntities When set to true, each tweet will include a node called "entities,"
*/
void QTweetFavoritesDestroy::unfavorite(qint64 statusid, bool includeEntities)
{
if (!isAuthenticationEnabled()) {
qCritical("Needs authentication to be enabled");
return;
}
QUrl url(QString("http://api.twitter.com/1/favorites/destroy/%1.json").arg(statusid));
if (includeEntities)
url.addQueryItem("include_entities", "true");
QNetworkRequest req(url);
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::DELETE);
req.setRawHeader(AUTH_HEADER, oauthHeader);
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->deleteResource(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetFavoritesDestroy::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QTweetStatus status = QTweetConvert::variantMapToStatus(json.toMap());
emit parsedStatus(status);
} else {
qDebug() << "QTweetFavoritesDestroy parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

46
thirdparty/qtweetlib/qtweetlib/src/qtweetfavoritesdestroy.h vendored
View File

@@ -1,46 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#ifndef QTWEETFAVORITESDESTROY_H
#define QTWEETFAVORITESDESTROY_H
#include "qtweetnetbase.h"
/**
* Un-favorites the status specified in the ID parameter as the authenticating user.
* Emits the un-favorited status when successful.
*/
class QTWEETLIBSHARED_EXPORT QTweetFavoritesDestroy : public QTweetNetBase
{
Q_OBJECT
public:
QTweetFavoritesDestroy(QObject *parent = 0);
QTweetFavoritesDestroy(OAuthTwitter *oauthTwitter, QObject *parent = 0);
void unfavorite(qint64 statusid, bool includeEntities = false);
signals:
/** Emits the unfavorited status */
void parsedStatus(const QTweetStatus& status);
protected slots:
void parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg);
};
#endif // QTWEETFAVORITESDESTROY_H

111
thirdparty/qtweetlib/qtweetlib/src/qtweetfollowersid.cpp vendored
View File

@@ -1,111 +0,0 @@
/* Copyright (c) 2010, Antonie Jovanoski
*
* All rights reserved.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Contact e-mail: Antonie Jovanoski <minimoog77_at_gmail.com>
*/
#include <QtDebug>
#include <QNetworkRequest>
#include <QNetworkReply>
#include "qtweetfollowersid.h"
/**
* Constructor
*/
QTweetFollowersID::QTweetFollowersID(QObject *parent) :
QTweetNetBase(parent)
{
}
/**
* Constructor
* @param oauthTwitter OAuthTwitter object
* @param parent parent QObject
*/
QTweetFollowersID::QTweetFollowersID(OAuthTwitter *oauthTwitter, QObject *parent) :
QTweetNetBase(oauthTwitter, parent)
{
}
/**
* Starts fetching one page of id's
* @param user the ID of the user for whom to return results for.
* @param cursor use from signal response nextCursor and prevCursor to allow paging back and forth
*/
void QTweetFollowersID::fetch(qint64 user, const QString &cursor)
{
QUrl url("http://api.twitter.com/1/followers/ids.json");
url.addQueryItem("user_id", QString::number(user));
url.addQueryItem("cursor", cursor);
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
/**
* Starts fetching one page of id's
* @param screenName the screen name of the user for whom to return results for.
* @param cursor use from signal response nextCursor and prevCursor to allow paging back and forth
*/
void QTweetFollowersID::fetch(const QString &screenName, const QString &cursor)
{
QUrl url("http://api.twitter.com/1/followers/ids.json");
url.addQueryItem("screen_name", screenName);
url.addQueryItem("cursor", cursor);
QNetworkRequest req(url);
if (isAuthenticationEnabled()) {
QByteArray oauthHeader = oauthTwitter()->generateAuthorizationHeader(url, OAuth::GET);
req.setRawHeader(AUTH_HEADER, oauthHeader);
}
QNetworkReply *reply = oauthTwitter()->networkAccessManager()->get(req);
connect(reply, SIGNAL(finished()), this, SLOT(reply()));
}
void QTweetFollowersID::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg)
{
if (ok) {
QList<qint64> idList;
QVariantMap respMap = json.toMap();
QVariantList idVarList = respMap["ids"].toList();
foreach (const QVariant& idVar, idVarList)
idList.append(idVar.toLongLong());
QString nextCursor = respMap["next_cursor_str"].toString();
QString prevCursor = respMap["previous_cursor_str"].toString();
emit parsedIDs(idList, nextCursor, prevCursor);
} else {
qDebug() << "QTweetFollowersID parser error: " << errorMsg;
setLastErrorMessage(errorMsg);
emit error(JsonParsingError, errorMsg);
}
}

Some files were not shown because too many files have changed in this diff Show More