src/utils/plasmamule/plasma-applet-plasmamule.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2010 Werner Mahr (Vollstrecker) <amule@vollstreckernet.de>
   5 //
   6 // Any parts of this program contributed by third-party developers are copyrighted
   7 // by their respective authors.
   8 //
   9 // This program is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU General Public License as published by
  11 // the Free Software Foundation; either version 3 of the License, or
  12 // (at your option) any later version.
  13 //
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  22 //
  23 #include "plasma-applet-plasmamule.h"
  24 #include "plasmamule-dbus.h"
  25
  26 #include <kaboutapplicationdialog.h>
  27 #include <kaboutdata.h>
  28 #include <kdebug.h>
  29 #include <kicon.h>
  30 #include <kplugininfo.h>
  31 #include <krun.h>
  32 #include <kservice.h>
  33
  34 #include <plasma/svg.h>
  35 #include <plasma/theme.h>
  36 #include <plasma/version.h>
  37
  38 #include <QApplication>
  39 #include <QClipboard>
  40 #include <QFontMetrics>
  41 #include <QMenu>
  42 #include <QPainter>
  43 #include <QSizeF>
  44 #include <QStringList>
  45
  46 K_EXPORT_PLASMA_APPLET(plasma-applet-plasmamule, PlasmaMuleApplet)
  47
  48 PlasmaMuleApplet::PlasmaMuleApplet(QObject *parent, const QVariantList &args)
  49         : Plasma::Applet(parent, args),
  50         m_svg(this)
  51 {
  52         QString path = __IMG_PATH__;
  53         path.append( "application-x-emulecollection.svg");
  54         m_svg.setImagePath(path);
  55         setBackgroundHints(TranslucentBackground);
  56         setMinimumSize(200, 200);
  57         setMaximumSize(300, 300);
  58         setAcceptDrops(TRUE);
  59         setHasConfigurationInterface(FALSE);
  60 }
  61
  62 PlasmaMuleApplet::~PlasmaMuleApplet()
  63 {
  64 }
  65
  66 void PlasmaMuleApplet::init()
  67 {
  68         m_debugChannel = KDebug::registerArea ("plasmamule-applet",
  69 #ifdef __DEBUG__
  70         true
  71 #else
  72         false
  73 #endif
  74         );
  75         connectToEngine();
  76 }
  77
  78 void PlasmaMuleApplet::paintInterface(QPainter *painter,
  79         const QStyleOptionGraphicsItem *option, const QRect &contentsRect)
  80 {
  81         painter->setRenderHint(QPainter::SmoothPixmapTransform);
  82         painter->setRenderHint(QPainter::Antialiasing);
  83         QPixmap pixmap;
  84         pixmap = m_svg.pixmap();
  85         QPixmap temp(pixmap.size());
  86         temp.fill(Qt::transparent);
  87         QPainter p(&temp);
  88         p.setCompositionMode(QPainter::CompositionMode_Source);
  89         p.drawPixmap(0, 0, pixmap);
  90         p.setCompositionMode(QPainter::CompositionMode_DestinationIn);
  91         p.fillRect(temp.rect(), QColor(0, 0, 0, 200));
  92         p.end();
  93         pixmap = temp;
  94         painter->drawPixmap(contentsRect, pixmap);
  95         painter->save();
  96         painter->setPen(Qt::red);
  97         QFont font = painter->font();
  98         font.setBold(true);
  99         painter->setFont(font);
 100         if (!m_config_found)
 101         {
 102                 painter->drawText(contentsRect, Qt::AlignCenter,
 103                 "aMule not configured or installed");
 104         }
 105         else if (!m_os_active)
 106         {
 107                 painter->drawText(contentsRect, Qt::AlignCenter,
 108                 "Online Signature disabled");
 109         } else if (m_uptime == 0)
 110         {
 111                 painter->drawText(contentsRect, Qt::AlignCenter,
 112                 "aMule is not running\n");
 113         } else {
 114                 QString message;
 115                 painter->setPen(Qt::black);
 116                 int time, days, hours, minutes;
 117                 QString runtime;
 118                 days = m_uptime/86400;
 119                 time = m_uptime%86400;
 120                 hours=time/3600;
 121                 time=time%3600;
 122                 minutes=time/60;
 123                 time=time%60;
 124
 125                 runtime = QString("%1:%2:%3").arg(hours, 2, 10, QLatin1Char('0')).arg(minutes, 2, 10, QLatin1Char('0')).arg(time, 2, 10, QLatin1Char('0'));
 126
 127                 if (days)
 128                 {
 129                         if (days = 1)
 130                         {
 131                                 runtime.prepend(QString("%1 day ").arg(days));
 132                         } else {
 133                                 runtime.prepend(QString("%1 days ").arg(days));
 134                         }
 135                 }
 136                 message = QString("%1 has been running for %2 \n\n").arg(m_version).arg(runtime);
 137                 if (m_ed2k_state == 0 && m_kad_status == 0)
 138                 {
 139                         message.append(QString("%1 is not connected ").arg(m_nickname));
 140                         message.append("but running\n\n");
 141                 }
 142                 else if (m_ed2k_state == 0 && m_kad_status != 0)
 143                 {
 144                         message.append(QString("%1 is connected to ").arg(m_nickname));
 145                         if (m_kad_status == 1)
 146                         {
 147                                 message.append("Kad: firewalled \n\n");
 148                         } else {
 149                                 message.append("Kad: ok \n\n");
 150                         }
 151                 } else {
 152                         message.append(QString("%1 is connected to %2 [%3:%4] with ").arg(m_nickname).arg(m_ed2k_server_name).arg(m_ed2k_server_ip).arg(m_ed2k_server_port));
 153                         if (m_kad_status == 1)
 154                         {
 155                                 if (m_ed2k_id_high_low == "H")
 156                                 {
 157                                         message.append("HighID | Kad: firewalled \n\n");
 158                                 } else {
 159                                         message.append("LowID | Kad: firewalled \n\n");
 160                                 }
 161                         } else if (m_kad_status == 2)
 162                         {
 163                                 if (m_ed2k_id_high_low == "H")
 164                                 {
 165                                         message.append("HighID | Kad: ok \n\n");
 166                                 } else {
 167                                         message.append("LowID | Kad: ok \n\n");
 168                                 }
 169                         } else {
 170                                 if (m_ed2k_id_high_low == "H")
 171                                 {
 172                                         message.append("HighID | Kad: off \n\n");
 173                                 } else {
 174                                         message.append("LowID | Kad: off \n\n");
 175                                 }
 176                         }
 177                 }
 178                 message.append(QString("Total Download: %1, Upload: %2\n\n").arg(calcSize(m_total_bytes_downloaded)).arg(calcSize(m_total_bytes_uploaded)));
 179                 message.append(QString("Session Download: %1, Upload: %2\n\n").arg(calcSize(m_session_bytes_downloaded)).arg(calcSize(m_session_bytes_uploaded)));
 180                 message.append(QString("Download: %L1 kB/s, Upload: %L2 kB/s\n\n").arg(m_down_speed, 0 , 'f', 1).arg(m_up_speed,0 ,'f', 1));
 181                 QString files_unit;
 182                 if (m_shared_files_count == 1)
 183                 {
 184                         files_unit = "file";
 185                 } else {
 186                         files_unit = "files";
 187                 }
 188                 message.append(QString("Sharing: %1 %2, Clients on queue: %3").arg(m_shared_files_count).arg(files_unit).arg(m_clients_in_up_queue));
 189                 painter->drawText(contentsRect, Qt::TextDontClip | Qt::AlignTop | Qt::AlignLeft | Qt::TextWordWrap, message);
 190
 191                 if (painter->boundingRect(contentsRect, Qt::TextDontClip | Qt::AlignTop | Qt::AlignLeft | Qt::TextWordWrap,
 192                          message).height() > contentsRect.height())
 193                 {
 194                         kDebug(m_debugChannel) << "Resizing";
 195                         resize(painter->boundingRect(contentsRect, message).height()+(contentsRect.topLeft().y()*2),
 196                                 painter->boundingRect(contentsRect, message).height()+(contentsRect.topLeft().y()*2));
 197                 }
 198         }
 199         painter->restore();
 200 }
 201
 202 QString PlasmaMuleApplet::calcSize (qlonglong in_size)
 203 {
 204         int unit=0;
 205         double size;
 206         QStringList units;
 207         units << "Bytes" << "kBs" << "MBs" << "GBs" << "TBs" << "PBs" << "BBs" << "ZBs" << "YBs";
 208
 209         while (in_size >1023)
 210         {
 211                 in_size /= 1024;
 212                 unit++;
 213         }
 214
 215         size = (in_size * 1024) / 1024;
 216         return QString("%L1 %2").arg(size, 0, 'f', 2).arg(units.at(unit));
 217 }
 218
 219 void PlasmaMuleApplet::connectToEngine()
 220 {
 221         m_aMuleEngine = dataEngine("plasmamule");
 222         m_aMuleEngine->connectAllSources(this, 0);
 223         connect(m_aMuleEngine, SIGNAL(sourceAdded(const QString&)), this, SLOT(onSourceAdded(const QString&)));
 224         connect(m_aMuleEngine, SIGNAL(sourceRemoved(const QString&)), this, SLOT(onSourceRemoved(const QString&)));
 225 }
 226
 227 void PlasmaMuleApplet::onSourceAdded(const QString& source)
 228 {
 229         kDebug(m_debugChannel) << "New Source: " << source << " added";
 230         m_aMuleEngine->connectSource(source, this, 0);
 231 }
 232
 233 void PlasmaMuleApplet::onSourceRemoved(const QString& source)
 234 {
 235         kDebug(m_debugChannel) << "Source: " << source << " removed";
 236         update();
 237 }
 238
 239 void PlasmaMuleApplet::dataUpdated(const QString& source, const Plasma::DataEngine::Data &data)
 240 {
 241         if (data.isEmpty())
 242         {
 243                 return;
 244         }
 245
 246         bool needs_update = FALSE;
 247         kDebug(m_debugChannel) << "Updating data" << data;
 248         if (data["cat_dirs"].toStringList() != m_catDirs && data.contains("cat_dirs"))
 249         {
 250                 m_catDirs = data["cat_dirs"].toStringList();
 251         }
 252         if (data["cat_names"].toStringList() != m_catNames && data.contains("cat_names"))
 253         {
 254                 m_catNames = data["cat_names"].toStringList();
 255         }
 256         if (data["os_active"].toBool() != m_os_active && data.contains("os_active"))
 257         {
 258                 m_os_active = data["os_active"].toBool();
 259                 needs_update = TRUE;
 260         }
 261         if (data["config_found"].toBool() != m_config_found && data.contains("config_found"))
 262         {
 263                 m_config_found = data["config_found"].toBool();
 264                 needs_update = TRUE;
 265         }
 266         if (data["ed2k_state"].toInt() != m_ed2k_state && data.contains("ed2k_state"))
 267         {
 268                 m_ed2k_state = data["ed2k_state"].toInt();
 269                 needs_update = TRUE;
 270         }
 271         if (data["ed2k_server_name"] != m_ed2k_server_name && data.contains("ed2k_server_name"))
 272         {
 273                 m_ed2k_server_name = data["ed2k_server_name"].toString();
 274                 needs_update = TRUE;
 275         }
 276         if (data["ed2k_server_ip"] != m_ed2k_server_ip && data.contains("ed2k_server_ip"))
 277         {
 278                 m_ed2k_server_ip = data["ed2k_server_ip"].toString();
 279                 needs_update = TRUE;
 280         }
 281         if (data["ed2k_server_port"].toInt() != m_ed2k_server_port && data.contains("ed2k_server_port"))
 282         {
 283                 m_ed2k_server_port = data["ed2k_server_port"].toInt();
 284                 needs_update = TRUE;
 285         }
 286         if (data["ed2k_id_high_low"] != m_ed2k_id_high_low && data.contains("ed2k_id_high_low"))
 287         {
 288                 m_ed2k_id_high_low = data["ed2k_id_high_low"].toString();
 289                 needs_update = TRUE;
 290         }
 291         if (data["kad_status"].toInt() != m_kad_status && data.contains("kad_status"))
 292         {
 293                 m_kad_status = data["kad_status"].toInt();
 294                 needs_update = TRUE;
 295         }
 296         if (data["down_speed"].toInt() != m_down_speed && data.contains("down_speed"))
 297         {
 298                 m_down_speed = data["down_speed"].toDouble();
 299                 needs_update = TRUE;
 300         }
 301         if (data["up_speed"].toDouble() != m_up_speed && data.contains("up_speed"))
 302         {
 303                 m_up_speed = data["up_speed"].toDouble();
 304                 needs_update = TRUE;
 305         }
 306         if (data["clients_in_up_queue"].toInt() != m_clients_in_up_queue && data.contains("clients_in_up_queue"))
 307         {
 308                 m_clients_in_up_queue = data["clients_in_up_queue"].toInt();
 309                 needs_update = TRUE;
 310         }
 311         if (data["shared_files_count"].toInt() != m_shared_files_count && data.contains("shared_files_count"))
 312         {
 313                 m_shared_files_count = data["shared_files_count"].toInt();
 314                 needs_update = TRUE;
 315         }
 316         if (data["nickname"] != m_nickname && data.contains("nickname"))
 317         {
 318                 m_nickname = data["nickname"].toString();
 319                 needs_update = TRUE;
 320         }
 321         if (data["total_bytes_downloaded"].toLongLong() != m_total_bytes_downloaded && data.contains("total_bytes_downloaded"))
 322         {
 323                 m_total_bytes_downloaded = data["total_bytes_downloaded"].toLongLong();
 324                 needs_update = TRUE;
 325         }
 326         if (data["total_bytes_uploaded"].toLongLong() != m_total_bytes_uploaded && data.contains("total_bytes_uploaded"))
 327         {
 328                 m_total_bytes_uploaded = data["total_bytes_uploaded"].toLongLong();
 329                 needs_update = TRUE;
 330         }
 331         if (data["version"] != m_version && data.contains("version"))
 332         {
 333                 m_version = data["version"].toString();
 334                 needs_update = TRUE;
 335         }
 336         if (data["session_bytes_downloaded"].toLongLong() != m_session_bytes_downloaded && data.contains("session_bytes_downloaded"))
 337         {
 338                 m_session_bytes_downloaded = data["session_bytes_downloaded"].toLongLong();
 339                 needs_update = TRUE;
 340         }
 341         if (data["session_bytes_uploaded"].toLongLong() != m_session_bytes_uploaded && data.contains("session_bytes_uploaded"))
 342         {
 343                 m_session_bytes_uploaded = data["session_bytes_uploaded"].toLongLong();
 344                 needs_update = TRUE;
 345         }
 346         if (data["uptime"].toInt() != m_uptime && data.contains("uptime"))
 347         {
 348                 m_uptime = data["uptime"].toInt();
 349                 needs_update = TRUE;
 350         }
 351
 352         if (needs_update)
 353         {
 354                 kDebug(m_debugChannel) << "Updating view";
 355                 update();
 356         }
 357 }
 358
 359 void PlasmaMuleApplet::dragEnterEvent(QGraphicsSceneDragDropEvent * event)
 360 {
 361         kDebug(m_debugChannel) << "Dragged Data detected " << event;
 362         if (event->mimeData()->hasUrls())
 363         {
 364                 event->acceptProposedAction();
 365         }
 366 }
 367
 368 void PlasmaMuleApplet::dropEvent(QGraphicsSceneDragDropEvent * event)
 369 {
 370         QStringList::const_iterator constIterator;
 371
 372         event->acceptProposedAction();
 373
 374         QMenu *menu = new QMenu;
 375
 376         if (m_catNames.count() == 1)
 377         {
 378                 sendLinkToEngine (event->mimeData()->text(), 0, this, m_debugChannel);
 379         } else {
 380                 for (constIterator = m_catNames.constBegin(); constIterator != m_catNames.constEnd(); constIterator++)
 381                 {
 382                         menu->addAction(*constIterator);
 383                         if (constIterator != m_catNames.constEnd())
 384                         {
 385                                 menu->addSeparator();
 386                         }
 387                 }
 388
 389                 QAction *cat_selection = menu->exec(QCursor::pos());
 390                 if (cat_selection)
 391                 {
 392                                 sendLinkToEngine (event->mimeData()->text(), m_catNames.indexOf(cat_selection->text()), this, m_debugChannel);
 393                 }
 394         }
 395
 396         delete menu;
 397 }
 398
 399 void PlasmaMuleApplet::contextMenuEvent(QGraphicsSceneContextMenuEvent * event)
 400 {
 401         QStringList::const_iterator constIterator;
 402         QMenu menu;
 403
 404         if (m_catDirs.count() == 1)
 405         {
 406                 menu.addAction (KIcon("folder"), QString("Default"));
 407         } else {
 408                 QMenu *open_sub_menu = menu.addMenu("Open Incoming");
 409                 for (constIterator = m_catNames.constBegin(); constIterator != m_catNames.constEnd(); constIterator++)
 410                 {
 411                         open_sub_menu->addAction(KIcon("folder"), "Folder for " + *constIterator);
 412                         if (constIterator != m_catNames.constEnd())
 413                         {
 414                                 open_sub_menu->addSeparator();
 415                         }
 416                 }
 417                 menu.addSeparator();
 418         }
 419
 420         QClipboard* clipboard = QApplication::clipboard();
 421
 422         if (!clipboard->text(QClipboard::Clipboard).isEmpty() || !clipboard->text(QClipboard::Selection).isEmpty())
 423         {
 424                 if (m_catDirs.count() == 1)
 425                 {
 426                         if (!clipboard->text(QClipboard::Clipboard).isEmpty())
 427                         {
 428                                 menu.addAction(KIcon("arrow-down-double"), "Download Link from Clipboard");
 429
 430                                 if (!clipboard->text(QClipboard::Selection).isEmpty())
 431                                 {
 432                                         menu.addSeparator();
 433                                 }
 434                         }
 435
 436                         if (!clipboard->text(QClipboard::Selection).isEmpty())
 437                         {
 438                                 menu.addAction(KIcon("arrow-down-double"), "Download Link from Selection");
 439                         }
 440                 } else  {
 441                         QMenu *download_sub_menu = menu.addMenu("Download Link");
 442
 443                         for (constIterator = m_catNames.constBegin(); constIterator != m_catNames.constEnd(); constIterator++)
 444                         {
 445                                 if (!clipboard->text(QClipboard::Clipboard).isEmpty())
 446                                 {
 447                                         download_sub_menu->addAction(KIcon("arrow-down-double"), "Clipboard->" + *constIterator);
 448
 449                                         if (!clipboard->text(QClipboard::Selection).isEmpty())
 450                                         {
 451                                                 download_sub_menu->addSeparator();
 452                                         }
 453                                 }
 454
 455                                 if (!clipboard->text(QClipboard::Selection).isEmpty())
 456                                 {
 457                                         download_sub_menu->addAction(KIcon("arrow-down-double"), "Selection->" + *constIterator);
 458                                 }
 459
 460                                 if (constIterator != m_catNames.constEnd())
 461                                 {
 462                                 download_sub_menu->addSeparator();
 463                                 }
 464                         }
 465                 }
 466         }
 467
 468         menu.addSeparator();
 469         menu.addAction(KIcon("documentinfo"), "About");
 470
 471         QAction* selectedItem = menu.exec(QCursor::pos());
 472         if (selectedItem)
 473         {
 474                 if (selectedItem->text() == "About")
 475                 {
 476                         KPluginInfo* service = new KPluginInfo (KService::serviceByDesktopName ("plasma-applet-plasmamule"));
 477                         KAboutData* aboutData = new KAboutData (service->name().toUtf8(),
 478                                 service->name().toUtf8(),
 479                                 ki18n(service->pluginName().toUtf8()),
 480                                 service->version().toUtf8(),
 481                                 ki18n(service->comment().toUtf8()),
 482                                 KAboutData::License_GPL_V3,
 483                                 ki18n(QByteArray()),
 484                                 ki18n(QByteArray()),
 485                                 service->website().toLatin1(),
 486                                 service->email().toLatin1());
 487                         aboutData->addAuthor (ki18n(service->author().toUtf8()),
 488                                 ki18n(QByteArray()),
 489                                 service->email().toLatin1(),
 490                                 service->website().toLatin1());
 491                         aboutData->setTranslator(ki18nc ("NAME OF TRANSLATORS", "Your names"),
 492                                 ki18nc("EMAIL OF TRANSLATORS", "Your emails"));
 493                         aboutData->setProgramIconName (service->icon());
 494
 495                         KAboutApplicationDialog* about = new KAboutApplicationDialog(aboutData, KAboutApplicationDialog::HideTranslators);
 496                         about->exec();
 497                 } else if (selectedItem->text().startsWith("Folder for"))
 498                 {
 499                         kDebug(m_debugChannel) << "Opening Folder " << m_catDirs.at(m_catNames.indexOf(selectedItem->text().remove("Folder for ")));
 500                         KUrl url(m_catDirs.at(m_catNames.indexOf(selectedItem->text().remove("Folder for "))) + "/");
 501                         (void) new KRun( url, 0, true );
 502                 } else if (selectedItem->text().startsWith("Download"))
 503                 {
 504                         if (selectedItem->text().remove("Download Link from ") == "Clipboard")
 505                         {
 506                                 sendLinkToEngine (clipboard->text(QClipboard::Clipboard), 0, this, m_debugChannel);
 507                         } else {
 508                                 sendLinkToEngine (clipboard->text(QClipboard::Selection), 0, this, m_debugChannel);
 509                         }
 510                 } else if (selectedItem->text().startsWith("Clipboard->"))
 511                 {
 512                         sendLinkToEngine (clipboard->text(QClipboard::Clipboard), m_catNames.indexOf(selectedItem->text().remove("Clipboard->")), this, m_debugChannel);
 513                 } else if (selectedItem->text().startsWith("Selection->"))
 514                 {
 515                         sendLinkToEngine (clipboard->text(QClipboard::Selection), m_catNames.indexOf(selectedItem->text().remove("Selection->")), this, m_debugChannel);
 516                 }
 517         }
 518 }
 519
 520 #include "plasma-applet-plasmamule.moc"