+*.patch

+ if env["PLATFORM"] != "darwin" or env["target"] == "native" :

+ sources += [

+ "src/libs/program_options/src/parsers.cpp",

+ ]

+

+ if env["PLATFORM"] == "win32" :

+ myenv.Append(CFLAGS = ["/TP"])

+ else :

+ myenv.Append(CFLAGS = ["-x", "c++"])

+CLangDiagnosticsFlags

+CLangDiagnosticsFlagsTool.sh

+CLangDiagnosticsFlagsTool

+clang-diagnostics-overview.*

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <iostream>

+#include <set>

+#include <vector>

+#include <cassert>

+#include <boost/algorithm/string/predicate.hpp>

+#include <boost/graph/graph_traits.hpp>

+#include <boost/graph/adjacency_list.hpp>

+#include <boost/graph/topological_sort.hpp>

+#include <boost/graph/topological_sort.hpp>

+#include <boost/graph/graphviz.hpp>

+

+// -----------------------------------------------------------------------------

+// Include diagnostics data from CLang

+// -----------------------------------------------------------------------------

+

+#define DIAG(name, a, b, c, d, e, f, g) name,

+

+namespace diag {

+ enum LexKinds {

+#include <clang/Basic/DiagnosticLexKinds.inc>

+#include <clang/Basic/DiagnosticParseKinds.inc>

+#include <clang/Basic/DiagnosticCommonKinds.inc>

+#include <clang/Basic/DiagnosticDriverKinds.inc>

+#include <clang/Basic/DiagnosticFrontendKinds.inc>

+#include <clang/Basic/DiagnosticSemaKinds.inc>

+ };

+}

+

+#define GET_DIAG_ARRAYS

+#include <clang/Basic/DiagnosticGroups.inc>

+#undef GET_DIAG_ARRAYS

+

+struct DiagTableEntry {

+ const char* name;

+ const short* array;

+ const short* group;

+};

+

+static const DiagTableEntry diagnostics[] = {

+#define GET_DIAG_TABLE

+#include <clang/Basic/DiagnosticGroups.inc>

+#undef GET_DIAG_TABLE

+};

+static const size_t diagnostics_count = sizeof(diagnostics) / sizeof(diagnostics[0]);

+

+// -----------------------------------------------------------------------------

+

+using namespace boost;

+

+struct Properties {

+ Properties() : missing(false), redundant(false) {

+ }

+

+ std::string name;

+ bool have;

+ bool implicitHave;

+ bool dontWant;

+ bool implicitDontWant;

+ bool ignored;

+ bool available;

+ bool missing;

+ bool redundant;

+ bool alreadyCovered;

+};

+

+class GraphVizLabelWriter {

+ public:

+ GraphVizLabelWriter(const std::vector<Properties>& properties) : properties(properties) {

+ }

+

+ template <class VertexOrEdge>

+ void operator()(std::ostream& out, const VertexOrEdge& v) const {

+ std::string color;

+ if (properties[v].missing) {

+ color = "orange";

+ }

+ else if (properties[v].redundant) {

+ color = "lightblue";

+ }

+ else if (properties[v].have) {

+ color = "darkgreen";

+ }

+ else if (properties[v].implicitHave) {

+ color = "green";

+ }

+ else if (properties[v].dontWant) {

+ color = "red";

+ }

+ else if (properties[v].implicitDontWant) {

+ color = "pink";

+ }

+ else if (properties[v].ignored) {

+ color = "white";

+ }

+ else if (properties[v].available) {

+ color = "yellow";

+ }

+ else {

+ assert(false);

+ }

+ out << "[label=" << escape_dot_string(properties[v].name) << " fillcolor=\"" << color << "\" style=filled]";

+ }

+

+ private:

+ const std::vector<Properties> properties;

+};

+

+int main(int argc, char* argv[]) {

+ // Parse command-line arguments

+ std::set<std::string> have;

+ std::set<std::string> dontWant;

+ std::string outputDir;

+ for (int i = 1; i < argc; ++i) {

+ std::string arg(argv[i]);

+ if (starts_with(arg, "-W")) {

+ have.insert(arg.substr(2, arg.npos));

+ }

+ else if (starts_with(arg, "-w")) {

+ dontWant.insert(arg.substr(2, arg.npos));

+ }

+ else if (starts_with(arg, "-O")) {

+ outputDir = arg.substr(2, arg.npos) + "/";

+ }

+ }

+

+ // Build the graph and initialize properties

+ typedef adjacency_list<vecS, vecS, bidirectionalS> Graph;

+ typedef graph_traits<Graph>::vertex_descriptor Vertex;

+ Graph g(diagnostics_count);

+ std::vector<Properties> properties(num_vertices(g));

+ for (size_t i = 0; i < diagnostics_count; ++i) {

+ std::string name(diagnostics[i].name);

+ properties[i].name = name;

+ properties[i].implicitHave = properties[i].have = have.find(name) != have.end();

+ properties[i].implicitDontWant = properties[i].dontWant = dontWant.find(name) != dontWant.end();

+ properties[i].ignored = diagnostics[i].group == 0 && diagnostics[i].array == 0;

+ properties[i].alreadyCovered = false;

+ properties[i].available = true;

+ for (const short* j = diagnostics[i].group; j && *j != -1; ++j) {

+ add_edge(i, *j, g);

+ }

+ }

+

+ // Sort the diagnostics

+ std::list<Vertex> sortedDiagnostics;

+ boost::topological_sort(g, std::front_inserter(sortedDiagnostics));

+

+ // Propagate dontWant and have properties down

+ for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

+ graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

+ for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

+ properties[*adjacentIt].implicitDontWant = properties[*i].implicitDontWant || properties[*adjacentIt].implicitDontWant;

+ properties[*adjacentIt].implicitHave = properties[*i].implicitHave || properties[*adjacentIt].implicitHave;

+ }

+ }

+

+ // Propagate 'available' property upwards

+ for(std::list<Vertex>::const_reverse_iterator i = sortedDiagnostics.rbegin(); i != sortedDiagnostics.rend(); ++i) {

+ properties[*i].available = properties[*i].available && !properties[*i].implicitDontWant;

+ graph_traits<Graph>::in_edge_iterator edgesIt, edgesEnd;

+ graph_traits<Graph>::edge_descriptor edge;

+ for (tie(edgesIt, edgesEnd) = in_edges(*i, g); edgesIt != edgesEnd; ++edgesIt) {

+ properties[source(*edgesIt, g)].available = properties[source(*edgesIt, g)].available && properties[*i].available;

+ }

+ }

+

+ // Collect missing & redundant flags

+ std::set<std::string> missing;

+ std::set<std::string> redundant;

+ for(std::list<Vertex>::const_iterator i = sortedDiagnostics.begin(); i != sortedDiagnostics.end(); ++i) {

+ bool markChildrenCovered = true;

+ if (properties[*i].alreadyCovered) {

+ if (properties[*i].have) {

+ properties[*i].redundant = true;

+ redundant.insert(properties[*i].name);

+ }

+ }

+ else {

+ if (properties[*i].available) {

+ if (!properties[*i].implicitHave && !properties[*i].ignored) {

+ properties[*i].missing = true;

+ missing.insert(properties[*i].name);

+ }

+ }

+ else {

+ markChildrenCovered = false;

+ }

+ }

+ if (markChildrenCovered) {

+ graph_traits<Graph>::adjacency_iterator adjacentIt, adjacentEnd;

+ for (tie(adjacentIt, adjacentEnd) = adjacent_vertices(*i, g); adjacentIt != adjacentEnd; ++adjacentIt) {

+ properties[*adjacentIt].alreadyCovered = true;

+ }

+ }

+ }

+

+ // Write information

+ if (!missing.empty()) {

+ std::cout << "Missing diagnostic flags: ";

+ for(std::set<std::string>::const_iterator i = missing.begin(); i != missing.end(); ++i) {

+ std::cout << "-W" << *i << " ";

+ }

+ std::cout<< std::endl;

+ }

+

+ if (!redundant.empty()) {

+ std::cout << "Redundant diagnostic flags: ";

+ for(std::set<std::string>::const_iterator i = redundant.begin(); i != redundant.end(); ++i) {

+ std::cout << "-W" << *i << " ";

+ }

+ std::cout<< std::endl;

+ }

+

+ // Write graphviz file

+ if (!outputDir.empty()) {

+ std::ofstream f((outputDir + "clang-diagnostics-overview.dot").c_str());

+ write_graphviz(f, g, GraphVizLabelWriter(properties));

+ f.close();

+ }

+

+ return 0;

+}

+Import("env")

+

+#myenv = Environment()

+#myenv.Append(CPPPATH = ["."])

+#myenv.Program("CLangDiagnosticsFlagsTool", ["CLangDiagnosticsFlagsTool.cpp"])

+#

+#disabledDiagnostics = ["-wunreachable-code", "-wunused-macros", "-wmissing-noreturn", "-wlong-long", "-wcast-align", "-wglobal-constructors", "-wmissing-prototypes", "-wpadded", "-wshadow"]

+#clangDiagnosticsFlagsToolCommand = "BuildTools/CLang/CLangDiagnosticsFlagsTool -O" + env.Dir(".").abspath + " " + " ".join(disabledDiagnostics) + " "

+#clangDiagnosticsFlagsToolCommand += " ".join([flag for flag in env["CXXFLAGS"] if flag.startswith("-W")])

+#clangDiagnosticsFlagsToolCommand += "\n"

+#clangDiagnosticsFlagsToolCommand += "dot -Tpng " + env.Dir(".").abspath + "/clang-diagnostics-overview.dot > " + env.Dir(".").abspath + "/clang-diagnostics-overview.png\n"

+#v = env.WriteVal("#/BuildTools/CLang/CLangDiagnosticsFlagsTool.sh", env.Value(clangDiagnosticsFlagsToolCommand))

+#env.AddPostAction(v, Chmod(v[0], 0755))

+#

+#

+#!/usr/bin/env python

+

+import os, sys

+

+foundBadHeaders = False

+

+for (path, dirs, files) in os.walk(".") :

+ if "3rdParty" in path or ".sconf" in path or ".framework" in path :

+ continue

+ if not "Swiften" in path :

+ continue

+

+ for filename in [os.path.join(path, file) for file in files if file.endswith(".h")] :

+ file = open(filename, "r")

+ for line in file.readlines() :

+ for include in ["iostream", "algorithm", "cassert", "boost/bind.hpp", "boost/filesystem.hpp", "Base/foreach.h", "Base/Log.h", "boost/date_time/date_time.hpp", "boost/filesystem/filesystem.hpp"] :

+ if "#include" in line and include in line and not "Base/Log" in filename :

+ print "Found " + include + " include in " + filename

+ foundBadHeaders = True

+

+sys.exit(foundBadHeaders)

+ for filename in [os.path.join(path, file) for file in files if (file.endswith(".cpp") or file.endswith(".h")) and not "ui_" in file and not "moc_" in file and not "qrc_" in file and not "BuildVersion.h" in file and not "Swiften.h" in file and not "swiften-config.h" in file and not "linit.cpp" in file ] :

+vars.Add(BoolVariable("allow_warnings", "Allow compilation warnings during compilation", "yes"))

+ env.Append(CXXFLAGS = ["-Wlogical-op"])

+ if "clang" in env["CC"] :

+ env.Append(CXXFLAGS = ["-W#warnings", "-W-Wc++0x-compat", "-Wc++0x-compat", "-Waddress-of-temporary", "-Wambiguous-member-template", "-Warray-bounds", "-Watomic-properties", "-Wbind-to-temporary-copy", "-Wbuiltin-macro-redefined", "-Wc++-compat", "-Wc++0x-extensions", "-Wcomments", "-Wconditional-uninitialized", "-Wconstant-logical-operand", "-Wdeclaration-after-statement", "-Wdeprecated", "-Wdeprecated-implementations", "-Wdeprecated-writable-strings", "-Wduplicate-method-arg", "-Wempty-body", "-Wendif-labels", "-Wenum-compare", "-Wformat=2", "-Wfour-char-constants", "-Wgnu", "-Wincomplete-implementation", "-Winvalid-noreturn", "-Winvalid-offsetof", "-Winvalid-token-paste", "-Wlocal-type-template-args", "-Wmethod-signatures", "-Wmicrosoft", "-Wmissing-declarations", "-Wnon-pod-varargs", "-Wnonfragile-abi2", "-Wnull-dereference", "-Wout-of-line-declaration", "-Woverlength-strings", "-Wpacked", "-Wpointer-arith", "-Wpointer-sign", "-Wprotocol", "-Wreadonly-setter-attrs", "-Wselector", "-Wshift-overflow", "-Wshift-sign-overflow", "-Wstrict-selector-match", "-Wsuper-class-method-mismatch", "-Wtautological-compare", "-Wtypedef-redefinition", "-Wundeclared-selector", "-Wunknown-attributes", "-Wunknown-warning-option", "-Wunnamed-type-template-args", "-Wunused-exception-parameter", "-Wunused-member-function", "-Wused-but-marked-unused", "-Wvariadic-macros"])

+# To enable:

+# "-Wheader-hygiene"

+# "-Wnon-gcc",

+# "-Wweak-vtables",

+# "-Wlarge-by-value-copy",

+ env.Append(LIBS = ["user32", "crypt32", "dnsapi", "ws2_32", "wsock32", "Advapi32"])

+ env.Append(FRAMEWORKS = ["IOKit", "AppKit", "SystemConfiguration"])

+env["TEST_CREATE_LIBRARIES"] = "create_test_libraries" in ARGUMENTS

+ env["XCODE_ARCH_FLAGS"] = ["-arch", "armv6", "-arch", "armv7"]

+ sdkVer = "4.3"

+def CheckPKG(context, name):

+ context.Message( 'Checking for package %s... ' % name )

+ ret = context.TryAction('pkg-config --exists \'%s\'' % name)[0]

+ context.Result( ret )

+ return ret

+

+# GConf

+env["HAVE_GCONF"] = 0

+if env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :

+ gconf_env = conf_env.Clone()

+ conf = Configure(gconf_env, custom_tests = {"CheckPKG": CheckPKG})

+ if conf.CheckPKG("gconf-2.0") :

+ gconf_bare_env = Environment()

+ gconf_bare_env.ParseConfig('pkg-config --cflags gconf-2.0 --libs gconf-2.0')

+ gconf_flags = {

+ "LIBS": gconf_bare_env["LIBS"],

+ "CCFLAGS": gconf_bare_env["CCFLAGS"],

+ "CPPPATH": gconf_bare_env["CPPPATH"],

+ "CPPDEFINES": gconf_bare_env["CPPDEFINES"],

+ }

+ gconf_env.MergeFlags(gconf_flags)

+ if conf.CheckCHeader("gconf/gconf-client.h") and conf.CheckLib("gconf-2") :

+ env["HAVE_GCONF"] = 1

+ env["GCONF_FLAGS"] = {

+ "LIBS": gconf_env["LIBS"],

+ "CCFLAGS": gconf_env["CCFLAGS"],

+ "CPPPATH": gconf_env["CPPPATH"],

+ "CPPDEFINES": gconf_env["CPPDEFINES"],

+ }

+ conf.Finish()

+

+# Build tools

+env.SConscript(dirs = ["#/BuildTools/CLang"])

+

+ def createAppBundle(env, bundle, version = "1.0", resources = [], frameworks = [], info = {}, handlesXMPPURIs = False) :

+ if handlesXMPPURIs :

+ plist += """<key>CFBundleURLTypes</key>

+<array>

+ <dict>

+ <key>CFBundleURLName</key>

+ <string>XMPP URL</string>

+ <key>CFBundleURLSchemes</key>

+ <array>

+ <string>xmpp</string>

+ </array>

+ </dict>

+</array>\n"""

+Copyright (c) 2011, Vlad Voicu

+ for running the unit tests.

+

+Installing

+----------

+- To install swift in /usr/local, run

+ ./scons SWIFT_INSTALLDIR=/usr/local /usr/local

+class EchoPayload : public Swift::Payload {

+class EchoPayloadParser : public Swift::GenericPayloadParser<EchoPayload> {

+class EchoPayloadParserFactory : public Swift::GenericPayloadParserFactory<EchoPayloadParser> {

+class EchoPayloadSerializer : public Swift::GenericPayloadSerializer<EchoPayload> {

+ # Temporarily disabling c++0x mode because of problems with boost::thread

+ # on some platforms

+ #cpp0x = True

+ if env["TEST_CREATE_LIBRARIES"] :

+ lib = myenv.StaticLibrary("Swift_UnitTests", env["UNITTEST_SOURCES"] + env["UNITTEST_OBJECTS"])

+ myenv.Program("checker", lib)

+ else :

+ checker = myenv.Program("checker", env["UNITTEST_SOURCES"] + env["UNITTEST_OBJECTS"])

+ for i in ["HOME", "USERPROFILE", "APPDATA"]:

+ if os.environ.get(i, "") :

+ myenv["ENV"][i] = os.environ[i]

+ myenv.Test(checker, is_checker = True)

+#include <SwifTools/Cocoa/CocoaAction.h>

+#include <iostream>

+#include <Swiften/Base/foreach.h>

+#include <lualib.h>

+ if env["PLATFORM"] == "win32" :

+ myenv.Append(CFLAGS = ["/TP"])

+ else :

+ myenv.Append(CFLAGS = ["-x", "c++"])

+#include "sluift.h"

+#include <lauxlib.h>

+#include <Swiften/Base/foreach.h>

+ ClientOptions& getOptions() {

+ return options;

+ }

+

+ ClientOptions options;

+ client->getOptions().useStreamCompression = lua_toboolean(L, -1);

+ client->getOptions().useTLS = (useTLS ? ClientOptions::UseTLSWhenAvailable : ClientOptions::NeverUseTLS);

+if swiftools_env["PLATFORM"] != "darwin" or swiftools_env["target"] == "native" :

+ env.Append(UNITTEST_SOURCES = [

+ File("UnitTest/ApplicationPathProviderTest.cpp")

+ ])

+/*

+ * Copyright (c) 2010 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <SwifTools/Cocoa/CocoaAction.h>

+Import("swiftools_env", "env")

+

+sources = []

+if swiftools_env["PLATFORM"] == "darwin" and swiftools_env["target"] == "native" :

+ sources += ["CocoaAction.mm"]

+

+objects = swiftools_env.StaticObject(sources)

+swiftools_env.Append(SWIFTOOLS_OBJECTS = [objects])

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include "LastLineTracker.h"

+

+using namespace Swift;

+

+LastLineTracker::LastLineTracker() {

+ lastFocus = true;

+ shouldMove = false;

+}

+

+void LastLineTracker::setHasFocus(bool focus) {

+ if (!focus && lastFocus) {

+ shouldMove = true;

+ lastFocus = focus;

+ return;

+ }

+ shouldMove = false;

+ lastFocus = focus;

+}

+

+bool LastLineTracker::getShouldMoveLastLine() {

+ bool ret = shouldMove;

+ shouldMove = false;

+ return ret;

+}

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#pragma once

+

+namespace Swift {

+ class LastLineTracker {

+ public:

+ LastLineTracker();

+ void setHasFocus(bool focus);

+ bool getShouldMoveLastLine();

+ private:

+ bool lastFocus;

+ bool shouldMove;

+ };

+}

+static boost::regex linkifyRegexp("^(https?://|xmpp:).*");

+ "LastLineTracker.cpp",

+ "URIHandler",

+ "Cocoa",

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+namespace Swift {

+ class MacOSXURIHandler : public URIHandler {

+ public:

+ MacOSXURIHandler();

+ virtual ~MacOSXURIHandler();

+

+ virtual void start();

+ virtual void stop();

+

+ private:

+ class Private;

+ Private* p;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <SwifTools/URIHandler/MacOSXURIHandler.h>

+

+#include <Cocoa/Cocoa.h>

+#include <iostream>

+

+using namespace Swift;

+

+@interface MacOSXURIEventHandler : NSObject {

+ URIHandler* handler;

+}

+- (id) initWithHandler: (URIHandler*) handler;

+- (void) getUrl: (NSAppleEventDescriptor*) event withReplyEvent: (NSAppleEventDescriptor*) replyEvent;

+

+@end

+@implementation MacOSXURIEventHandler

+ - (id) initWithHandler: (URIHandler*) h {

+ if ([super init]) {

+ handler = h;

+ }

+ return self;

+ }

+

+ - (void) getUrl: (NSAppleEventDescriptor*) event withReplyEvent: (NSAppleEventDescriptor*) replyEvent {

+ (void) replyEvent;

+ NSString* url = [[event paramDescriptorForKeyword:keyDirectObject] stringValue];

+ handler->onURI(std::string([url UTF8String]));

+ }

+@end

+

+class MacOSXURIHandler::Private {

+ public:

+ MacOSXURIEventHandler* eventHandler;

+};

+

+MacOSXURIHandler::MacOSXURIHandler() {

+ p = new Private();

+ p->eventHandler = [[MacOSXURIEventHandler alloc] initWithHandler: this];

+}

+

+MacOSXURIHandler::~MacOSXURIHandler() {

+ [p->eventHandler release];

+ delete p;

+}

+

+void MacOSXURIHandler::start() {

+ [[NSAppleEventManager sharedAppleEventManager] setEventHandler:p->eventHandler andSelector:@selector(getUrl:withReplyEvent:) forEventClass:kInternetEventClass andEventID:kAEGetURL];

+ NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];

+ LSSetDefaultHandlerForURLScheme((CFStringRef)@"xmpp", (CFStringRef)bundleID);

+}

+

+void MacOSXURIHandler::stop() {

+ [[NSAppleEventManager sharedAppleEventManager] removeEventHandlerForEventClass:kInternetEventClass andEventID:kAEGetURL];

+}

+ void registerAppAsDefaultXMPPURIHandler();

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <SwifTools/URIHandler/MacOSXURIHandlerHelpers.h>

+

+#include <Cocoa/Cocoa.h>

+

+namespace Swift {

+ void registerAppAsDefaultXMPPURIHandler() {

+ NSString* bundleID = [[NSBundle mainBundle] bundleIdentifier];

+ LSSetDefaultHandlerForURLScheme((CFStringRef)@"xmpp", (CFStringRef)bundleID);

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+namespace Swift {

+ class NullURIHandler : public URIHandler {

+ public:

+ virtual void start() {

+ }

+

+ virtual void stop() {

+ }

+ };

+}

+Import("swiftools_env", "env")

+

+sources = [

+ "XMPPURI.cpp",

+ "URIHandler.cpp",

+ ]

+

+if swiftools_env["PLATFORM"] == "darwin" and swiftools_env["target"] == "native" :

+ sources += [

+ "MacOSXURIHandler.mm",

+ "MacOSXURIHandlerHelpers.mm",

+ ]

+elif swiftools_env["PLATFORM"] == "win32" :

+ sources += []

+else :

+ sources += []

+

+objects = swiftools_env.StaticObject(sources)

+swiftools_env.Append(SWIFTOOLS_OBJECTS = [objects])

+

+env.Append(UNITTEST_SOURCES = [

+ File("UnitTest/XMPPURITest.cpp"),

+ ])

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <SwifTools/URIHandler/URIHandler.h>

+

+using namespace Swift;

+

+URIHandler::URIHandler() {

+}

+

+URIHandler::~URIHandler() {

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <Swiften/Base/boost_bsignals.h>

+

+namespace Swift {

+ class URIHandler {

+ public:

+ URIHandler();

+ virtual ~URIHandler();

+

+ boost::signal<void (const std::string&)> onURI;

+ };

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include <SwifTools/URIHandler/XMPPURI.h>

+

+using namespace Swift;

+

+class XMPPURITest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(XMPPURITest);

+ CPPUNIT_TEST(testFromString_Authority);

+ CPPUNIT_TEST(testFromString_AuthorityWithPath);

+ CPPUNIT_TEST(testFromString_AuthorityWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithPathAndFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithIntlChars);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_AuthorityWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_Path);

+ CPPUNIT_TEST(testFromString_PathWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithIntlChars);

+ CPPUNIT_TEST(testFromString_PathWithInvalidEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar);

+ CPPUNIT_TEST(testFromString_PathWithIncompleteEscapedChar2);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParameters);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithoutParametersWithFragment);

+ CPPUNIT_TEST(testFromString_PathWithQueryWithParametersWithFragment);

+ CPPUNIT_TEST(testFromString_NoPrefix);

+ CPPUNIT_TEST_SUITE_END();

+

+ public:

+ void testFromString_Authority() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithPath() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_AuthorityWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithPathAndFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://foo@bar.com/baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("foo@bar.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://nasty!%23$%25()*+,-.;=\%3F\%5B\%5C\%5D\%5E_\%60\%7B\%7C\%7D~node@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$\%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getAuthority());

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+

+ void testFromString_AuthorityWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+

+ void testFromString_AuthorityWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_AuthorityWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp://test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getAuthority());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_Path() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ }

+

+ void testFromString_PathWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:baz@example.com#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("baz@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_PathWithIntlChars() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:nasty!%23$%25()*+,-.;=\%3F\%5B\%5C\%5D\%5E_\%60\%7B\%7C\%7D~node@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID("nasty!#$\%()*+,-.;=?[\\]^_`{|}~node@example.com"), testling.getPath());

+ }

+

+ void testFromString_PathWithInvalidEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test%%@example.com");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithIncompleteEscapedChar() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithIncompleteEscapedChar2() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com%1");

+

+ CPPUNIT_ASSERT_EQUAL(JID(), testling.getPath());

+ }

+

+ void testFromString_PathWithQueryWithoutParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ }

+

+ void testFromString_PathWithQueryWithParameters() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ }

+

+ void testFromString_PathWithQueryWithoutParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_PathWithQueryWithParametersWithFragment() {

+ XMPPURI testling = XMPPURI::fromString("xmpp:test@example.com?message;subject=Test%20Message;body=Here%27s%20a%20test%20message#myfragment");

+

+ CPPUNIT_ASSERT_EQUAL(JID("test@example.com"), testling.getPath());

+ CPPUNIT_ASSERT_EQUAL(std::string("message"), testling.getQueryType());

+ CPPUNIT_ASSERT_EQUAL(std::string("Test Message"), get(testling.getQueryParameters(), "subject"));

+ CPPUNIT_ASSERT_EQUAL(std::string("Here's a test message"), get(testling.getQueryParameters(), "body"));

+ CPPUNIT_ASSERT_EQUAL(std::string("myfragment"), testling.getFragment());

+ }

+

+ void testFromString_NoPrefix() {

+ XMPPURI testling = XMPPURI::fromString("baz@example.com");

+

+ CPPUNIT_ASSERT(testling.isNull());

+ }

+

+ private:

+ std::string get(const std::map<std::string, std::string>& m, const std::string& k) {

+ std::map<std::string, std::string>::const_iterator i = m.find(k);

+ return i == m.end() ? "" : i->second;

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(XMPPURITest);

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <SwifTools/URIHandler/XMPPURI.h>

+

+#include <boost/algorithm/string/predicate.hpp>

+#include <boost/algorithm/string/find_format.hpp>

+#include <boost/algorithm/string/formatter.hpp>

+#include <boost/algorithm/string/find_iterator.hpp>

+#include <boost/algorithm/string/split.hpp>

+#include <boost/algorithm/string/classification.hpp>

+#include <sstream>

+#include <stdexcept>

+#include <vector>

+

+using namespace Swift;

+

+// Should be in anonymous namespace, but older GCCs complain if we do that

+struct PercentEncodedCharacterFinder {

+ template<typename Iterator>

+ boost::iterator_range<Iterator> operator()(Iterator begin, Iterator end) {

+ boost::iterator_range<Iterator> r = boost::first_finder("%")(begin, end);

+ if (r.end() == end) {

+ return r;

+ }

+ else {

+ if (r.end() + 1 == end || r.end() + 2 == end) {

+ throw std::runtime_error("Incomplete escape character");

+ }

+ else {

+ r.advance_end(2);

+ return r;

+ }

+ }

+ }

+};

+

+struct PercentUnencodeFormatter {

+ template<typename FindResult>

+ std::string operator()(const FindResult& match) const {

+ std::stringstream s;

+ s << std::hex << std::string(match.begin() + 1, match.end());

+ unsigned int value;

+ s >> value;

+ if (s.fail() || s.bad()) {

+ throw std::runtime_error("Invalid escape character");

+ }

+ unsigned char charValue = static_cast<unsigned char>(value);

+ return std::string(reinterpret_cast<const char*>(&charValue), 1);

+ }

+};

+

+namespace {

+ std::string unescape(const std::string& s) {

+ try {

+ return boost::find_format_all_copy(s, PercentEncodedCharacterFinder(), PercentUnencodeFormatter());

+ }

+ catch (const std::exception&) {

+ return "";

+ }

+ }

+}

+

+XMPPURI::XMPPURI() {

+}

+

+XMPPURI XMPPURI::fromString(const std::string& s) {

+ XMPPURI result;

+ if (boost::starts_with(s, "xmpp:")) {

+ std::string uri = s.substr(5, s.npos);

+ bool parsePath = true;

+ bool parseQuery = true;

+ bool parseFragment = true;

+

+ // Parse authority

+ if (boost::starts_with(uri, "//")) {

+ size_t i = uri.find_first_of("/#?", 2);

+ result.setAuthority(JID(unescape(uri.substr(2, i - 2))));

+ if (i == uri.npos) {

+ uri = "";

+ parsePath = parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '?') {

+ parsePath = false;

+ }

+ else if (uri[i] == '#') {

+ parseQuery = parsePath = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+

+ // Parse path

+ if (parsePath) {

+ size_t i = uri.find_first_of("#?");

+ result.setPath(JID(unescape(uri.substr(0, i))));

+ if (i == uri.npos) {

+ uri = "";

+ parseQuery = parseFragment = false;

+ }

+ else {

+ if (uri[i] == '#') {

+ parseQuery = false;

+ }

+ uri = uri.substr(i + 1, uri.npos);

+ }

+ }

+

+ // Parse query

+ if (parseQuery) {

+ size_t end = uri.find_first_of("#");

+ std::string query = uri.substr(0, end);

+ bool haveType = false;

+ typedef boost::split_iterator<std::string::iterator> split_iterator;

+ for (split_iterator it = boost::make_split_iterator(query, boost::first_finder(";")); it != split_iterator(); ++it) {

+ if (haveType) {

+ std::vector<std::string> keyValue;

+ boost::split(keyValue, *it, boost::is_any_of("="));

+ if (keyValue.size() == 1) {

+ result.addQueryParameter(unescape(keyValue[0]), "");

+ }

+ else if (keyValue.size() >= 2) {

+ result.addQueryParameter(unescape(keyValue[0]), unescape(keyValue[1]));

+ }

+ }

+ else {

+ result.setQueryType(unescape(boost::copy_range<std::string>(*it)));

+ haveType = true;

+ }

+ }

+ uri = (end == uri.npos ? "" : uri.substr(end + 1, uri.npos));

+ }

+

+ // Parse fragment

+ if (parseFragment) {

+ result.setFragment(unescape(uri));

+ }

+ }

+ return result;

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <map>

+

+#include <Swiften/JID/JID.h>

+

+namespace Swift {

+ class XMPPURI {

+ public:

+ XMPPURI();

+

+ const JID& getAuthority() const {

+ return authority;

+ }

+

+ void setAuthority(const JID& j) {

+ authority = j;

+ }

+

+ const JID& getPath() const {

+ return path;

+ }

+

+ void setPath(const JID& j) {

+ path = j;

+ }

+

+ const std::string& getQueryType() const {

+ return queryType;

+ }

+

+ void setQueryType(const std::string& q) {

+ queryType = q;

+ }

+

+ const std::map<std::string, std::string>& getQueryParameters() const {

+ return queryParameters;

+ }

+

+ void addQueryParameter(const std::string& key, const std::string& path) {

+ queryParameters[key] = path;

+ }

+

+ const std::string& getFragment() const {

+ return fragment;

+ }

+

+ void setFragment(const std::string& f) {

+ fragment = f;

+ }

+

+ bool isNull() const {

+ return !authority.isValid() && !path.isValid();

+ }

+

+ static XMPPURI fromString(const std::string&);

+

+ private:

+ JID authority;

+ JID path;

+ std::string fragment;

+ std::string queryType;

+ std::map<std::string, std::string> queryParameters;

+ };

+}

+/*

+ * Copyright (c) 2011 Vlad Voicu

+ * Licensed under the Simplified BSD license.

+ * See Documentation/Licenses/BSD-simplified.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "SwifTools/LastLineTracker.h"

+

+using namespace Swift;

+

+class LastLineTrackerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(LastLineTrackerTest);

+ CPPUNIT_TEST(testFocusNormal);

+ CPPUNIT_TEST(testFocusOut);

+ CPPUNIT_TEST(testFocusOtherTab);

+ CPPUNIT_TEST(testRepeatedFocusOut);

+ CPPUNIT_TEST(testRepeatedFocusIn);

+ CPPUNIT_TEST_SUITE_END();

+ public:

+ LastLineTrackerTest () {

+ };

+ void testFocusNormal() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testFocusOut() {

+ LastLineTracker testling;

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testFocusOtherTab() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+

+ void testRepeatedFocusOut() {

+ LastLineTracker testling;

+ testling.setHasFocus(true);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(false, testling.getShouldMoveLastLine());

+ }

+ void testRepeatedFocusIn() {

+ LastLineTracker testling;

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ testling.setHasFocus(true);

+ testling.setHasFocus(false);

+ CPPUNIT_ASSERT_EQUAL(true, testling.getShouldMoveLastLine());

+ }

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(LastLineTrackerTest);

+ File("TabCompleteTest.cpp"),

+ File("LastLineTrackerTest.cpp"),

+#include <Swiften/Base/foreach.h>

+ else if (boost::shared_ptr<RequestJoinMUCUIEvent> joinEvent = boost::dynamic_pointer_cast<RequestJoinMUCUIEvent>(event)) {

+ joinMUCWindow_->setMUC(joinEvent->getRoom());

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <Swift/Controllers/ChatMessageSummarizer.h>

+

+#include <Swiften/Base/format.h>

+#include <Swift/Controllers/Intl.h>

+#include <Swiften/Base/foreach.h>

+

+using namespace Swift;

+using namespace std;

+

+string ChatMessageSummarizer::getSummary(const string& current, const vector<UnreadPair>& unreads) {

+ vector<UnreadPair> others;

+ int currentUnread = 0;

+ int otherCount = 0;

+ foreach (UnreadPair unread, unreads) {

+ if (unread.first == current) {

+ currentUnread += unread.second;

+ } else {

+ if (unread.second > 0) {

+ otherCount += unread.second;

+ others.push_back(unread);

+ }

+ }

+ }

+ string myString(current);

+

+ if (currentUnread > 0) {

+ string result(QT_TRANSLATE_NOOP("", "%1% (%2%)"));

+ myString = str(format(result) % current % currentUnread);

+ }

+

+ if (others.size() > 1) {

+ string result(QT_TRANSLATE_NOOP("", "%1% and %2% others (%3%)"));

+ myString = str(format(result) % myString % others.size() % otherCount);

+ } else if (others.size() > 0) {

+ string result(QT_TRANSLATE_NOOP("", "%1%, %2% (%3%)"));

+ myString = str(format(result) % myString % others[0].first % otherCount);

+ }

+ return myString;

+}

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <vector>

+#include <utility>

+#include <string>

+

+namespace Swift {

+typedef std::pair<std::string, int> UnreadPair;

+

+ class ChatMessageSummarizer {

+ public:

+ std::string getSummary(const std::string& current, const std::vector<UnreadPair>& unreads);

+ };

+}

+#include <Swiften/Base/foreach.h>

+#include <Swift/Controllers/XMPPURIController.h>

+ URIHandler* uriHandler,

+ uriHandler_(uriHandler),

+ xmppURIController_ = new XMPPURIController(uriHandler_, uiEventStream_);

+

+ delete xmppURIController_;

+ class URIHandler;

+ class XMPPURIController;

+ URIHandler* uriHandler,

+ URIHandler* uriHandler_;

+ XMPPURIController* xmppURIController_;

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+

+#include <Swiften/Base/foreach.h>

+#include <Swiften/Base/foreach.h>

+ "XMPPURIController.cpp",

+ "ChatMessageSummarizer.cpp",

+ File("UnitTest/ChatMessageSummarizerTest.cpp"),

+

+#include <Swiften/JID/JID.h>

+ RequestJoinMUCUIEvent(const JID& room = JID()) : room(room) {

+

+ const JID& getRoom() const {

+ return room;

+ }

+

+ private:

+ JID room;

+/*

+ * Copyright (c) 2011 Kevin Smith

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <cppunit/extensions/HelperMacros.h>

+#include <cppunit/extensions/TestFactoryRegistry.h>

+

+#include "Swift/Controllers/ChatMessageSummarizer.h"

+

+using namespace Swift;

+using namespace std;

+

+class ChatMessageSummarizerTest : public CppUnit::TestFixture {

+ CPPUNIT_TEST_SUITE(ChatMessageSummarizerTest);

+ CPPUNIT_TEST(testEmpty);

+ CPPUNIT_TEST(testCurrentNone);

+ CPPUNIT_TEST(testCurrentCount);

+ CPPUNIT_TEST(testCurrentCountOthersNone);

+ CPPUNIT_TEST(testCurrentCountOtherCount);

+ CPPUNIT_TEST(testCurrentNoneOtherCount);

+ CPPUNIT_TEST(testCurrentCountOthersCount);

+ CPPUNIT_TEST(testCurrentNoneOthersCount);

+ CPPUNIT_TEST(testCurrentCountSomeOthersCount);

+ CPPUNIT_TEST_SUITE_END();

+

+public:

+ ChatMessageSummarizerTest() {};

+

+ void setUp() {

+

+ }

+

+ void testEmpty() {

+ string current("");

+ vector<UnreadPair> unreads;

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bob", 0));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(current, summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bob", 3));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOthersNone() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 3));

+ unreads.push_back(UnreadPair("Betty", 0));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 3));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (3), Betty (7)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNoneOtherCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 0));

+ unreads.push_back(UnreadPair("Bob", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob, Betty (7)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentNoneOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Bob", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Bob", 11));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+ void testCurrentCountSomeOthersCount() {

+ string current("Bob");

+ vector<UnreadPair> unreads;

+ unreads.push_back(UnreadPair("Bert", 2));

+ unreads.push_back(UnreadPair("Beverly", 0));

+ unreads.push_back(UnreadPair("Bob", 11));

+ unreads.push_back(UnreadPair("Beatrice", 0));

+ unreads.push_back(UnreadPair("Betty", 7));

+ ChatMessageSummarizer summary;

+ CPPUNIT_ASSERT_EQUAL(string("Bob (11) and 2 others (9)"), summary.getSummary(current, unreads));

+ }

+

+};

+

+CPPUNIT_TEST_SUITE_REGISTRATION(ChatMessageSummarizerTest);

+#include <Swiften/Base/foreach.h>

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <Swift/Controllers/XMPPURIController.h>

+

+#include <boost/bind.hpp>

+#include <boost/smart_ptr/make_shared.hpp>

+

+#include <SwifTools/URIHandler/URIHandler.h>

+#include <SwifTools/URIHandler/XMPPURI.h>

+#include <Swift/Controllers/UIEvents/UIEventStream.h>

+#include <Swift/Controllers/UIEvents/RequestJoinMUCUIEvent.h>

+#include <Swift/Controllers/UIEvents/RequestChatUIEvent.h>

+

+using namespace Swift;

+

+XMPPURIController::XMPPURIController(URIHandler* uriHandler, UIEventStream* uiEventStream) : uriHandler(uriHandler), uiEventStream(uiEventStream) {

+ uriHandler->onURI.connect(boost::bind(&XMPPURIController::handleURI, this, _1));

+}

+

+XMPPURIController::~XMPPURIController() {

+ uriHandler->onURI.disconnect(boost::bind(&XMPPURIController::handleURI, this, _1));

+}

+

+void XMPPURIController::handleURI(const std::string& s) {

+ XMPPURI uri = XMPPURI::fromString(s);

+ if (!uri.isNull()) {

+ if (uri.getQueryType() == "join") {

+ uiEventStream->send(boost::make_shared<RequestJoinMUCUIEvent>(uri.getPath()));

+ }

+ else {

+ uiEventStream->send(boost::make_shared<RequestChatUIEvent>(uri.getPath()));

+ }

+ }

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <string>

+#include <Swiften/Base/boost_bsignals.h>

+

+namespace Swift {

+ class URIHandler;

+ class JID;

+ class UIEventStream;

+

+ class XMPPURIController {

+ public:

+ XMPPURIController(URIHandler* uriHandler, UIEventStream* uiEventStream);

+ ~XMPPURIController();

+

+ boost::signal<void (const JID&)> onStartChat;

+ boost::signal<void (const JID&)> onJoinMUC;

+

+ private:

+ void handleURI(const std::string&);

+

+ private:

+ URIHandler* uriHandler;

+ UIEventStream* uiEventStream;

+ };

+}

+swift-open-uri

+#include <vector>

+

+#include <Swift/Controllers/ChatMessageSummarizer.h>

+#include <Swift/QtUI/QtSwiftUtil.h>

+

+ std::vector<std::pair<std::string, int> > unreads;

+ unreads.push_back(std::pair<std::string, int>(Q2PSTRING(tab->windowTitle()), tab->getCount()));

+ std::string current(Q2PSTRING(qobject_cast<QtTabbable*>(tabs_->currentWidget())->windowTitle()));

+ ChatMessageSummarizer summary;

+ setWindowTitle(summary.getSummary(current, unreads).c_str());

+void QtChatView::addLastSeenLine() {

+ if (lineSeparator_.isNull()) {

+ lineSeparator_ = newInsertPoint_.clone();

+ lineSeparator_.setInnerXml(QString("<hr/>"));

+ newInsertPoint_.prependOutside(lineSeparator_);

+ }

+ else {

+ QWebElement lineSeparatorC = lineSeparator_.clone();

+ lineSeparatorC.removeFromDocument();

+ }

+ newInsertPoint_.prependOutside(lineSeparator_);

+}

+

+ void addLastSeenLine();

+ QWebElement lineSeparator_;

+

+

+ treeWidget_->setRosterModel(roster);

+ lastLineTracker_.setHasFocus(true);

+ else {

+ lastLineTracker_.setHasFocus(false);

+ }

+ }

+ if (lastLineTracker_.getShouldMoveLastLine()) {

+ /* should this be queued? */

+ messageLog_->addLastSeenLine();

+ /* if the line is added we should break the snippet */

+ appendToPrevious = false;

+ }

+ emit geometryChanged();

+#pragma once

+#include "SwifTools/LastLineTracker.h"

+

+ LastLineTracker lastLineTracker_;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "QtDBUSURIHandler.h"

+

+#include <QDBusAbstractAdaptor>

+#include <QDBusConnection>

+

+#include "QtSwiftUtil.h"

+

+using namespace Swift;

+

+namespace {

+ class DBUSAdaptor: public QDBusAbstractAdaptor {

+ Q_OBJECT

+ Q_CLASSINFO("D-Bus Interface", "im.swift.Swift.URIHandler");

+ public:

+ DBUSAdaptor(QtDBUSURIHandler* uriHandler) : QDBusAbstractAdaptor(uriHandler), uriHandler(uriHandler) {

+ }

+

+ public slots:

+ void openURI(const QString& uri) {

+ uriHandler->onURI(Q2PSTRING(uri));

+ }

+

+ private:

+ QtDBUSURIHandler* uriHandler;

+ };

+}

+

+QtDBUSURIHandler::QtDBUSURIHandler() {

+ new DBUSAdaptor(this);

+ QDBusConnection connection = QDBusConnection::sessionBus();

+ connection.registerService("im.swift.Swift.URIHandler");

+ connection.registerObject("/", this);

+}

+

+#include "QtDBUSURIHandler.moc"

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <QObject>

+#include <SwifTools/URIHandler/URIHandler.h>

+

+namespace Swift {

+ class QtDBUSURIHandler : public QObject, public URIHandler {

+ public:

+ QtDBUSURIHandler();

+ };

+}

+ * Copyright (c) 2010-2011 Kevin Smith

+ loginWidgetWrapper_ = new QWidget(this);

+ loginWidgetWrapper_->setSizePolicy(QSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding));

+ QBoxLayout *layout = new QBoxLayout(QBoxLayout::TopToBottom, loginWidgetWrapper_);

+ stack_->addWidget(loginWidgetWrapper_);

+ stack_->removeWidget(stack_->currentWidget());

+ stack_->addWidget(loginWidgetWrapper_);

+ stack_->setCurrentWidget(loginWidgetWrapper_);

+ stack_->removeWidget(loginWidgetWrapper_);

+ * Copyright (c) 2010-2011 Kevin Smith

+#pragma once

+ QWidget* loginWidgetWrapper_;

+

+#elif defined(HAVE_GROWL)

+

+#else

+#endif

+

+#if defined(SWIFTEN_PLATFORM_MACOSX)

+#include "QtURIHandler.h"

+#elif defined(SWIFTEN_PLATFORM_WIN32)

+#include <SwifTools/URIHandler/NullURIHandler.h>

+#else

+#include "QtDBUSURIHandler.h"

+#endif

+#if defined(SWIFTEN_PLATFORM_MACOSX)

+ uriHandler_ = new QtURIHandler();

+#elif defined(SWIFTEN_PLATFORM_WIN32)

+ uriHandler_ = new NullURIHandler();

+#else

+ uriHandler_ = new QtDBUSURIHandler();

+#endif

+

+ uriHandler_,

+ delete uriHandler_;

+ class URIHandler;

+ URIHandler* uriHandler_;

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include "QtURIHandler.h"

+

+#include <QCoreApplication>

+#include <QFileOpenEvent>

+#include <QUrl>

+

+#include "QtSwiftUtil.h"

+#ifdef Q_WS_MAC

+#include <SwifTools/URIHandler/MacOSXURIHandlerHelpers.h>

+#endif

+

+using namespace Swift;

+

+QtURIHandler::QtURIHandler() {

+ qApp->installEventFilter(this);

+#ifdef Q_WS_MAC

+ registerAppAsDefaultXMPPURIHandler();

+#endif

+}

+

+bool QtURIHandler::eventFilter(QObject*, QEvent* event) {

+ if (event->type() == QEvent::FileOpen) {

+ QFileOpenEvent* fileOpenEvent = static_cast<QFileOpenEvent*>(event);

+ if (fileOpenEvent->url().scheme() == "xmpp") {

+ onURI(Q2PSTRING(fileOpenEvent->url().toString()));

+ return true;

+ }

+ }

+ return false;

+}

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#pragma once

+

+#include <QObject>

+#include <SwifTools/URIHandler/URIHandler.h>

+

+class QUrl;

+

+namespace Swift {

+ class QtURIHandler : public QObject, public URIHandler {

+ public:

+ QtURIHandler();

+

+ private:

+ bool eventFilter(QObject* obj, QEvent* event);

+ };

+}

+ "QtURIHandler.cpp",

+ res = myenv.RES("../resources/Windows/Swift.rc")

+ # For some reason, SCons isn't picking up the dependency correctly

+ # Adding it explicitly until i figure out why

+ myenv.Depends(res, "../Controllers/BuildVersion.h")

+ sources += [

+ "FreeDesktopNotifier.cpp",

+ "QtDBUSURIHandler.cpp",

+ ]

+if env["PLATFORM"] != "darwin" and env["PLATFORM"] != "win32" :

+ openURIProgram = myenv.Program("swift-open-uri", "swift-open-uri.cpp")

+else :

+ openURIProgram = []

+

+ app = myenv.AppBundle("Swift", version = myenv["SWIFT_VERSION"], resources = commonResources, frameworks = frameworks, handlesXMPPURIs = True)

+ env.Install(os.path.join(env["SWIFT_INSTALLDIR"], "bin"), swiftProgram + openURIProgram)

+/*

+ * Copyright (c) 2011 Remko Tronçon

+ * Licensed under the GNU General Public License v3.

+ * See Documentation/Licenses/GPLv3.txt for more information.

+ */

+

+#include <QCoreApplication>

+#include <QDBusConnection>

+#include <QDBusMessage>

+#include <iostream>

+

+int main(int argc, char* argv[]) {

+ QCoreApplication app(argc, argv);

+

+ QDBusConnection bus = QDBusConnection::sessionBus();

+ if (!bus.isConnected()) {

+ return -1;

+ }

+ if (argc != 2) {

+ std::cerr << "Usage: " << argv[0] << " uri" << std::endl;

+ return -1;

+ }

+

+ QDBusMessage msg = QDBusMessage::createMethodCall("im.swift.Swift.URIHandler", "/", "im.swift.Swift.URIHandler", "openURI");

+ msg << argv[1];

+

+ bus.call(msg);

+

+ return 0;

+}

+#include <boost/filesystem.hpp>

+ file.write(reinterpret_cast<const char*>(avatar.getData()), static_cast<std::streamsize>(avatar.getSize()));

+#include <boost/filesystem/path.hpp>

+#include <boost/filesystem/path.hpp>

+#include <Swiften/Base/boost_bsignals.h>

+

+#include <boost/filesystem/path.hpp>

+ return operator<<(os, s.getDataVector());

+}

+

+std::ostream& operator<<(std::ostream& os, const std::vector<unsigned char>& s) {