Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdebase@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 435 insertions, 0 deletions

diff --git a/khotkeys/shared/triggers.cpp b/khotkeys/shared/triggers.cpp
new file mode 100644
index 000000000..1febedfa9
--- /dev/null
+++ b/khotkeys/shared/triggers.cpp
@@ -0,0 +1,435 @@
+/****************************************************************************
+
+ KHotKeys
+
+ Copyright (C) 1999-2001 Lubos Lunak <l.lunak@kde.org>
+
+ Distributed under the terms of the GNU General Public License version 2.
+
+****************************************************************************/
+
+#define _TRIGGERS_CPP_
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "triggers.h"
+
+#include <kglobalaccel.h>
+#include <kconfig.h>
+#include <kdebug.h>
+#include <kwinmodule.h>
+#include <klocale.h>
+#include <netwm_def.h>
+#include <kaccel.h>
+
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+
+#include "actions.h"
+#include "action_data.h"
+#include "input.h"
+#include "gestures.h"
+#include "windows.h"
+#include "voices.h"
+
+namespace KHotKeys
+{
+
+// Trigger
+
+void Trigger::cfg_write( KConfig& cfg_P ) const
+    {
+    cfg_P.writeEntry( "Type", "ERROR" );
+    }
+
+Trigger* Trigger::create_cfg_read( KConfig& cfg_P, Action_data* data_P )
+    {
+    QString type = cfg_P.readEntry( "Type" );
+    if( type == "SHORTCUT" || type == "SINGLE_SHORTCUT" )
+        return new Shortcut_trigger( cfg_P, data_P );
+    if( type == "WINDOW" )
+        return new Window_trigger( cfg_P, data_P );
+    if( type == "GESTURE" )
+        return new Gesture_trigger(cfg_P, data_P );
+    if( type == "VOICE" )
+        return new Voice_trigger (cfg_P, data_P );
+
+    kdWarning( 1217 ) << "Unknown Trigger type read from cfg file\n";
+    return NULL;
+    }
+
+// Trigger_list
+
+Trigger_list::Trigger_list( KConfig& cfg_P, Action_data* data_P )
+    : QPtrList< Trigger >()
+    {
+    setAutoDelete( true );
+    _comment = cfg_P.readEntry( "Comment" );
+    QString save_cfg_group = cfg_P.group();
+    int cnt = cfg_P.readNumEntry( "TriggersCount", 0 );
+    for( int i = 0;
+         i < cnt;
+         ++i )
+        {
+        cfg_P.setGroup( save_cfg_group + QString::number( i ));
+        Trigger* trigger = Trigger::create_cfg_read( cfg_P, data_P );
+        if( trigger )
+            append( trigger );
+        }
+    cfg_P.setGroup( save_cfg_group );
+    }
+
+void Trigger_list::cfg_write( KConfig& cfg_P ) const
+    {
+    cfg_P.writeEntry( "Comment", comment());
+    QString save_cfg_group = cfg_P.group();
+    int i = 0;
+    for( Iterator it( *this );
+         it;
+         ++it, ++i )
+        {
+        cfg_P.setGroup( save_cfg_group + QString::number( i ));
+        it.current()->cfg_write( cfg_P );
+        }
+    cfg_P.setGroup( save_cfg_group );
+    cfg_P.writeEntry( "TriggersCount", i );
+    }
+
+Trigger_list* Trigger_list::copy( Action_data* data_P ) const
+    {
+    Trigger_list* ret = new Trigger_list( comment());
+    for( Iterator it( *this );
+         it;
+         ++it )
+        ret->append( it.current()->copy( data_P ));
+    return ret;
+    }
+
+void Trigger_list::activate( bool activate_P )
+    {
+    for( Iterator it( *this );
+         it;
+         ++it )
+        ( *it )->activate( activate_P );
+    }
+
+// Shortcut_trigger
+
+Shortcut_trigger::Shortcut_trigger( Action_data* data_P, const KShortcut& shortcut_P )
+    : Trigger( data_P ), _shortcut( shortcut_P )
+    {
+    keyboard_handler->insert_item( shortcut(), this );
+    }
+
+Shortcut_trigger::Shortcut_trigger( KConfig& cfg_P, Action_data* data_P )
+    : Trigger( cfg_P, data_P ), _shortcut( cfg_P.readEntry( "Key", 0 ))
+    {
+    keyboard_handler->insert_item( shortcut(), this );
+    }
+
+Shortcut_trigger::~Shortcut_trigger()
+    {
+    keyboard_handler->remove_item( shortcut(), this );
+    }
+
+void Shortcut_trigger::cfg_write( KConfig& cfg_P ) const
+    {
+    base::cfg_write( cfg_P );
+    cfg_P.writeEntry( "Key", _shortcut.toStringInternal());
+    cfg_P.writeEntry( "Type", "SHORTCUT" ); // overwrites value set in base::cfg_write()
+    }
+
+Shortcut_trigger* Shortcut_trigger::copy( Action_data* data_P ) const
+    {
+    kdDebug( 1217 ) << "Shortcut_trigger::copy()" << endl;
+    return new Shortcut_trigger( data_P ? data_P : data, shortcut());
+    }
+
+const QString Shortcut_trigger::description() const
+    {
+    // CHECKME vice mods
+    return i18n( "Shortcut trigger: " ) + _shortcut.toString();
+    // CHECKME i18n pro toString() ?
+    }
+
+bool Shortcut_trigger::handle_key( const KShortcut& shortcut_P )
+    {
+    if( shortcut() == shortcut_P )
+        {
+        windows_handler->set_action_window( 0 ); // use active window
+        data->execute();
+        return true;
+        }
+    return false;
+    }
+
+void Shortcut_trigger::activate( bool activate_P )
+    {
+    if( activate_P && khotkeys_active())
+        keyboard_handler->activate_receiver( this );
+    else
+        keyboard_handler->deactivate_receiver( this );
+    }
+
+// Window_trigger
+
+Window_trigger::Window_trigger( KConfig& cfg_P, Action_data* data_P )
+    : Trigger( cfg_P, data_P ), active( false )
+    {
+//    kdDebug( 1217 ) << "Window_trigger" << endl;
+    QString save_cfg_group = cfg_P.group();
+    cfg_P.setGroup( save_cfg_group + "Windows" );
+    _windows = new Windowdef_list( cfg_P );
+    cfg_P.setGroup( save_cfg_group );
+    window_actions = cfg_P.readNumEntry( "WindowActions" );
+    init();
+    }
+
+Window_trigger::~Window_trigger()
+    {
+//    kdDebug( 1217 ) << "~Window_trigger :" << this << endl;
+    disconnect( windows_handler, NULL, this, NULL );
+    delete _windows;
+    }
+
+void Window_trigger::init()
+    {
+    kdDebug( 1217 ) << "Window_trigger::init()" << endl;
+    connect( windows_handler, SIGNAL( window_added( WId )), this, SLOT( window_added( WId )));
+    connect( windows_handler, SIGNAL( window_removed( WId )), this, SLOT( window_removed( WId )));
+    if( window_actions & ( WINDOW_ACTIVATES | WINDOW_DEACTIVATES /*| WINDOW_DISAPPEARS*/ ))
+        connect( windows_handler, SIGNAL( active_window_changed( WId )),
+            this, SLOT( active_window_changed( WId )));
+    connect( windows_handler, SIGNAL( window_changed( WId, unsigned int )),
+        this, SLOT( window_changed( WId, unsigned int )));
+    }
+
+void Window_trigger::activate( bool activate_P )
+    {
+    active = activate_P && khotkeys_active();
+    }
+
+void Window_trigger::window_added( WId window_P )
+    {
+    bool matches = windows()->match( Window_data( window_P ));
+    existing_windows[ window_P ] = matches;
+    kdDebug( 1217 ) << "Window_trigger::w_added() : " << matches << endl;
+    if( active && matches && ( window_actions & WINDOW_APPEARS ))
+        {
+        windows_handler->set_action_window( window_P );
+        data->execute();
+        }
+    }
+
+void Window_trigger::window_removed( WId window_P )
+    {
+    if( existing_windows.contains( window_P ))
+        {
+        bool matches = existing_windows[ window_P ];
+        kdDebug( 1217 ) << "Window_trigger::w_removed() : " << matches << endl;
+        if( active && matches && ( window_actions & WINDOW_DISAPPEARS ))
+            {
+            windows_handler->set_action_window( window_P );
+            data->execute();
+            }
+        existing_windows.remove( window_P );
+        // CHECKME jenze co kdyz se window_removed zavola pred active_window_changed ?
+        }
+    else
+        kdDebug( 1217 ) << "Window_trigger::w_removed()" << endl;
+    }
+
+void Window_trigger::active_window_changed( WId window_P )
+    {
+    bool was_match = false;
+    if( existing_windows.contains( last_active_window ))
+        was_match = existing_windows[ last_active_window ];
+    if( active && was_match && ( window_actions & WINDOW_DEACTIVATES ))
+        {
+        windows_handler->set_action_window( window_P );
+        data->execute();
+        }
+/*    bool matches = windows()->match( Window_data( window_P ));
+    existing_windows[ window_P ] = matches;*/
+    bool matches = existing_windows.contains( window_P )
+        ? existing_windows[ window_P ] : false;
+    if( active && matches && ( window_actions & WINDOW_ACTIVATES ))
+        {
+        windows_handler->set_action_window( window_P );
+        data->execute();
+        }
+    kdDebug( 1217 ) << "Window_trigger::a_w_changed() : " << was_match << "|" << matches << endl;
+    last_active_window = window_P;
+    }
+
+void Window_trigger::window_changed( WId window_P, unsigned int dirty_P )
+    { // CHECKME snad nebude mit vliv, kdyz budu kaslat na properties_P a zkratka
+      // kontrolovat kazdou zmenu
+      // CHECKME kdyz se zmeni okno z match na non-match, asi to nebrat jako DISAPPEAR
+    if( ! ( dirty_P & ( NET::WMName | NET::WMWindowType )))
+        return;
+    kdDebug( 1217 ) << "Window_trigger::w_changed()" << endl;
+    bool was_match = false;
+    if( existing_windows.contains( window_P ))
+        was_match = existing_windows[ window_P ];
+    bool matches = windows()->match( Window_data( window_P ));
+    existing_windows[ window_P ] = matches;
+    if( active && matches && !was_match )
+        if( window_actions & WINDOW_APPEARS )
+            {
+            windows_handler->set_action_window( window_P );
+            data->execute();
+            }
+        else if( window_actions & WINDOW_ACTIVATES && window_P == windows_handler->active_window())
+            {
+            windows_handler->set_action_window( window_P );
+            data->execute();
+            }
+    kdDebug( 1217 ) << "Window_trigger::w_changed() : " << was_match << "|" << matches << endl;
+    }
+
+void Window_trigger::cfg_write( KConfig& cfg_P ) const
+    {
+    base::cfg_write( cfg_P );
+    QString save_cfg_group = cfg_P.group();
+    cfg_P.setGroup( save_cfg_group + "Windows" );
+    windows()->cfg_write( cfg_P );
+    cfg_P.setGroup( save_cfg_group );
+    cfg_P.writeEntry( "WindowActions", window_actions );
+    cfg_P.writeEntry( "Type", "WINDOW" ); // overwrites value set in base::cfg_write()
+    }
+
+#ifndef COVARIANT_RETURN_BROKEN    // stupid gcc, it doesn't even warn it can't do this
+Window_trigger* Window_trigger::copy( Action_data* data_P ) const
+#else
+Trigger* Window_trigger::copy( Action_data* data_P ) const
+#endif
+    {
+    Window_trigger* ret = new Window_trigger( data_P ? data_P : data, windows()->copy(),
+        window_actions );
+    ret->existing_windows = existing_windows; // CHECKME je tohle vazne treba ?
+    return ret;
+    }
+
+const QString Window_trigger::description() const
+    {
+    return i18n( "Window trigger: " ) + windows()->comment();
+    }
+
+// Gesture_trigger
+
+Gesture_trigger::Gesture_trigger( Action_data* data_P, const QString &gesturecode_P )
+    : Trigger( data_P ), _gesturecode( gesturecode_P )
+    {
+    }
+
+Gesture_trigger::Gesture_trigger( KConfig& cfg_P, Action_data* data_P )
+    : Trigger( cfg_P, data_P )
+    {
+    _gesturecode = cfg_P.readEntry( "Gesture" );
+    }
+
+Gesture_trigger::~Gesture_trigger()
+    {
+    gesture_handler->unregister_handler( this, SLOT( handle_gesture( const QString&, WId )));
+    }
+
+void Gesture_trigger::cfg_write( KConfig& cfg_P ) const
+    {
+    base::cfg_write( cfg_P );
+    cfg_P.writeEntry( "Gesture", gesturecode());
+    cfg_P.writeEntry( "Type", "GESTURE" ); // overwrites value set in base::cfg_write()
+    }
+
+Trigger* Gesture_trigger::copy( Action_data* data_P ) const
+    {
+    kdDebug( 1217 ) << "Gesture_trigger::copy()" << endl;
+    return new Gesture_trigger( data_P ? data_P : data, gesturecode());
+    }
+
+const QString Gesture_trigger::description() const
+    {
+    return i18n( "Gesture trigger: " ) + gesturecode();
+    }
+
+void Gesture_trigger::handle_gesture( const QString &gesture_P, WId window_P )
+    {
+    if( gesturecode() == gesture_P )
+        {
+        windows_handler->set_action_window( window_P );
+        data->execute();
+        }
+    }
+
+void Gesture_trigger::activate( bool activate_P )
+    {
+    if( activate_P )
+        gesture_handler->register_handler( this, SLOT( handle_gesture( const QString&, WId )));
+    else
+        gesture_handler->unregister_handler( this, SLOT( handle_gesture( const QString&, WId )));
+    }
+
+
+// Voice_trigger
+
+	Voice_trigger::Voice_trigger( Action_data* data_P, const QString &Voicecode_P, const VoiceSignature& signature1_P, const VoiceSignature& signature2_P )
+	: Trigger( data_P ), _voicecode( Voicecode_P )
+    {
+		_voicesignature[0]=signature1_P;
+		_voicesignature[1]=signature2_P;
+    }
+
+Voice_trigger::Voice_trigger( KConfig& cfg_P, Action_data* data_P )
+	: Trigger( cfg_P, data_P )
+    {
+    _voicecode = cfg_P.readEntry( "Name" );
+	_voicesignature[0].read( &cfg_P , "Signature1" );
+	_voicesignature[1].read( &cfg_P , "Signature2" );
+    }
+
+Voice_trigger::~Voice_trigger()
+    {
+    voice_handler->unregister_handler( this );
+    }
+
+void Voice_trigger::cfg_write( KConfig& cfg_P ) const
+    {
+    base::cfg_write( cfg_P );
+    cfg_P.writeEntry( "Name", voicecode());
+    cfg_P.writeEntry( "Type", "VOICE" ); // overwrites value set in base::cfg_write()
+	_voicesignature[0].write( &cfg_P , "Signature1" );
+	_voicesignature[1].write( &cfg_P , "Signature2" );
+	}
+
+Trigger* Voice_trigger::copy( Action_data* data_P ) const
+    {
+    kdDebug( 1217 ) << "Voice_trigger::copy()" << endl;
+	return new Voice_trigger( data_P ? data_P : data, voicecode(), voicesignature(1) , voicesignature(2) );
+    }
+
+const QString Voice_trigger::description() const
+    {
+    return i18n( "Voice trigger: " ) + voicecode();
+    }
+
+void Voice_trigger::handle_Voice(  )
+    {
+        windows_handler->set_action_window( 0 ); // use active window
+        data->execute();
+
+    }
+
+void Voice_trigger::activate( bool activate_P )
+    {
+    if( activate_P && khotkeys_active())
+		voice_handler->register_handler( this );
+    else
+        voice_handler->unregister_handler( this );
+    }
+
+
+} // namespace KHotKeys
+
+#include "triggers.moc"