/// <remarks> /// Sets the key-binding to be used for manual text /// completion, text rotation in a history list as /// well as a completion list. /// When the keys set by this function are pressed, a /// signal defined by the inheriting widget will be activated. /// If the default value or 0 is specified by the second /// parameter, then the key-binding as defined in the global /// setting should be used. This method returns false value /// for <code>key</code> is negative or the supplied key-binding conflicts /// with the ones set for one of the other features. /// NOTE: To use a modifier key (Shift, Ctrl, Alt) as part of /// the key-binding simply simply <code>sum</code> up the values of the /// modifier and the actual key. For example, to use CTRL+E as /// a key binding for one of the items, you would simply supply /// <code></code>"Qt.CtrlButton + Qt.Key_E" as the second argument to this /// function. /// <param> name="item" the feature whose key-binding needs to be set: /// </param> /// <li> /// TextCompletion the manual completion key-binding. /// </li> /// /// <li> /// PrevCompletionMatch the previous match key for multiple completion. /// </li> /// /// <li> /// NextCompletionMatch the next match key for for multiple completion. /// </li> /// /// <li> /// SubstringCompletion the key for substring completion /// </li> /// <param> name="key" key-binding used to rotate down in a list. /// </param></remarks> <return> true if key-binding can successfully be set. /// </return> /// <short> Sets the key-binding to be used for manual text completion, text rotation in a history list as well as a completion list.</short> /// <see> getKeyBinding</see> public bool SetKeyBinding(KCompletionBase.KeyBindingType item, KShortcut key) { return (bool) interceptor.Invoke("setKeyBinding$#", "setKeyBinding(KCompletionBase::KeyBindingType, const KShortcut&)", typeof(bool), typeof(KCompletionBase.KeyBindingType), item, typeof(KShortcut), key); }
/// <remarks> /// Sets the global shorcut to associate with this widget. /// </remarks> <short> Sets the global shorcut to associate with this widget.</short> public void SetGlobalShortcut(KShortcut shortcut) { applet.SetGlobalShortcut(shortcut); }
/// <remarks> /// Remove <code>keySeq</code> from this shortcut. /// If <code>handleEmpty</code> equals RemoveEmpty, following key sequences will move up to take the place of /// <code>keySeq.</code> Otherwise, key sequences equal to <code>keySeq</code> will be set to empty. /// <param> name="keySeq" remove this key sequence from the shortcut /// </param></remarks> <short> Remove <code>keySeq</code> from this shortcut.</short> public void Remove(QKeySequence keySeq, KShortcut.EmptyHandling handleEmpty) { interceptor.Invoke("remove#$", "remove(const QKeySequence&, KShortcut::EmptyHandling)", typeof(void), typeof(QKeySequence), keySeq, typeof(KShortcut.EmptyHandling), handleEmpty); }
/// <remarks> /// Returns shortcut as QList\<QKeySequence\>, and is equivalent to toList(RemoveEmpty). /// Be aware that empty shortcuts will not be included in the list; /// due to this, conversion operations like /// KShortcut b = (QList\<QKeySequence\>)KShortcut a /// will not always result in b == a. /// </remarks> <return> the shortcut converted to a QList\<QKeySequence\> /// </return> /// <short> Returns shortcut as QList\<QKeySequence\>, and is equivalent to toList(RemoveEmpty).</short> /// <remarks> /// The same as operator QList\<QKeySequence\>() /// If <code>handleEmpty</code> equals RemoveEmpty, empty key sequences will be left out of the result. /// Otherwise, empy key sequences will be included; you can be sure that /// shortcut.alternate() == shortcut.toList(KeepEmpty).at(1). /// </remarks> <return> the shortcut converted to a QList\<QKeySequence\> /// </return> /// <short> The same as operator QList\<QKeySequence\>() If <code>handleEmpty</code> equals RemoveEmpty, empty key sequences will be left out of the result.</short> public List<QKeySequence> ToList(KShortcut.EmptyHandling handleEmpty) { return (List<QKeySequence>) interceptor.Invoke("toList$", "toList(KShortcut::EmptyHandling) const", typeof(List<QKeySequence>), typeof(KShortcut.EmptyHandling), handleEmpty); }
/// <remarks> /// Copy constructor. /// </remarks> <short> Copy constructor.</short> public KShortcut(KShortcut other) : this((Type) null) { CreateProxy(); interceptor.Invoke("KShortcut#", "KShortcut(const KShortcut&)", typeof(void), typeof(KShortcut), other); }
/// <remarks> /// Sets the global shorcut to associate with this widget. /// </remarks> <short> Sets the global shorcut to associate with this widget.</short> public void SetGlobalShortcut(KShortcut shortcut) { interceptor.Invoke("setGlobalShortcut#", "setGlobalShortcut(const KShortcut&)", typeof(void), typeof(KShortcut), shortcut); }
/// <remarks> /// Saves the new shortcut \a cut for standard accel \a id. /// </remarks> <short> Saves the new shortcut \a cut for standard accel \a id.</short> public static void SaveShortcut(KStandardShortcut.StandardShortcut id, KShortcut newShortcut) { staticInterceptor.Invoke("saveShortcut$#", "saveShortcut(KStandardShortcut::StandardShortcut, const KShortcut&)", typeof(void), typeof(KStandardShortcut.StandardShortcut), id, typeof(KShortcut), newShortcut); }
/// <remarks> /// Set the shortcut for this action. /// This is preferred over QAction.SetShortcut(), as it allows for multiple shortcuts /// per action. /// \param shortcut shortcut(s) to use for this action in its specified shortcutContext() /// \param type type of shortcut to be set: active shortcut, /// default shortcut, or both (the default). /// </remarks> <short> Set the shortcut for this action.</short> public void SetShortcut(KShortcut shortcut, uint type) { interceptor.Invoke("setShortcut#$", "setShortcut(const KShortcut&, KAction::ShortcutTypes)", typeof(void), typeof(KShortcut), shortcut, typeof(uint), type); }
/// <remarks> /// Assign a global shortcut for this action. Global shortcuts /// allow an action to respond to key shortcuts independently of the focused window, /// i.e. the action will trigger if the keys were pressed no matter where in the X session. /// The action must have a per main component unique /// objectName() to enable cross-application bookeeping. If the objectName() is empty this method will /// do nothing, otherwise the isGlobalShortcutEnabled() property will be set to true and the /// shortcut will be enabled. /// It is mandatory that the objectName() doesn't change once isGlobalshortcutEnabled() /// has become true. /// <b>Note:<> KActionCollection.Insert(name, action) will set action's objectName to name so you often /// don't have to set an objectName explicitly. /// When an action, identified by main component name and objectName(), is assigned /// a global shortcut for the first time on a KDE installation the assignment will /// be saved. The shortcut will then be restored every time setGlobalShortcut() is /// called with <code>loading</code> == Autoloading. /// If you actually want to change the global shortcut you have to set /// <code>loading</code> to NoAutoloading. The new shortcut will be automatically saved again. /// \param shortcut global shortcut(s) to assign. Will be ignored unless <pre>loading</pre> is set to NoAutoloading or this is the first time ever you call this method (see above). /// \param type the type of shortcut to be set, whether the active shortcut, the default shortcut, /// or both (the default). /// \param loading if Autoloading, assign the global shortcut this action has previously had if any. /// That way user preferences and changes made to avoid clashes will be conserved. /// if NoAutoloading the given shortcut will be assigned without looking up old values. /// You should only do this if the user wants to change the shortcut or if you have /// another very good reason. Key combinations that clash with other shortcuts will be /// dropped. /// <b>Note:<> the default shortcut will never be influenced by autoloading - it will be set as given. /// \sa globalShortcut() /// </remarks> <short> Assign a global shortcut for this action.</short> public void SetGlobalShortcut(KShortcut shortcut, uint type, KAction.GlobalShortcutLoading loading) { interceptor.Invoke("setGlobalShortcut#$$", "setGlobalShortcut(const KShortcut&, KAction::ShortcutTypes, KAction::GlobalShortcutLoading)", typeof(void), typeof(KShortcut), shortcut, typeof(uint), type, typeof(KAction.GlobalShortcutLoading), loading); }