summaryrefslogtreecommitdiffstats
path: root/opensuse/tdebase/kickoff-beagle.diff
diff options
context:
space:
mode:
Diffstat (limited to 'opensuse/tdebase/kickoff-beagle.diff')
-rw-r--r--opensuse/tdebase/kickoff-beagle.diff1329
1 files changed, 1329 insertions, 0 deletions
diff --git a/opensuse/tdebase/kickoff-beagle.diff b/opensuse/tdebase/kickoff-beagle.diff
new file mode 100644
index 000000000..a850e78ce
--- /dev/null
+++ b/opensuse/tdebase/kickoff-beagle.diff
@@ -0,0 +1,1329 @@
+--- configure.in.in (Revision 0)
++++ configure.in.in (Revision 849791)
+@@ -0,0 +1,78 @@
++dnl Check for pkg-config
++AC_PATH_PROG(PKG_CONFIG, pkg-config, no)
++
++if test "$PKG_CONFIG" = "no"; then
++ AC_MSG_ERROR([
++This package requires pkg-config.
++])
++fi
++
++dnl Check for Glib-2.0
++# GLIB_CFLAGS: cflags for compiling glib dependant sources
++# GLIB_LIBADD: glib libraries (-l options)
++# GLIB_LDFLAGS: flags containing path to glib libraries (-L options)
++
++GLIB_PACKAGES="gmodule-2.0 gthread-2.0"
++GLIB_VERSION="1.3.3"
++AC_MSG_CHECKING(for GLib-2.0 (at least $GLIB_VERSION))
++
++if $PKG_CONFIG --atleast-pkgconfig-version 0.15 ; then
++ if $PKG_CONFIG --atleast-version $GLIB_VERSION $GLIB_PACKAGES >/dev/null 2>&1 ; then
++ GLIB_CFLAGS="`$PKG_CONFIG --cflags $GLIB_PACKAGES`"
++ GLIB_LIBADD="`$PKG_CONFIG --libs-only-l --libs-only-other $GLIB_PACKAGES`"
++ GLIB_LDFLAGS="`$PKG_CONFIG --libs-only-L $GLIB_PACKAGES`"
++ AC_MSG_RESULT(yes)
++ fi
++else
++ if $PKG_CONFIG --atleast-version $GLIB_VERSION $GLIB_PACKAGES >/dev/null 2>&1 ; then
++ GLIB_CFLAGS="`$PKG_CONFIG --cflags $GLIB_PACKAGES`"
++ GLIB_LIBADD="`$PKG_CONFIG --libs-only-l $GLIB_PACKAGES`"
++ GLIB_LDFLAGS="`$PKG_CONFIG --libs-only-L $GLIB_PACKAGES`"
++ AC_MSG_RESULT(yes)
++ AC_MSG_WARN([you may need to run make LDFLAGS=-pthread to compile arts])
++ fi
++fi
++
++if test -z "$GLIB_LIBADD"; then
++ AC_MSG_RESULT(not installed)
++ DO_NOT_COMPILE="$DO_NOT_COMPILE kerry gmcop"
++fi
++
++AC_SUBST(GLIB_CFLAGS)
++AC_SUBST(GLIB_LIBADD)
++AC_SUBST(GLIB_LDFLAGS)
++
++dnl Check for libbeagle 0.2.0
++# LIBBEAGLE_CFLAGS: cflags for compiling libbeagle dependant sources
++# LIBBEAGLE_LIBADD: libbeagle libraries (-l options)
++# LIBBEAGLE_LDFLAGS: flags containing path to libbeagle libraries (-L options)
++
++LIBBEAGLE_PACKAGES="libbeagle-0.0"
++LIBBEAGLE_VERSION="0.2.4"
++AC_MSG_CHECKING(for libbeagle-0.2.4 (at least $LIBBEAGLE_VERSION))
++
++if $PKG_CONFIG --atleast-pkgconfig-version 0.15 ; then
++ if $PKG_CONFIG --atleast-version $LIBBEAGLE_VERSION $LIBBEAGLE_PACKAGES >/dev/null 2>&1 ; then
++ LIBBEAGLE_CFLAGS="`$PKG_CONFIG --cflags $LIBBEAGLE_PACKAGES`"
++ LIBBEAGLE_LIBADD="`$PKG_CONFIG --libs-only-l --libs-only-other $LIBBEAGLE_PACKAGES`"
++ LIBBEAGLE_LDFLAGS="`$PKG_CONFIG --libs-only-L $LIBBEAGLE_PACKAGES`"
++ AC_MSG_RESULT(yes)
++ fi
++else
++ if $PKG_CONFIG --atleast-version $LIBBEAGLE_VERSION $LIBBEAGLE_PACKAGES >/dev/null 2>&1 ; then
++ LIBBEAGLE_CFLAGS="`$PKG_CONFIG --cflags $LIBBEAGLE_PACKAGES`"
++ LIBBEAGLE_LIBADD="`$PKG_CONFIG --libs-only-l $LIBBEAGLE_PACKAGES`"
++ LIBBEAGLE_LDFLAGS="`$PKG_CONFIG --libs-only-L $LIBBEAGLE_PACKAGES`"
++ AC_MSG_RESULT(yes)
++ AC_MSG_WARN([you may need to run make LDFLAGS=-pthread to compile arts])
++ fi
++fi
++
++if test -z "$LIBBEAGLE_LIBADD"; then
++ AC_MSG_RESULT(not installed)
++ DO_NOT_COMPILE="$DO_NOT_COMPILE kerry gmcop"
++fi
++
++AC_SUBST(LIBBEAGLE_CFLAGS)
++AC_SUBST(LIBBEAGLE_LIBADD)
++AC_SUBST(LIBBEAGLE_LDFLAGS)
+--- kicker/plugins/beaglesearch.cpp (Revision 0)
++++ kicker/plugins/beaglesearch.cpp (Revision 849791)
+@@ -0,0 +1,362 @@
++/*****************************************************************
++
++ Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com>
++
++ 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; see the file COPYING. If not, write to
++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++ Boston, MA 02110-1301, USA.
++
++******************************************************************/
++
++#include "beaglesearch.h"
++
++#include <qdatetime.h>
++#include <qmutex.h>
++#include <qstringlist.h>
++#include <qapplication.h>
++#include <time.h>
++
++void beagle_init ()
++{
++ g_type_init ();
++}
++
++// ---------------- Hit ---------------------------
++
++Hit::Hit (BeagleHit *_hit) : processed (false)
++{
++ hit = beagle_hit_ref (_hit);
++}
++
++Hit::~Hit ()
++{
++ beagle_hit_unref (hit);
++ if (! processed)
++ return;
++ QDictIterator<QStringList> it (property_map);
++ for( ; it.current(); ++it )
++ ((QStringList *)it.current())->clear ();
++
++}
++
++void Hit::processProperties ()
++{
++ processed = true;
++ GSList *prop_list = beagle_hit_get_all_properties (hit);
++ GSList *it;
++ property_map.setAutoDelete (true);
++ for (it = prop_list; it; it = it->next) {
++ BeagleProperty *property = (BeagleProperty *) it->data;
++ QString key = QString::fromUtf8 (beagle_property_get_key (property));
++ if (! property_map [key])
++ property_map.insert (key, new QStringList ());
++ property_map [key]->append (QString::fromUtf8 (beagle_property_get_value (property)));
++ }
++ g_slist_free (prop_list);
++}
++
++const QString Hit::operator[] (QString prop_name)
++{
++ if (! processed)
++ processProperties ();
++
++ QStringList *prop_list = property_map [prop_name];
++ if (! prop_list)
++ return QString::null;
++ if (prop_list->count () != 1)
++ return QString::null;
++ return (QString)prop_list->first ();
++}
++
++// ---------------- BeagleSearch ------------------
++
++BeagleSearchResult::BeagleSearchResult(int client_id)
++ : client_id (client_id), total (0)
++{
++ hitlist = new QPtrList<Hit>;
++ hitlist->setAutoDelete (true);
++}
++
++
++BeagleSearchResult::~BeagleSearchResult()
++{
++ // everything is set to autodelete
++}
++
++void BeagleSearchResult::addHit(BeagleHit *_hit)
++{
++ Hit *hit = new Hit (_hit);
++ hitlist->prepend (hit);
++}
++
++const QPtrList<Hit> *BeagleSearchResult::getHits () const
++{
++ return hitlist;
++}
++
++
++static int total_hits;
++
++static void print_feed_item_hit (BeagleHit *hit)
++{
++ const char *text;
++
++ if (beagle_hit_get_one_property (hit, "dc:title", &text))
++ g_print ("Blog: %s\n", text);
++}
++
++static void print_file_hit (BeagleHit *hit)
++{
++ g_print ("File: %s, (%s)\n", beagle_hit_get_uri (hit), beagle_hit_get_mime_type (hit));
++}
++
++static void print_other_hit (BeagleHit *hit)
++{
++ const char *text;
++
++ g_print ("%s (%s)", beagle_hit_get_uri (hit),
++ beagle_hit_get_source (hit));
++ if (beagle_hit_get_one_property (hit, "dc:title", &text))
++ g_print ("title = %s\n", text);
++}
++
++static void print_hit (BeagleHit *hit)
++{
++ if (strcmp (beagle_hit_get_type (hit), "FeedItem") == 0) {
++ print_feed_item_hit (hit);
++ }
++ else if (strcmp (beagle_hit_get_type (hit), "File") == 0) {
++ print_file_hit (hit);
++ } else {
++ print_other_hit (hit);
++ }
++}
++
++// ---------------- BeagleSearchClient ------------------
++
++void BeagleSearchClient::run ()
++{
++ kdDebug () << "Starting query ..." << endl;
++
++ QTime query_timer;
++ query_timer.start ();
++
++ g_signal_connect (query, "hits-added",
++ G_CALLBACK (hitsAddedSlot),
++ this);
++ g_signal_connect (query, "finished",
++ G_CALLBACK (finishedSlot),
++ this);
++ beagle_client_send_request_async (client,
++ BEAGLE_REQUEST (query),
++ NULL);
++ g_main_loop_run (main_loop);
++ kdDebug () << "Finished query ..." << endl;
++
++ QCustomEvent *ev;
++ if (collate_results) {
++ result->query_msec = query_timer.elapsed ();
++
++ ev = new QCustomEvent (RESULTFOUND, result);
++ QApplication::postEvent (object, ev);
++ }
++
++ ev = new QCustomEvent (KILLME, this);
++ QApplication::postEvent (object, ev);
++
++}
++
++void BeagleSearchClient::stopClient ()
++{
++ if (finished ())
++ return; // duh!
++ kdDebug () << "Query thread " << id << " not yet finished ..." << endl;
++ // get ready for suicide
++ client_mutex->lock ();
++ kill_me = true;
++ g_signal_handlers_disconnect_by_func (
++ query,
++ (void *)hitsAddedSlot,
++ this);
++ g_signal_handlers_disconnect_by_func (
++ query,
++ (void *)finishedSlot,
++ this);
++ g_main_loop_quit (main_loop);
++ client_mutex->unlock ();
++}
++
++void BeagleSearchClient::hitsAddedSlot (BeagleQuery *query,
++ BeagleHitsAddedResponse *response,
++ BeagleSearchClient *bsclient)
++{
++ GSList *hits, *l;
++ gint i;
++ gint nr_hits;
++
++ // check if we are supposed to be killed
++ bsclient->client_mutex->lock ();
++ if (bsclient->kill_me) {
++ kdDebug () << "Suicide time before processing" << endl;
++ bsclient->client_mutex->unlock ();
++ return;
++ }
++ bsclient->client_mutex->unlock ();
++
++ hits = beagle_hits_added_response_get_hits (response);
++
++ nr_hits = g_slist_length (hits);
++ total_hits += nr_hits;
++ g_print ("Found hits (%d) at %ld:\n", nr_hits, time (NULL));
++
++ BeagleSearchResult *search_result;
++ if (! bsclient->collate_results)
++ search_result = new BeagleSearchResult (bsclient->id);
++ else
++ search_result = bsclient->result;
++ search_result->total += nr_hits;
++
++ for (l = hits, i = 1; l; l = l->next, ++i) {
++ //g_print ("[%d] ", i);
++ //print_hit (BEAGLE_HIT (l->data));
++ //g_print ("\n");
++
++ search_result->addHit(BEAGLE_HIT (l->data));//hit);
++ }
++ g_print ("[%ld] hits adding finished \n", time (NULL));
++
++ // check if we are supposed to be killed
++ bsclient->client_mutex->lock ();
++ if (bsclient->kill_me) {
++ kdDebug () << "Suicide time before sending ..." << endl;
++ bsclient->client_mutex->unlock ();
++ if (! bsclient->collate_results)
++ delete search_result;
++ return;
++ }
++ bsclient->client_mutex->unlock ();
++
++ // time to send back results, if user asked so
++ if (bsclient->collate_results)
++ return;
++ QCustomEvent *ev = new QCustomEvent (RESULTFOUND, search_result);
++ g_print ("[%ld] event notified \n", time (NULL));
++ QApplication::postEvent (bsclient->object, ev);
++}
++
++void BeagleSearchClient::finishedSlot (BeagleQuery *query,
++ BeagleFinishedResponse *response,
++ BeagleSearchClient *bsclient)
++{
++ // check if we are supposed to be killed
++ bsclient->client_mutex->lock ();
++ bool should_kill = bsclient->kill_me;
++ QObject* receiver = bsclient->object;
++ bsclient->client_mutex->unlock ();
++
++ if (should_kill)
++ return;
++
++ g_main_loop_quit (bsclient->main_loop);
++
++ if (bsclient->collate_results)
++ return; // if we are collating, everything will be send from a central place
++ if (receiver) {
++ QCustomEvent *ev = new QCustomEvent (SEARCHOVER, bsclient);
++ g_print ("[%ld] query finish notified \n", time (NULL));
++ QApplication::postEvent (receiver, ev);
++ }
++}
++
++// ----------------- BeagleUtil -------------------
++
++BeagleQuery *
++BeagleUtil::createQueryFromString (QString query_str,
++ QStringList &sources_menu,
++ QStringList &types_menu,
++ int max_hits_per_source)
++{
++ BeagleQuery *beagle_query = beagle_query_new ();
++ beagle_query_set_max_hits (beagle_query, max_hits_per_source); // this is per source!
++
++ kdDebug () << "Creating query from \"" << query_str << "\"" << endl;
++ for ( QStringList::Iterator it = sources_menu.begin(); it != sources_menu.end(); ++it )
++ beagle_query_add_source (beagle_query, g_strdup ((*it).utf8 ()));
++
++ for ( QStringList::Iterator it = types_menu.begin(); it != types_menu.end(); ++it )
++ beagle_query_add_hit_type (beagle_query, g_strdup ((*it).utf8 ()));
++
++ QStringList query_terms;
++ QString start_date, end_date;
++ QStringList words = QStringList::split (' ', query_str, false);
++ for ( QStringList::Iterator it = words.begin(); it != words.end(); ++it ) {
++ QStringList key_value_pair = QStringList::split ('=', *it, false);
++ if (key_value_pair.count () == 1)
++ query_terms += *it;
++ else if (key_value_pair.count () == 2) {
++ QString key = key_value_pair [0].lower ();
++ QString value = key_value_pair [1];
++ if (key == "mime")
++ beagle_query_add_mime_type (beagle_query, g_strdup (value.utf8 ()));
++ else if (key == "type")
++ beagle_query_add_hit_type (beagle_query, g_strdup (value.utf8 ()));
++ else if (key == "source")
++ beagle_query_add_source (beagle_query, g_strdup (value.utf8 ()));
++ else if (key == "start")
++ start_date = value;
++ else if (key == "end")
++ end_date = value;
++ else
++ query_terms += *it;
++ } else
++ query_terms += *it;
++ }
++
++ beagle_query_add_text (beagle_query, g_strdup (query_terms.join (" ").utf8 ()));
++ kdDebug () << "Adding query text:" << query_terms.join (" ").utf8 () << endl;
++
++ if (start_date.isNull () && end_date.isNull ())
++ return beagle_query;
++
++ //kdDebug () << "Handling dates ..." << endl;
++ BeagleQueryPartDate * date_part = beagle_query_part_date_new ();
++ if (! start_date.isNull ())
++ beagle_query_part_date_set_start_date (date_part, timestringToBeagleTimestamp (start_date));
++ if (! end_date.isNull ())
++ beagle_query_part_date_set_end_date (date_part, timestringToBeagleTimestamp (end_date));
++ beagle_query_add_part (beagle_query, BEAGLE_QUERY_PART (date_part));
++
++ return beagle_query;
++}
++
++// timestring format allowed YYYYmmDD
++BeagleTimestamp *
++BeagleUtil::timestringToBeagleTimestamp(QString timestring)
++{
++ //kdDebug () << "datetime string:" << timestring << endl;
++ // FIXME: error check timestring format
++ if (timestring.isNull () || timestring.stripWhiteSpace () == "" || timestring.length() != 8 )
++ return beagle_timestamp_new_from_unix_time (QDateTime::currentDateTime ().toTime_t ());
++ //QDateTime dt = QDateTime::fromString (timestring, Qt::ISODate);
++ struct tm tm_time;
++ time_t timet_time;
++ time (&timet_time);
++ localtime_r (&timet_time, &tm_time);
++ strptime (timestring.ascii(), "%Y%m%d", &tm_time);
++ tm_time.tm_sec = tm_time.tm_min = tm_time.tm_hour = 0;
++ //kdDebug() << asctime (&tm_time) << endl;
++ timet_time = mktime (&tm_time);
++ return beagle_timestamp_new_from_unix_time (timet_time);
++}
++
+--- kicker/plugins/kickoff-beagle-plugin.cpp (Revision 0)
++++ kicker/plugins/kickoff-beagle-plugin.cpp (Revision 849791)
+@@ -0,0 +1,499 @@
++/***************************************************************************
++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> *
++ * Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com> *
++ * *
++ * This program is free software; you can redistribute it and/or modify *
++ * it under the terms of the GNU General Public License as published by *
++ * the Free Software Foundation; either version 2 of the License, or *
++ * (at your option) any later version. *
++ * *
++ * This program is distributed in the hope that it will be useful, *
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
++ * GNU General Public License for more details. *
++ * *
++ * You should have received a copy of the GNU General Public License *
++ * along with this program; if not, write to the *
++ * Free Software Foundation, Inc., *
++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
++ ***************************************************************************/
++
++#include "kickoff-beagle-plugin.h"
++
++#include <qregexp.h>
++#include <qtimer.h>
++
++#include <kapplication.h>
++#include <kdesktopfile.h>
++#include <kgenericfactory.h>
++#include <kservice.h>
++
++QString dc_identifier = "dc:identifier";
++QString dc_title = "dc:title";
++QString parent_dc_title = "parent:dc:title";
++QString exactfilename = "beagle:ExactFilename";
++QString fixme_name = "fixme:Name";
++QString beagle_filename = "beagle:Filename";
++QString fixme_attachment_title = "fixme:attachment_title";
++QString fixme_hasattachments = "fixme:hasAttachments";
++QString parent_prefix = "parent:";
++QString fixme_folder = "fixme:folder";
++QString fixme_categories = "fixme:Categories";
++QString fixme_comment = "fixme:Comment";
++QString fixme_width = "fixme:width";
++QString fixme_height = "fixme:height";
++QString fixme_from_address = "fixme:from_address";
++QString fixme_artist = "fixme:artist";
++QString fixme_album = "fixme:album";
++QString dc_source = "dc:source";
++QString dc_publisher = "dc:publisher";
++QString digikam_tag = "digikam:Tag";
++QString fixme_speakingto = "fixme:speakingto";
++QString fixme_starttime = "fixme:starttime";
++QString comma_string = ",";
++QString vCard_FN = "vCard:FN";
++QString vCard_PREFEMAIL = "vCard:PREFEMAIL";
++QString fixme_uid = "fixme:uid";
++
++static CATEGORY getHitCategory (Hit *hit)
++{
++ QString hittype = hit->getType();
++ QString hitsource = hit->getSource();
++
++ // if hit source is None, dont handle it. Might be anthrax-envelope :)
++ if (hitsource.isNull())
++ return OTHER;
++
++ if (hitsource == "documentation")
++ return DOCS;
++
++ if (hittype == "IMLog")
++ return CHATS;
++
++ // sure shots
++ if (hittype == "FeedItem")
++ return FEEDS;
++ if (hittype == "WebHistory")
++ return WEBHIST;
++ if (hittype == "MailMessage")
++ return MAILS;
++ if (hittype == "Note")
++ return NOTES;
++
++ // check for applications
++ if (hittype == "File" && (*hit) ["beagle:FilenameExtension"] == ".desktop")
++ return APPS;
++
++ // check for music
++ QString hitmimetype = hit->getMimeType();
++ if (hitsource == "Amarok"
++ || hitmimetype.startsWith ("audio")
++ || hitmimetype == "application/ogg")
++ return MUSIC; // not an exhaustive search
++
++ // check for images from files
++ if (hitsource == "Files" && hitmimetype.startsWith ("image"))
++ return PICS;
++
++ if (hitsource == "Files" && hitmimetype.startsWith ("video"))
++ return VIDEOS;
++
++ if (hitsource == "Files")
++ return FILES;
++
++ if (hitsource == "KAddressBook")
++ return ACTIONS;
++
++ return OTHER;
++}
++
++K_EXPORT_COMPONENT_FACTORY( kickoffsearch_beagle,
++ KGenericFactory<KickoffBeaglePlugin>( "kickoffsearch_beagle" ) )
++
++KickoffBeaglePlugin::KickoffBeaglePlugin(QObject *parent, const char* name, const QStringList&)
++ : KickoffSearch::Plugin(parent, name ), genericTitle( true )
++{
++ g_type_init ();
++ current_beagle_client = NULL;
++}
++
++bool KickoffBeaglePlugin::daemonRunning()
++{
++ return beagle_util_daemon_is_running();
++}
++
++void KickoffBeaglePlugin::query(QString term, bool _genericTitle)
++{
++ genericTitle = _genericTitle;
++ current_query_str = term;
++
++ // Beagle search
++ if (current_beagle_client != NULL) {
++ kdDebug () << "Previous client w/id " << current_beagle_client->id << " still running ... ignoring it." << endl;
++ current_beagle_client->stopClient ();
++ }
++ current_beagle_client_id = KApplication::random ();
++ kdDebug () << "Creating client with id:" << current_beagle_client_id << endl;
++
++ BeagleClient *beagle_client = beagle_client_new (NULL);
++ if (beagle_client == NULL) {
++ kdDebug() << "beagle service not running ..." << endl;
++ return;
++ }
++
++ QStringList sources, types;
++ BeagleQuery *beagle_query = BeagleUtil::createQueryFromString (term, sources, types, 99); // maximum 99 results, if this doesnt work, blame the stars
++
++ current_beagle_client = new BeagleSearchClient (
++ current_beagle_client_id,
++ this,
++ beagle_client,
++ beagle_query,
++ false);
++ current_beagle_client->start();
++// kdDebug () << "Query dispatched at " << time (NULL) << endl;
++}
++
++void KickoffBeaglePlugin::cleanClientList ()
++{
++ toclean_list_mutex.lock ();
++ BeagleSearchClient *old_client = toclean_client_list.take (0);
++ if (old_client != NULL) { // failsafe
++ kdDebug () << "Cleanup old client " << old_client->id << endl;
++ delete old_client;
++ }
++ toclean_list_mutex.unlock ();
++}
++
++void KickoffBeaglePlugin::customEvent (QCustomEvent *e)
++{
++ if (e->type () == RESULTFOUND) {
++// kdDebug () << "Quick query thread at " << time (NULL) << " with current_id=" << current_beagle_client_id << " finished ..." << endl;
++ BeagleSearchResult *result = (BeagleSearchResult *) e->data ();
++ if (current_beagle_client_id != result->client_id) {
++ kdDebug () << "Stale result from " << result->client_id << endl;
++ delete result;
++ // FIXME: Should I also free e ?
++ } else {
++ kdDebug () << "Good results ...total=" << result->total << endl;
++ showResults (result);
++ }
++ //KPassivePopup::message( "This is the message", this );
++ } else if (e->type () == SEARCHOVER) {
++ BeagleSearchClient *client = (BeagleSearchClient *) e->data ();
++ if (client == NULL) {
++// kdDebug () << "Query finished event at " << time (NULL) << " but client is already deleted" << endl;
++ return;
++ }
++// kdDebug () << "Query finished event at " << time (NULL) << " for id=" << client->id << endl;
++ if (current_beagle_client_id == client->id) {
++ kickoffSearchInterface()->searchOver();
++ current_beagle_client = NULL; // important !
++ }
++ } else if (e->type () == KILLME) {
++ BeagleSearchClient *client = (BeagleSearchClient *) e->data ();
++ if (client->finished ())
++ delete client;
++ else {
++ // add client to cleanup list
++ toclean_list_mutex.lock ();
++ toclean_client_list.append (client);
++ kdDebug () << "Scheduling client to be deleted in 500ms" << endl;
++ toclean_list_mutex.unlock ();
++ QTimer::singleShot (500, this, SLOT (cleanClientList ()));
++ }
++ }
++}
++
++// this method decides what to display in the result list
++HitMenuItem *KickoffBeaglePlugin::hitToHitMenuItem (int category, Hit *hit)
++{
++ QString title, info, mimetype, icon;
++ int score = 0;
++ KURL uri;
++
++#if 0
++ kdDebug() << "*** " << hit->getUri() << endl;
++ QDict<QStringList> all = hit->getAllProperties();
++ QDictIterator<QStringList> it( all );
++ for( ; it.current(); ++it )
++ kdDebug() << it.currentKey() << ": " << *(it.current()) << endl;
++#endif
++
++ switch (category) {
++ case FILES:
++ {
++ uri = hit->getUri ();
++ QString uristr = uri.path ();
++ title = (*hit) [exactfilename];
++ int last_slash = uristr.findRev ('/', -1);
++ info = i18n("Folder: %1").arg(last_slash == 0 ? "/"
++ : uristr.section ('/', -2, -2));
++ }
++ break;
++ case ACTIONS:
++ {
++ if (hit->getSource()=="KAddressBook"){
++ title = i18n("Send Email to %1").arg((*hit)[vCard_FN]);
++ info = (*hit)[vCard_PREFEMAIL];
++ uri = "mailto:"+(*hit)[vCard_PREFEMAIL];
++ mimetype = hit->getMimeType ();
++ icon = "mail_new";
++
++ HitMenuItem * first_item=new HitMenuItem (title, info, uri, mimetype, 0, category, icon, score);
++ kickoffSearchInterface()->addHitMenuItem(first_item);
++
++ title =i18n("Open Addressbook at %1").arg((*hit)[vCard_FN]);
++ uri = "kaddressbook:/"+(*hit)[fixme_uid];
++ icon = "kaddressbook";
++ }
++ break;
++ }
++ case MAILS:
++ {
++ QString prefix = QString::null;
++ bool is_attachment = ((*hit) [parent_prefix + fixme_hasattachments] == "true");
++ bool has_parent = (! hit->getParentUri ().isEmpty ());
++ bool parent_mbox_file = false;
++ if (has_parent)
++ parent_mbox_file = ((*hit) [parent_prefix + fixme_folder] == QString::null);
++
++ // Logic:
++ // If has_parent == false, everything is normal
++ // If has_parent == true, parent_mbox_file == false, everything is normal, use uri
++ // FIXME: If has_parent == true, parent_mbox_file == true, ???
++ // If has_parent == true, is_attachment == true, hit is attach and access with prefix "parent:", use parenturi
++ // Else, not attachment (multipart), access with prefix "parent:", use parenturi
++
++ if (has_parent && !parent_mbox_file) {
++ uri = hit->getParentUri ();
++ prefix = parent_prefix;
++ if (is_attachment)
++ title = (*hit) [fixme_attachment_title];
++ if (title.isEmpty ())
++ title = (*hit) [prefix + dc_title];
++ if (title.isEmpty ())
++ title = i18n("No subject");
++ if (is_attachment)
++ title = title.prepend (i18n("(Attachment) "));
++ info = (i18n("From %1").arg((*hit) [prefix + fixme_from_address]));
++ } else {
++ uri = hit->getUri ();
++ title = (*hit) [dc_title];
++ info = (i18n("From %1").arg((*hit) [fixme_from_address]));
++ }
++ }
++ mimetype = "message/rfc822"; // to handle attachment results
++ break;
++ case MUSIC:
++ uri = hit->getUri ();
++ title = (*hit) [exactfilename];
++ {
++ QString artist = (*hit) [fixme_artist];
++ QString album = (*hit) [fixme_album];
++ if (! artist.isEmpty ())
++ info = (i18n("By %1").arg(artist));
++ else if (! album.isEmpty ())
++ info = (i18n("From Album %1").arg(album));
++ else {
++ QString uristr = uri.path ();
++ int last_slash = uristr.findRev ('/', -1);
++ info = i18n("Folder: %1")
++ .arg(last_slash == 0 ? "/" : uristr.section ('/', -2, -2));
++ }
++ }
++ break;
++ case VIDEOS:
++ uri = hit->getUri ();
++ title = (*hit) [exactfilename];
++ {
++ QString uristr = uri.path ();
++ int last_slash = uristr.findRev ('/', -1);
++ info = i18n("Folder: %1").arg(last_slash == 0 ? "/" : uristr.section ('/', -2, -2));
++ }
++ break;
++ case WEBHIST:
++ uri = hit->getUri ();
++ title = (*hit) [dc_title];
++ title = title.replace(QRegExp("\n")," ");
++ mimetype = "text/html";
++ if (title.isEmpty () || title.stripWhiteSpace ().isEmpty ()) {
++ title = uri.prettyURL ();
++ } else {
++ info = uri.host () + uri.path ();
++ }
++ break;
++ case FEEDS:
++ {
++ uri = KURL ((*hit) [dc_identifier]);
++ title = (*hit) [dc_title];
++ mimetype = "text/html";
++ QString publisher = (*hit) [dc_publisher];
++ QString source = (*hit) [dc_source];
++ if (! publisher.isEmpty ())
++ info = publisher;
++ else if (! source.isEmpty ())
++ info = source;
++ }
++ break;
++ case PICS:
++ {
++ uri = hit->getUri ();
++ title = (*hit) [exactfilename];
++ QString width = (*hit) [fixme_width];
++ QString height = (*hit) [fixme_height];
++ if (width.isEmpty () || height.isEmpty ()) {
++ QString uristr = uri.path ();
++ int last_slash = uristr.findRev ('/', -1);
++ info = i18n("Folder: %1")
++ .arg(last_slash == 0 ? "/" : uristr.section ('/', -2, -2));
++ break;
++ }
++ info = (QString (" (%1x%2)").arg (width).arg (height));
++ const QStringList *tags = hit->getProperties (digikam_tag);
++ if (tags == NULL)
++ break;
++ QString tags_string = tags->join (comma_string);
++ info += (" " + tags_string);
++ }
++ break;
++ case APPS:
++ {
++ uri = hit->getUri ();
++ title = (*hit) [dc_title];
++ KDesktopFile desktopfile(uri.path(),true);
++ if (genericTitle && !desktopfile.readGenericName().isEmpty()) {
++ title = desktopfile.readGenericName();
++ info = desktopfile.readName();
++ }
++ else {
++ title = desktopfile.readName();
++ info = desktopfile.readGenericName();
++ }
++ icon = desktopfile.readIcon();
++ QString input = current_query_str.lower();
++ QString command = desktopfile.readEntry("Exec");
++ if (command==input)
++ score = 100;
++ else if (command.find(input)==0)
++ score = 50;
++ else if (command.find(input)!=-1)
++ score = 10;
++ else if (title==input)
++ score = 100;
++ else if (title.find(input)==0)
++ score = 50;
++ else if (title.find(input)!=-1)
++ score = 10;
++ break;
++ }
++ break;
++ case NOTES:
++ {
++ uri = hit->getUri ();
++ title = (*hit) [dc_title];
++ title = i18n("Title: %1").arg(title.isEmpty() ? i18n("Untitled") : title);
++
++ if (hit->getSource()=="KNotes")
++ icon="knotes";
++ else
++ icon="contents2";
++ }
++ break;
++ case CHATS:
++ {
++ uri = hit->getUri ();
++ title = (*hit) [fixme_speakingto];
++ title = i18n("Conversation With %1").arg(title.isEmpty() ? i18n("Unknown Person") : title);
++ QDateTime datetime;
++ datetime = datetimeFromString((*hit) [fixme_starttime]);
++ info=i18n("Date: %1").arg(KGlobal::locale()->formatDateTime(datetime,false));
++ if (hit->getMimeType()=="beagle/x-kopete-log")
++ icon="kopete";
++ else
++ icon="gaim";
++ }
++ break;
++ case DOCS:
++ {
++ uri = hit->getUri ();
++ title = (*hit) [dc_title];
++ if (title.isEmpty () || title.stripWhiteSpace ().isEmpty ())
++ title = uri.prettyURL ();
++ else {
++ QString uristr = uri.path ();
++ int last_slash = uristr.findRev ('/', -1);
++ info = i18n("Folder: %1").arg(last_slash == 0 ? "/" : uristr.section ('/',
++ -2, -2));
++ }
++ }
++ break;
++ default:
++ return NULL;
++ }
++ if (mimetype.isEmpty ())
++ mimetype = hit->getMimeType ();
++ return new HitMenuItem (title, info, uri, mimetype, 0, category, icon, score);
++}
++
++void KickoffBeaglePlugin::showResults(BeagleSearchResult *result)
++{
++ if (result->total == 0 ) {
++ // Dont report error from here ...
++ kdDebug() << "No matches found" << endl;
++ delete result;
++ return;
++ }
++
++ const QPtrList<Hit> *hits = result->getHits();
++ if (hits == NULL) {
++ kdDebug () << "Hmm... null" << endl;
++ delete result;
++ return;
++ }
++ kickoffSearchInterface()->initCategoryTitlesUpdate();
++
++ QPtrListIterator<Hit> it (*hits);
++ Hit *hit;
++ for (; (hit = it.current ()) != NULL; ++it) {
++ CATEGORY category = getHitCategory (hit);
++
++ // if category is not handled, continue
++ if (category == OTHER)
++ continue;
++
++ if ( category == APPS ) {
++ // we need to check if this is useful
++ KService cs( hit->getUri().path() );
++ if ( cs.noDisplay() )
++ continue;
++ }
++
++ if (!kickoffSearchInterface()->anotherHitMenuItemAllowed(category))
++ continue;
++
++ HitMenuItem *hit_item = hitToHitMenuItem (category, hit);
++
++ if (!hit_item)
++ continue;
++
++ kickoffSearchInterface()->addHitMenuItem(hit_item);
++ }
++
++ kickoffSearchInterface()->updateCategoryTitles();
++
++ delete result;
++}
++
++QDateTime KickoffBeaglePlugin::datetimeFromString( const QString& s)
++{
++ int year( s.mid( 0, 4 ).toInt() );
++ int month( s.mid( 4, 2 ).toInt() );
++ int day( s.mid( 6, 2 ).toInt() );
++ int hour( s.mid( 8, 2 ).toInt() );
++ int min( s.mid( 10, 2 ).toInt() );
++ int sec( s.mid( 12, 2 ).toInt() );
++ return QDateTime(QDate(year,month,day),QTime(hour,min,sec));
++}
++
++#include "kickoff-beagle-plugin.moc"
+--- kicker/plugins/Makefile.am (Revision 0)
++++ kicker/plugins/Makefile.am (Revision 849791)
+@@ -0,0 +1,24 @@
++INCLUDES = -I$(top_srcdir)/interfaces $(all_includes) $(LIBBEAGLE_CFLAGS) $(GLIB_CFLAGS)
++METASOURCES = AUTO
++
++# Install this plugin in the KDE modules directory
++kde_module_LTLIBRARIES = kickoffsearch_beagle.la
++
++# Srcs for the plugin
++kickoffsearch_beagle_la_SOURCES = kickoff-beagle-plugin.cpp beaglesearch.cpp
++
++# Libs needed by the plugin
++kickoffsearch_beagle_la_LIBADD = $(LIB_KPARTS) ../interfaces/libkickoffsearch_interfaces.la \
++ $(LIBBEAGLE_LIBADD) $(GLIB_LIBADD)
++
++# LD flags for the plugin
++# -module says: this is a module, i.e. something you're going to dlopen
++# so e.g. it has no version number like a normal shared lib would have.
++kickoffsearch_beagle_la_LDFLAGS = -module $(KDE_PLUGIN) $(all_libraries)
++
++# Install the desktop file needed to detect the plugin
++kde_services_DATA = kickoffsearch_beagle.desktop
++
++# i18n translation messages
++messages: rc.cpp
++ $(XGETTEXT) *.cpp *.h -o $(podir)/kickoffsearch_beagle.pot
+--- kicker/plugins/kickoffsearch_beagle.desktop (Revision 0)
++++ kicker/plugins/kickoffsearch_beagle.desktop (Revision 849791)
+@@ -0,0 +1,6 @@
++[Desktop Entry]
++Name=Beagle Search
++Comment=Beagle search plugin for Kickoff search
++ServiceTypes=KickoffSearch/Plugin
++Type=Service
++X-KDE-Library=kickoffsearch_beagle
+--- kicker/plugins/beaglesearch.h (Revision 0)
++++ kicker/plugins/beaglesearch.h (Revision 849791)
+@@ -0,0 +1,234 @@
++/*****************************************************************
++
++ Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com>
++
++ 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; see the file COPYING. If not, write to
++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
++ Boston, MA 02110-1301, USA.
++
++******************************************************************/
++
++#ifndef BEAGLESEARCH_H
++#define BEAGLESEARCH_H
++
++#include <qdict.h>
++#include <qptrlist.h>
++#include <qthread.h>
++#include <qevent.h>
++#include <qmutex.h>
++
++#include <kdebug.h>
++#include <kurl.h>
++
++extern "C" {
++#include <glib.h>
++#include <beagle/beagle.h>
++}
++
++// BeagleSearchClient sends 3 types of events
++// when results are to be sent as they arrive,
++// - RESULTFOUND : when result is found
++// - SEARCHOVER : when search is over
++// - KILLME : just before thread finishes - used to cleanup the thread object
++// when results are to be sent after receiving all of them
++// - RESULTFOUND : when all results are obtained
++// - KILLME : just before thread finishes - used to cleanup the thread object
++#define RESULTFOUND (QEvent::Type)1001 /* QEvent::User + 1 */
++#define SEARCHOVER (QEvent::Type)1002 /* QEvent::User + 2 */
++#define KILLME (QEvent::Type)1003 /* QEvent::User + 3 */
++
++class QStringList;
++
++// IMPORTANT: Call this before any beagle calls
++void beagle_init ();
++
++class Hit {
++public:
++ Hit (BeagleHit *_hit);
++ ~Hit ();
++
++ // convenience wrappers
++ // remember that the hit values are utf8 strings
++ const KURL getUri () const { return KURL (QString::fromUtf8 (beagle_hit_get_uri (hit)));}
++ const QString getType () const { return QString::fromUtf8 (beagle_hit_get_type (hit));}
++ const QString getMimeType () const { return QString::fromUtf8 (beagle_hit_get_mime_type (hit));}
++ const QString getSource () const { return QString::fromUtf8 (beagle_hit_get_source (hit));}
++ const KURL getParentUri () const { return KURL (QString::fromUtf8 (beagle_hit_get_parent_uri (hit)));}
++ const QDict<QStringList>& getAllProperties ()
++ {
++ if (! processed)
++ processProperties ();
++ return property_map;
++ }
++ const QStringList* getProperties (QString prop_name)
++ {
++ if (! processed)
++ processProperties ();
++ return property_map [prop_name];
++ }
++ const QString operator[] (QString prop_name);
++
++private:
++ BeagleHit *hit;
++ QDict<QStringList> property_map;
++ // not every hit may be used. so, do a lazy processing of property_map
++ bool processed;
++ void processProperties ();
++};
++
++class BeagleSearchResult{
++public:
++ BeagleSearchResult(int client_id);
++ ~BeagleSearchResult();
++ void addHit (BeagleHit *hit);
++ QString getHitCategory (Hit *hit);
++
++ // id of the bsclient
++ int client_id;
++ // time taken to finish query
++ int query_msec;
++ // total number of results in this query
++ int total;
++
++ const QPtrList<Hit> *getHits () const;
++
++private:
++ // lists of hits
++ QPtrList<Hit> *hitlist;
++};
++
++// caller should delete bsclient->result and bsclient
++class BeagleSearchClient : public QThread {
++public:
++ // passing NULL for client makes bsclient create client itself and
++ // delete it later
++ BeagleSearchClient (int id,
++ QObject *y,
++ BeagleClient *client,
++ BeagleQuery *query,
++ bool collate_results)
++ : id (id), kill_me (false), object (y), client (client),
++ query (query), destroy_client (false), collate_results (collate_results)
++ {
++ if (client == NULL) {
++ client = beagle_client_new (NULL);
++ destroy_client = true;
++ }
++
++// if (client == NULL)
++// throw -1;
++
++ main_loop = g_main_loop_new (NULL, FALSE);
++ if (collate_results)
++ result = new BeagleSearchResult (id);
++
++ client_mutex = new QMutex ();
++ }
++
++ // It is never safe to delete BeagleSearchClient directly, the thread might still be running
++ ~BeagleSearchClient ()
++ {
++ if (! finished ()) {
++ kdDebug () << "Thread " << id << " still running. Waiting.........." << endl;
++ wait ();
++ }
++
++ if (destroy_client)
++ g_object_unref (client);
++ g_main_loop_unref (main_loop);
++ g_object_unref (query);
++ kdDebug() << "Deleting client ..." << id << endl;
++ delete client_mutex;
++ }
++
++private:
++ static void hitsAddedSlot (BeagleQuery *query,
++ BeagleHitsAddedResponse *response,
++ BeagleSearchClient *bsclient);
++
++ static void finishedSlot (BeagleQuery *query,
++ BeagleFinishedResponse *response,
++ BeagleSearchClient *bsclient);
++
++public:
++ // run() starts the query and sends the result as follows:
++ // - either wait till get back all results and send it as RESULTFOUND
++ // - or, send results as it gets them as RESULTFOUND and
++ // send SEARCHOVER when finished
++ // collate_results controls the behaviour
++ virtual void run ( );
++
++ // after stopClient() is called, application can safely go and remove previous menu entries
++ // - i.e. after stopClient is called, app doesnt except the eventhandler to receive any results
++ // - use client_id to determine which is the current client, set it right after stopclient
++ // - Eventhandler checks client id, if it is current, it adds stuff to the menu
++ // else, it discards everything
++ // Once eventhandler is being processed, doQuery() wont be called and vice versa
++ // so no need to serialize eventhandler and doquery
++ //
++ // stopClient needs to make sure that once it is called, the thread is finished asap. Use a mutex
++ // to serialize actions. callbacks need to use mutex too.
++ // stopclient has to remove signal handlers to prevent further signal calls, set kill_me flag
++ // and quite main loop
++ // stopClient can be called at the following times:
++ // - Waiting for the first result:
++ // nothing extra
++ // - in hitsAddedSlot, processing results
++ // in callback, before processing, if killme is set, just return.
++ // - in hitsAddedSlot, after sending results
++ // before sending, if killme is set, dont send results
++ // (doing it twice in hitsAdded because forming BeagleSearchResult can take time)
++ // - Waiting for more results
++ // nothing extra
++ // - in finishedSlot, before sending finishedMsg
++ // if killme is set, just return
++ // - in finishedSlot, after sending finishedMsg
++ // if killme is set, just return
++ // in Run(), when return from mainloop, if killme is set, dont do anything more but call delete this
++ void stopClient ();
++
++ // id of the client
++ // this is required in case applications fires many clients in rapid succession
++ int id;
++
++ GMainLoop * main_loop;
++ BeagleSearchResult *result;
++
++ // this is set if the client is obsolete now i.e.
++ // the application doesnt need the results from the client anymore
++ bool kill_me;
++private:
++ // the application; need this to send events to the application
++ QObject *object;
++ // mutex to control setting the kill_me shared variable
++ QMutex *client_mutex;
++ BeagleClient *client;
++ BeagleQuery *query;
++ // should the client be destroyed by the client
++ // if the client created it, then most probably it should
++ bool destroy_client;
++ bool collate_results;
++};
++
++class BeagleUtil {
++public:
++
++ static BeagleQuery *createQueryFromString (QString query_str,
++ QStringList &sources,
++ QStringList &types,
++ int max_hits_per_source = 100);
++ static BeagleTimestamp *timestringToBeagleTimestamp (QString timestring);
++};
++
++#endif
+--- kicker/plugins/kickoff-beagle-plugin.h (Revision 0)
++++ kicker/plugins/kickoff-beagle-plugin.h (Revision 849791)
+@@ -0,0 +1,64 @@
++/***************************************************************************
++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> *
++ * Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com> *
++ * *
++ * This program is free software; you can redistribute it and/or modify *
++ * it under the terms of the GNU General Public License as published by *
++ * the Free Software Foundation; either version 2 of the License, or *
++ * (at your option) any later version. *
++ * *
++ * This program is distributed in the hope that it will be useful, *
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of *
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
++ * GNU General Public License for more details. *
++ * *
++ * You should have received a copy of the GNU General Public License *
++ * along with this program; if not, write to the *
++ * Free Software Foundation, Inc., *
++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
++ ***************************************************************************/
++
++#ifndef CAPITALIZEPLUGIN_H
++#define CAPITALIZEPLUGIN_H
++
++#include "../interfaces/kickoff-search-plugin.h"
++#include "beaglesearch.h"
++
++class KickoffBeaglePlugin :public KickoffSearch::Plugin
++{
++ Q_OBJECT
++
++public:
++ KickoffBeaglePlugin(QObject *parent, const char* name, const QStringList&);
++
++ void query(QString, bool);
++ bool daemonRunning();
++
++protected slots:
++ // to clean beaglesearchclients
++ void cleanClientList ();
++
++private:
++ QString current_query_str;
++
++ // all beagle activity is done through the BSC object
++ BeagleSearchClient *current_beagle_client;
++
++ // used to send notification from the beagle thread to the main event loop
++ virtual void customEvent (QCustomEvent *e);
++
++ QPtrList<BeagleSearchClient> toclean_client_list;
++ QMutex toclean_list_mutex;
++
++ // show the results
++ void showResults (BeagleSearchResult *);
++ HitMenuItem *hitToHitMenuItem (int category, Hit *hit);
++
++ // use a different id for each bsc client, and use that to separate stale responses from current ones
++ int current_beagle_client_id;
++
++ bool genericTitle;
++ QDateTime datetimeFromString( const QString& );
++};
++
++#endif /* CAPITALIZEPLUGIN_H */
+
+Eigenschaftsänderungen: kicker/plugins
+___________________________________________________________________
+HinzugefĂĽgt: svn:ignore
+ + .deps
+kickoffsearch_beagle.la
+.libs
+Makefile
+Makefile.in
+*.moc
+
+
+--- kicker/Makefile.am 2010/08/10 08:10:21 1.1
++++ kicker/Makefile.am 2010/08/10 08:10:33
+@@ -1,6 +1,6 @@
+ INCLUDES = $(all_includes)
+
+-SUBDIRS = core ui buttons interfaces .
++SUBDIRS = core ui buttons interfaces plugins .
+
+ bin_PROGRAMS =
+ lib_LTLIBRARIES =
+--- kicker/core/Makefile.am 2010/08/10 08:15:06 1.2
++++ kicker/core/Makefile.am 2010/08/10 08:17:08
+@@ -1,6 +1,6 @@
+ INCLUDES = -I$(srcdir)/../../libkicker -I../../libkicker \
+ -I../ui -I$(srcdir)/../ui -I$(srcdir)/../buttons -I$(top_srcdir)/libkonq \
+- $(all_includes)
++ $(all_includes) $(LIBBEAGLE_CFLAGS) $(GLIB_CFLAGS)
+
+ noinst_LTLIBRARIES = libkicker_core.la
+
+--- kicker/buttons/Makefile.am 2010/08/10 08:16:06 1.1
++++ kicker/buttons/Makefile.am 2010/08/10 08:16:28
+@@ -1,5 +1,5 @@
+ INCLUDES = -I$(srcdir)/../core -I$(srcdir)/../../libkicker -I../../libkicker \
+- -I../ui -I$(srcdir)/../ui -I$(top_srcdir)/libkonq $(all_includes)
++ -I../ui -I$(srcdir)/../ui -I$(top_srcdir)/libkonq $(all_includes) $(LIBBEAGLE_CFLAGS) $(GLIB_CFLAGS)
+
+ noinst_LTLIBRARIES = libkicker_buttons.la
+