workspace/klipper/urlgrabber.cpp

   1 // -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8; -*-
   2 /* This file is part of the KDE project
   3    Copyright (C) (C) 2000,2001,2002 by Carsten Pfeiffer <pfeiffer@kde.org>
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public
   7    License as published by the Free Software Foundation; either
   8    version 2 of the License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; see the file COPYING.  If not, write to
  17    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18    Boston, MA 02110-1301, USA.
  19 */
  20
  21 #include <netwm.h>
  22
  23 #include <QTimer>
  24 #include <QX11Info>
  25 #include <QUuid>
  26
  27 #include <kconfig.h>
  28 #include <kdialog.h>
  29 #include <ktextedit.h>
  30 #include <klocale.h>
  31 #include <kmenu.h>
  32 #include <kprocess.h>
  33 #include <kservice.h>
  34 #include <kdebug.h>
  35 #include <kstringhandler.h>
  36 #include <kmacroexpander.h>
  37 #include <kglobal.h>
  38
  39 #include "klippersettings.h"
  40 #include "urlgrabber.h"
  41
  42 // TODO:
  43 // - script-interface?
  44
  45 URLGrabber::URLGrabber()
  46 {
  47     m_myCurrentAction = 0L;
  48     m_myMenu = 0L;
  49     m_myPopupKillTimeout = 8;
  50     m_trimmed = true;
  51
  52     m_myPopupKillTimer = new QTimer( this );
  53     m_myPopupKillTimer->setSingleShot( true );
  54     connect( m_myPopupKillTimer, SIGNAL( timeout() ),
  55              SLOT( slotKillPopupMenu() ));
  56
  57     // testing
  58     /*
  59     ClipAction *action;
  60     action = new ClipAction( "^http:\\/\\/", "Web-URL" );
  61     action->addCommand("kfmclient exec %s", "Open with Konqi", true);
  62     action->addCommand("netscape -no-about-splash -remote \"openURL(%s, new-window)\"", "Open with Netscape", true);
  63     m_myActions->append( action );
  64
  65     action = new ClipAction( "^mailto:", "Mail-URL" );
  66     action->addCommand("kmail --composer %s", "Launch kmail", true);
  67     m_myActions->append( action );
  68
  69     action = new ClipAction( "^\\/.+\\.jpg$", "Jpeg-Image" );
  70     action->addCommand("kuickshow %s", "Launch KuickShow", true);
  71     action->addCommand("kview %s", "Launch KView", true);
  72     m_myActions->append( action );
  73     */
  74 }
  75
  76
  77 URLGrabber::~URLGrabber()
  78 {
  79     qDeleteAll(m_myActions);
  80     m_myActions.clear();
  81     delete m_myMenu;
  82 }
  83
  84 //
  85 // Called from Klipper::slotRepeatAction, i.e. by pressing Ctrl-Alt-R
  86 // shortcut. I.e. never from clipboard monitoring
  87 //
  88 void URLGrabber::invokeAction( const QString& clip )
  89 {
  90     if ( !clip.isEmpty() )
  91         m_myClipData = clip;
  92     if ( m_trimmed )
  93         m_myClipData = m_myClipData.trimmed();
  94
  95     actionMenu( false );
  96 }
  97
  98
  99 void URLGrabber::setActionList( const ActionList& list )
 100 {
 101     qDeleteAll(m_myActions);
 102     m_myActions.clear();
 103     m_myActions = list;
 104 }
 105
 106
 107 const ActionList& URLGrabber::matchingActions( const QString& clipData )
 108 {
 109     m_myMatches.clear();
 110
 111     foreach (ClipAction* action, m_myActions) {
 112         if ( action->matches( clipData ) )
 113             m_myMatches.append( action );
 114     }
 115
 116     return m_myMatches;
 117 }
 118
 119
 120 bool URLGrabber::checkNewData( const QString& clipData )
 121 {
 122     // kDebug() << "** checking new data: " << clipData;
 123     m_myClipData = clipData;
 124     if ( m_trimmed )
 125         m_myClipData = m_myClipData.trimmed();
 126
 127     if ( m_myActions.isEmpty() )
 128         return false;
 129
 130     actionMenu( true ); // also creates m_myMatches
 131
 132     return !m_myMatches.isEmpty();
 133 }
 134
 135
 136 void URLGrabber::actionMenu( bool wm_class_check )
 137 {
 138     if ( m_myClipData.isEmpty() )
 139         return;
 140
 141     ActionList matchingActionsList = matchingActions( m_myClipData );
 142     ClipCommand *command = 0L;
 143
 144     if (!matchingActionsList.isEmpty()) {
 145         // don't react on konqi's/netscape's urls...
 146         if ( wm_class_check && isAvoidedWindow() )
 147             return;
 148
 149         QString item;
 150         m_myCommandMapper.clear();
 151
 152         m_myPopupKillTimer->stop();
 153
 154         m_myMenu = new KMenu;
 155
 156         connect(m_myMenu, SIGNAL(triggered(QAction*)), SLOT(slotItemSelected(QAction*)));
 157
 158         foreach (ClipAction* action, matchingActionsList) {
 159             QListIterator<ClipCommand*> it( action->commands() );
 160             if ( it.hasNext() )
 161                 m_myMenu->addTitle(KIcon( "klipper" ),
 162                         i18n("%1 - Actions For: %2", action->description(), KStringHandler::csqueeze(m_myClipData, 45)));
 163             while (it.hasNext()) {
 164                 command = it.next();
 165                 item = command->description;
 166                 if ( item.isEmpty() )
 167                     item = command->command;
 168
 169                 QString id = QUuid::createUuid().toString();
 170                 QAction * action = new QAction(this);
 171                 action->setData(id);
 172                 action->setText(item);
 173
 174                 if (!command->pixmap.isEmpty())
 175                     action->setIcon(KIcon(command->pixmap));
 176
 177                 m_myCommandMapper.insert(id, command);
 178                 m_myMenu->addAction(action);
 179             }
 180         }
 181
 182         // only insert this when invoked via clipboard monitoring, not from an
 183         // explicit Ctrl-Alt-R
 184         if ( wm_class_check )
 185         {
 186             m_myMenu->addSeparator();
 187             QAction *disableAction = new QAction(i18n("Disable This Popup"), this);
 188             connect(disableAction, SIGNAL(triggered()), SIGNAL(sigDisablePopup()));
 189             m_myMenu->addAction(disableAction);
 190         }
 191         m_myMenu->addSeparator();
 192         // add an edit-possibility
 193         QAction *editAction = new QAction(KIcon("document-properties"), i18n("&Edit Contents..."), this);
 194         connect(editAction, SIGNAL(triggered()), SLOT(editData()));
 195         m_myMenu->addAction(editAction);
 196
 197         QAction *cancelAction = new QAction(KIcon("dialog-cancel"), i18n("&Cancel"), this);
 198         connect(cancelAction, SIGNAL(triggered()), m_myMenu, SLOT(hide()));
 199         m_myMenu->addAction(cancelAction);
 200
 201         if ( m_myPopupKillTimeout > 0 )
 202             m_myPopupKillTimer->start( 1000 * m_myPopupKillTimeout );
 203
 204         emit sigPopup( m_myMenu );
 205     }
 206 }
 207
 208
 209 void URLGrabber::slotItemSelected(QAction *action)
 210 {
 211     if (m_myMenu)
 212         m_myMenu->hide(); // deleted by the timer or the next action
 213
 214     QString id = action->data().toString();
 215
 216     if (id.isEmpty()) {
 217         kDebug() << "Klipper: no command associated";
 218         return;
 219     }
 220
 221     QHash<QString, ClipCommand*>::iterator i = m_myCommandMapper.find(id);
 222     ClipCommand *command = i.value();
 223
 224     if (command)
 225         execute(command);
 226     else
 227         kDebug() << "Klipper: cannot find associated action";
 228 }
 229
 230
 231 void URLGrabber::execute( const struct ClipCommand *command ) const
 232 {
 233     if ( command->isEnabled ) {
 234         QHash<QChar,QString> map;
 235         map.insert( 's', m_myClipData );
 236         // commands executed should always have a parent,
 237         // but a simple check won't hurt...
 238         if ( command->parent )
 239         {
 240             const QStringList matches = command->parent->regExpMatches();
 241             // support only %0 and the first 9 matches...
 242             const int numMatches = qMin(10, matches.count());
 243             for ( int i = 0; i < numMatches; ++i )
 244                 map.insert( QChar( '0' + i ), matches.at( i ) );
 245         }
 246         else
 247         {
 248             kDebug() << "No parent for" << command->description << "(" << command->command << ")";
 249         }
 250         QString cmdLine = KMacroExpander::expandMacrosShellQuote( command->command, map );
 251
 252         if ( cmdLine.isEmpty() )
 253             return;
 254
 255         KProcess proc;
 256         proc.setShellCommand(cmdLine.trimmed());
 257         if (!proc.startDetached())
 258             kDebug() << "Klipper: Could not start process!";
 259     }
 260 }
 261
 262
 263 void URLGrabber::editData()
 264 {
 265     m_myPopupKillTimer->stop();
 266     KDialog *dlg = new KDialog( 0 );
 267     dlg->setModal( true );
 268     dlg->setCaption( i18n("Edit Contents") );
 269     dlg->setButtons( KDialog::Ok | KDialog::Cancel );
 270
 271     KTextEdit *edit = new KTextEdit( dlg );
 272     edit->setText( m_myClipData );
 273     edit->setFocus();
 274     edit->setMinimumSize( 300, 40 );
 275     dlg->setMainWidget( edit );
 276     dlg->adjustSize();
 277
 278     if ( dlg->exec() == KDialog::Accepted ) {
 279         m_myClipData = edit->toPlainText();
 280         QTimer::singleShot( 0, this, SLOT( slotActionMenu() ) );
 281     }
 282     else
 283     {
 284         m_myMenu->deleteLater();
 285         m_myMenu = 0;
 286     }
 287     delete dlg;
 288 }
 289
 290
 291 void URLGrabber::loadSettings()
 292 {
 293     m_trimmed = KlipperSettings::stripWhiteSpace();
 294     m_myAvoidWindows = KlipperSettings::noActionsForWM_CLASS();
 295     m_myPopupKillTimeout = KlipperSettings::timeoutForActionPopups();
 296
 297     qDeleteAll(m_myActions);
 298     m_myActions.clear();
 299
 300     KConfigGroup cg(KGlobal::config(), "General");
 301     int num = cg.readEntry("Number of Actions", 0);
 302     QString group;
 303     for ( int i = 0; i < num; i++ ) {
 304         group = QString("Action_%1").arg( i );
 305         m_myActions.append( new ClipAction( KGlobal::config(), group ) );
 306     }
 307 }
 308
 309 void URLGrabber::saveSettings() const
 310 {
 311     KConfigGroup cg(KGlobal::config(), "General");
 312     cg.writeEntry( "Number of Actions", m_myActions.count() );
 313
 314     int i = 0;
 315     QString group;
 316     foreach (ClipAction* action, m_myActions) {
 317         group = QString("Action_%1").arg( i );
 318         action->save( KGlobal::config(), group );
 319         ++i;
 320     }
 321
 322     KlipperSettings::setNoActionsForWM_CLASS(m_myAvoidWindows);
 323 }
 324
 325 // find out whether the active window's WM_CLASS is in our avoid-list
 326 // digged a little bit in netwm.cpp
 327 bool URLGrabber::isAvoidedWindow() const
 328 {
 329     Display *d = QX11Info::display();
 330     static Atom wm_class = XInternAtom( d, "WM_CLASS", true );
 331     static Atom active_window = XInternAtom( d, "_NET_ACTIVE_WINDOW", true );
 332     Atom type_ret;
 333     int format_ret;
 334     unsigned long nitems_ret, unused;
 335     unsigned char *data_ret;
 336     long BUFSIZE = 2048;
 337     bool ret = false;
 338     Window active = 0L;
 339     QString wmClass;
 340
 341     // get the active window
 342     if (XGetWindowProperty(d, DefaultRootWindow( d ), active_window, 0l, 1l,
 343                            False, XA_WINDOW, &type_ret, &format_ret,
 344                            &nitems_ret, &unused, &data_ret)
 345         == Success) {
 346         if (type_ret == XA_WINDOW && format_ret == 32 && nitems_ret == 1) {
 347             active = *((Window *) data_ret);
 348         }
 349         XFree(data_ret);
 350     }
 351     if ( !active )
 352         return false;
 353
 354     // get the class of the active window
 355     if ( XGetWindowProperty(d, active, wm_class, 0L, BUFSIZE, False, XA_STRING,
 356                             &type_ret, &format_ret, &nitems_ret,
 357                             &unused, &data_ret ) == Success) {
 358         if ( type_ret == XA_STRING && format_ret == 8 && nitems_ret > 0 ) {
 359             wmClass = QString::fromUtf8( (const char *) data_ret );
 360             ret = (m_myAvoidWindows.indexOf( wmClass ) != -1);
 361         }
 362
 363         XFree( data_ret );
 364     }
 365
 366     return ret;
 367 }
 368
 369
 370 void URLGrabber::slotKillPopupMenu()
 371 {
 372     if ( m_myMenu && m_myMenu->isVisible() )
 373     {
 374         if ( m_myMenu->geometry().contains( QCursor::pos() ) &&
 375              m_myPopupKillTimeout > 0 )
 376         {
 377             m_myPopupKillTimer->start( 1000 * m_myPopupKillTimeout );
 378             return;
 379         }
 380     }
 381
 382     if ( m_myMenu ) {
 383         m_myMenu->deleteLater();
 384         m_myMenu = 0;
 385     }
 386 }
 387
 388 ///////////////////////////////////////////////////////////////////////////
 389 ////////
 390
 391 ClipCommand::ClipCommand(ClipAction *_parent, const QString &_command, const QString &_description,
 392                          bool _isEnabled, const QString &_icon)
 393     : parent(_parent),
 394       command(_command),
 395       description(_description),
 396       isEnabled(_isEnabled)
 397 {
 398     int len = command.indexOf(" ");
 399     if (len == -1)
 400         len = command.length();
 401
 402     if (!_icon.isEmpty())
 403         pixmap = _icon;
 404     else
 405     {
 406     KService::Ptr service= KService::serviceByDesktopName(command.left(len));
 407     if (service)
 408         pixmap = service->icon();
 409     else
 410         pixmap.clear();
 411     }
 412 }
 413
 414
 415 ClipAction::ClipAction( const QString& regExp, const QString& description )
 416     : m_myRegExp( regExp ), m_myDescription( description )
 417 {
 418 }
 419
 420
 421 ClipAction::ClipAction( const ClipAction& action )
 422 {
 423     m_myRegExp      = action.m_myRegExp;
 424     m_myDescription = action.m_myDescription;
 425
 426     ClipCommand *command = 0L;
 427     QListIterator<ClipCommand*> it( m_myCommands );
 428     while (it.hasNext()) {
 429         command = it.next();
 430         addCommand(command->command, command->description, command->isEnabled);
 431     }
 432 }
 433
 434
 435 ClipAction::ClipAction( KSharedConfigPtr kc, const QString& group )
 436     : m_myRegExp( kc->group(group).readEntry("Regexp") ),
 437       m_myDescription (kc->group(group).readEntry("Description") )
 438 {
 439     KConfigGroup cg(kc, group);
 440
 441     int num = cg.readEntry( "Number of commands", 0 );
 442
 443     // read the commands
 444     for ( int i = 0; i < num; i++ ) {
 445         QString _group = group + "/Command_%1";
 446         KConfigGroup _cg(kc, _group.arg(i));
 447
 448         addCommand( _cg.readPathEntry( "Commandline", QString() ),
 449                     _cg.readEntry( "Description" ), // i18n'ed
 450                     _cg.readEntry( "Enabled" , false),
 451                     _cg.readEntry( "Icon") );
 452     }
 453 }
 454
 455
 456 ClipAction::~ClipAction()
 457 {
 458     qDeleteAll(m_myCommands);
 459 }
 460
 461
 462 void ClipAction::addCommand( const QString& command,
 463                              const QString& description, bool enabled, const QString& icon )
 464 {
 465     if ( command.isEmpty() )
 466         return;
 467
 468     struct ClipCommand *cmd = new ClipCommand( this, command, description, enabled, icon );
 469     //    cmd->id = m_myCommands.count(); // superfluous, I think...
 470     m_myCommands.append( cmd );
 471 }
 472
 473
 474 // precondition: we're in the correct action's group of the KConfig object
 475 void ClipAction::save( KSharedConfigPtr kc, const QString& group ) const
 476 {
 477     KConfigGroup cg(kc, group);
 478     cg.writeEntry( "Description", description() );
 479     cg.writeEntry( "Regexp", regExp() );
 480     cg.writeEntry( "Number of commands", m_myCommands.count() );
 481
 482     struct ClipCommand *cmd;
 483     QListIterator<struct ClipCommand*> it( m_myCommands );
 484
 485     // now iterate over all commands of this action
 486     int i = 0;
 487     while (it.hasNext()) {
 488         cmd = it.next();
 489         QString _group = group + "/Command_%1";
 490         KConfigGroup cg(kc, _group.arg(i));
 491
 492         cg.writePathEntry( "Commandline", cmd->command );
 493         cg.writeEntry( "Description", cmd->description );
 494         cg.writeEntry( "Enabled", cmd->isEnabled );
 495
 496         ++i;
 497     }
 498 }
 499
 500 #include "urlgrabber.moc"