/// <remarks>
/// Constructor which creates a single-line range from <pre>start</pre>,
/// extending <pre>width</pre> characters along the same line.
/// \param start start position
/// \param width width of this range in columns along the same line
/// </remarks> <short> Constructor which creates a single-line range from \p start, extending \p width characters along the same line.</short>
public Range(KTextEditor.Cursor start, int width)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Range#$", "Range(const KTextEditor::Cursor&, int)", typeof(void), typeof(KTextEditor.Cursor), start, typeof(int), width);
}
public override void SetRange(KTextEditor.Range range)
{
interceptor.Invoke("setRange#", "setRange(const KTextEditor::Range&)", typeof(void), typeof(KTextEditor.Range), range);
}
protected override void RangeChanged(KTextEditor.Cursor cursor, KTextEditor.Range from)
{
interceptor.Invoke("rangeChanged##", "rangeChanged(KTextEditor::Cursor*, const KTextEditor::Range&)", typeof(void), typeof(KTextEditor.Cursor), cursor, typeof(KTextEditor.Range), from);
}
/// <remarks>
/// Deregister a notifier and no longer deliver signals indicating change of state of this range.
/// \param notifier notifier to deregister.
/// </remarks> <short> Deregister a notifier and no longer deliver signals indicating change of state of this range.</short>
public void RemoveNotifier(KTextEditor.SmartRangeNotifier notifier)
{
interceptor.Invoke("removeNotifier#", "removeNotifier(KTextEditor::SmartRangeNotifier*)", typeof(void), typeof(KTextEditor.SmartRangeNotifier), notifier);
}
/// <remarks>
/// Sets the currently active attribute for this range.
/// \param attribute Attribute to assign to this range. If null, simply
/// removes the previous Attribute.
/// </remarks> <short> Sets the currently active attribute for this range.</short>
public void SetAttribute(KTextEditor.Attribute attribute)
{
interceptor.Invoke("setAttribute?", "setAttribute(KSharedPtr<KTextEditor::Attribute>)", typeof(void), typeof(KTextEditor.Attribute), attribute);
}
public override bool ExpandToRange(KTextEditor.Range range)
{
return (bool) interceptor.Invoke("expandToRange#", "expandToRange(const KTextEditor::Range&)", typeof(bool), typeof(KTextEditor.Range), range);
}
/// <remarks>
/// Determine whether \a parent is a parent of this range.
/// \param parent range to check to see if it is a parent of this range.
/// \return \e true if \a parent is in the parent heirachy, otherwise \e false.
/// </remarks> <short> Determine whether \a parent is a parent of this range.</short>
public bool HasParent(KTextEditor.SmartRange parent)
{
return (bool) interceptor.Invoke("hasParent#", "hasParent(KTextEditor::SmartRange*) const", typeof(bool), typeof(KTextEditor.SmartRange), parent);
}
public virtual bool SetSelection(KTextEditor.Cursor position, int length)
{
return (bool) interceptor.Invoke("setSelection#$", "setSelection(const KTextEditor::Cursor&, int)", typeof(bool), typeof(KTextEditor.Cursor), position, typeof(int), length);
}
public virtual void ProcessText(KTextEditor.View view, string text)
{
interceptor.Invoke("processText#$", "processText(KTextEditor::View*, const QString&)", typeof(void), typeof(KTextEditor.View), view, typeof(string), text);
}
public virtual bool SetCursorPosition(KTextEditor.Cursor position)
{
return (bool) interceptor.Invoke("setCursorPosition#", "setCursorPosition(KTextEditor::Cursor)", typeof(bool), typeof(KTextEditor.Cursor), position);
}
public virtual bool SetSelection(KTextEditor.Range range)
{
return (bool) interceptor.Invoke("setSelection#", "setSelection(const KTextEditor::Range&)", typeof(bool), typeof(KTextEditor.Range), range);
}
public virtual QPoint CursorToCoordinate(KTextEditor.Cursor cursor)
{
return (QPoint) interceptor.Invoke("cursorToCoordinate#", "cursorToCoordinate(const KTextEditor::Cursor&) const", typeof(QPoint), typeof(KTextEditor.Cursor), cursor);
}
public virtual bool Exec(KTextEditor.View view, string cmd, StringBuilder msg)
{
return (bool) interceptor.Invoke("exec#$$", "exec(KTextEditor::View*, const QString&, QString&)", typeof(bool), typeof(KTextEditor.View), view, typeof(string), cmd, typeof(StringBuilder), msg);
}
/// <remarks>
/// Constructor which creates a range from <pre>start</pre>, to <pre>endLine</pre>, <pre>endColumn</pre>.
/// \param start start position
/// \param endLine end line
/// \param endColumn end column
/// </remarks> <short> Constructor which creates a range from \p start, to \p endLine, \p endColumn.</short>
public Range(KTextEditor.Cursor start, int endLine, int endColumn)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Range#$$", "Range(const KTextEditor::Cursor&, int, int)", typeof(void), typeof(KTextEditor.Cursor), start, typeof(int), endLine, typeof(int), endColumn);
}
public virtual void NeedTextHint(KTextEditor.Cursor position, StringBuilder text)
{
interceptor.Invoke("needTextHint#$", "needTextHint(const KTextEditor::Cursor&, QString&)", typeof(void), typeof(KTextEditor.Cursor), position, typeof(StringBuilder), text);
}
public virtual KCompletion CompletionObject(KTextEditor.View view, string cmdname)
{
return (KCompletion) interceptor.Invoke("completionObject#$", "completionObject(KTextEditor::View*, const QString&)", typeof(KCompletion), typeof(KTextEditor.View), view, typeof(string), cmdname);
}
/// <remarks>
/// Find the child before <pre>range</pre>, if any.
/// \param range to seach backwards from
/// \return the range before <pre>range</pre> if one exists, otherwise null.
/// </remarks> <short> Find the child before \p range, if any.</short>
public KTextEditor.SmartRange ChildBefore(KTextEditor.SmartRange range)
{
return (KTextEditor.SmartRange) interceptor.Invoke("childBefore#", "childBefore(const KTextEditor::SmartRange*) const", typeof(KTextEditor.SmartRange), typeof(KTextEditor.SmartRange), range);
}
public virtual void CompletionInvoked(KTextEditor.View view, KTextEditor.Range range, KTextEditor.CodeCompletionModel.InvocationType invocationType)
{
interceptor.Invoke("completionInvoked##$", "completionInvoked(KTextEditor::View*, const KTextEditor::Range&, KTextEditor::CodeCompletionModel::InvocationType)", typeof(void), typeof(KTextEditor.View), view, typeof(KTextEditor.Range), range, typeof(KTextEditor.CodeCompletionModel.InvocationType), invocationType);
}
/// <remarks>
/// Finds the first child range which contains position <pre>pos</pre>.
/// \param pos the cursor position to use in searching
/// \return the most shallow range (from and including this range) which
/// contains <pre>pos</pre>
/// </remarks> <short> Finds the first child range which contains position \p pos.</short>
public KTextEditor.SmartRange FirstRangeContaining(KTextEditor.Cursor pos)
{
return (KTextEditor.SmartRange) interceptor.Invoke("firstRangeContaining#", "firstRangeContaining(const KTextEditor::Cursor&) const", typeof(KTextEditor.SmartRange), typeof(KTextEditor.Cursor), pos);
}
public virtual void RemoveDocument(KTextEditor.Document document)
{
interceptor.Invoke("removeDocument#", "removeDocument(KTextEditor::Document*)", typeof(void), typeof(KTextEditor.Document), document);
}
/// <remarks>
/// Finds the most specific range in a heirachy for the given input range
/// (ie. the smallest range which wholly contains the input range)
/// \param input the range to use in searching
/// \return the deepest range which contains <pre>input</pre>
/// </remarks> <short> Finds the most specific range in a heirachy for the given input range (ie.</short>
public KTextEditor.SmartRange MostSpecificRange(KTextEditor.Range input)
{
return (KTextEditor.SmartRange) interceptor.Invoke("mostSpecificRange#", "mostSpecificRange(const KTextEditor::Range&) const", typeof(KTextEditor.SmartRange), typeof(KTextEditor.Range), input);
}
public virtual void RemoveView(KTextEditor.View view)
{
interceptor.Invoke("removeView#", "removeView(KTextEditor::View*)", typeof(void), typeof(KTextEditor.View), view);
}
/// <remarks>
/// Stop delivery of notifications to a SmartRangeWatcher.
/// \param watcher the watcher that no longer wants notifications.
/// </remarks> <short> Stop delivery of notifications to a SmartRangeWatcher.</short>
public void RemoveWatcher(KTextEditor.SmartRangeWatcher watcher)
{
interceptor.Invoke("removeWatcher#", "removeWatcher(KTextEditor::SmartRangeWatcher*)", typeof(void), typeof(KTextEditor.SmartRangeWatcher), watcher);
}
public virtual void SetAnnotationModel(KTextEditor.AnnotationModel model)
{
interceptor.Invoke("setAnnotationModel#", "setAnnotationModel(KTextEditor::AnnotationModel*)", typeof(void), typeof(KTextEditor.AnnotationModel), model);
}
public virtual void SetParentRange(KTextEditor.SmartRange r)
{
interceptor.Invoke("setParentRange#", "setParentRange(KTextEditor::SmartRange*)", typeof(void), typeof(KTextEditor.SmartRange), r);
}
public virtual void ExecuteCompletionItem2(KTextEditor.Document document, KTextEditor.Range word, QModelIndex index)
{
interceptor.Invoke("executeCompletionItem2###", "executeCompletionItem2(KTextEditor::Document*, const KTextEditor::Range&, const QModelIndex&) const", typeof(void), typeof(KTextEditor.Document), document, typeof(KTextEditor.Range), word, typeof(QModelIndex), index);
}
/// <remarks>
/// \internal
/// Constructor for subclasses to utilise. Protected to prevent direct
/// instantiation.
/// <b>Note:<> 3rd party developers: you do not (and should not) need to subclass
/// the Smart classes; instead, use the SmartInterface to create instances.
/// \param start the start cursor to use - ownership is taken
/// \param end the end cursor to use - ownership is taken
/// \param insertBehavior the behavior of this range when an insert happens
/// immediately outside the range.
/// </remarks> <short> \internal </short>
public SmartRange(KTextEditor.SmartCursor start, KTextEditor.SmartCursor end, KTextEditor.SmartRange parent, uint insertBehavior)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("SmartRange###$", "SmartRange(KTextEditor::SmartCursor*, KTextEditor::SmartCursor*, KTextEditor::SmartRange*, KTextEditor::SmartRange::InsertBehaviors)", typeof(void), typeof(KTextEditor.SmartCursor), start, typeof(KTextEditor.SmartCursor), end, typeof(KTextEditor.SmartRange), parent, typeof(uint), insertBehavior);
}
protected virtual bool InsertTemplateTextImplementation(KTextEditor.Cursor insertPosition, string templateString, Dictionary<string, string> initialValues)
{
return (bool) interceptor.Invoke("insertTemplateTextImplementation#$?", "insertTemplateTextImplementation(const KTextEditor::Cursor&, const QString&, const QMap<QString,QString>&)", typeof(bool), typeof(KTextEditor.Cursor), insertPosition, typeof(string), templateString, typeof(Dictionary<string, string>), initialValues);
}
public SmartRange(KTextEditor.SmartCursor start, KTextEditor.SmartCursor end)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("SmartRange##", "SmartRange(KTextEditor::SmartCursor*, KTextEditor::SmartCursor*)", typeof(void), typeof(KTextEditor.SmartCursor), start, typeof(KTextEditor.SmartCursor), end);
}
/// <remarks>
/// Constructor which creates a range from \e start to \e end.
/// If start is after end, they will be swapped.
/// \param start start position
/// \param end end position
/// </remarks> <short> Constructor which creates a range from \e start to \e end.</short>
public Range(KTextEditor.Cursor start, KTextEditor.Cursor end)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("Range##", "Range(const KTextEditor::Cursor&, const KTextEditor::Cursor&)", typeof(void), typeof(KTextEditor.Cursor), start, typeof(KTextEditor.Cursor), end);
}
