/// <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);
}
