/ScintillaNET/Scintilla.INativeScintilla.cs

Large files files are truncated, but you can click here to view the full file

#region Using Directives

using System;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

#endregion Using Directives


namespace ScintillaNET
{
    public partial class Scintilla
    {
        #region Fields

        private static readonly object _autoCSelectionEventKey = new object();
        private static readonly object _callTipClickEventKeyNative = new object();
        private static readonly object _charAddedEventKeyNative = new object();
        private static readonly object _doubleClickEventKey = new object();
        private static readonly object _dwellEndEventKeyNative = new object();
        private static readonly object _dwellStartEventKeyNative = new object();
        private static readonly object _hotspotClickEventKey = new object();
        private static readonly object _hotspotDoubleClickEventKey = new object();
        private static readonly object _indicatorClickKeyNative = new object();
        private static readonly object _indicatorReleaseKeyNative = new object();
        private static readonly object _keyEventKey = new object();
        private static readonly object _macroRecordEventKeyNative = new object();
        private static readonly object _marginClickEventKeyNative = new object();
        private static readonly object _modifiedEventKey = new object();
        private static readonly object _modifyAttemptROEventKey = new object();
        private static readonly object _needShownEventKey = new object();
        private static readonly object _paintedEventKey = new object();
        private static readonly object _savePointLeftEventKeyNative = new object();
        private static readonly object _savePointReachedEventKeyNative = new object();
        private static readonly object _styleNeededEventKeyNative = new object();
        private static readonly object _updateUIEventKey = new object();
        private static readonly object _uriDroppedEventKeyNative = new object();
        private static readonly object _userListSelectionEventKeyNative = new object();
        private static readonly object _zoomEventKey = new object();
        private LastSelection lastSelection = new LastSelection();
        private const uint TEXT_MODIFIED_FLAGS = Constants.SC_MOD_BEFOREDELETE | Constants.SC_MOD_BEFOREINSERT |
                                                    Constants.SC_MOD_DELETETEXT | Constants.SC_MOD_INSERTTEXT;

        #endregion Fields


        #region Methods

        internal void FireAutoCSelection(NativeScintillaEventArgs ea)
        {
            if (Events[_autoCSelectionEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_autoCSelectionEventKey])(this, ea);

            OnAutoCompleteAccepted(new AutoCompleteAcceptedEventArgs(ea.SCNotification, _encoding));
        }


        internal void FireCallTipClick(NativeScintillaEventArgs ea)
        {
            if(Events[_callTipClickEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_callTipClickEventKeyNative])(this, ea);

            FireCallTipClick(ea.SCNotification.position);
        }


        internal void FireCharAdded(NativeScintillaEventArgs ea)
        {
            
            if(Events[_charAddedEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_charAddedEventKeyNative])(this, ea);

            OnCharAdded(new CharAddedEventArgs(ea.SCNotification.ch));
        }


        internal void FireDoubleClick(NativeScintillaEventArgs ea)
        {
            if(Events[_doubleClickEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_doubleClickEventKey])(this, ea);
        }


        internal void FireDwellEnd(NativeScintillaEventArgs ea)
        {
            if(Events[_dwellEndEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_dwellEndEventKeyNative])(this, ea);

            OnDwellEnd(new ScintillaMouseEventArgs(ea.SCNotification.x, ea.SCNotification.y, ea.SCNotification.position));
        }


        internal void FireDwellStart(NativeScintillaEventArgs ea)
        {
            if(Events[_dwellStartEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_dwellStartEventKeyNative])(this, ea);

            OnDwellStart(new ScintillaMouseEventArgs(ea.SCNotification.x, ea.SCNotification.y, ea.SCNotification.position));
        }


        internal void FireIndicatorClick(NativeScintillaEventArgs ea)
        {
            if (Events[_indicatorClickKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_indicatorClickKeyNative])(this, ea);

            OnIndicatorClick(new ScintillaMouseEventArgs(ea.SCNotification.x, ea.SCNotification.y, ea.SCNotification.position));
        }


        internal void FireIndicatorRelease(NativeScintillaEventArgs ea)
        {
            if (Events[_indicatorReleaseKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_indicatorReleaseKeyNative])(this, ea);
        }


        internal void FireKey(NativeScintillaEventArgs ea)
        {
            if(Events[_keyEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_keyEventKey])(this, ea);
        }


        internal void FireMacroRecord(NativeScintillaEventArgs ea)
        {
            if(Events[_macroRecordEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_macroRecordEventKeyNative])(this, ea);

            OnMacroRecord(new MacroRecordEventArgs(ea));
        }


        internal void FireMarginClick(NativeScintillaEventArgs ea)
        {
            if(Events[_marginClickEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_marginClickEventKeyNative])(this, ea);

            FireMarginClick(ea.SCNotification);
        }


        private void FireModified(NativeScintillaEventArgs ea)
        {
            //	First we fire the INativeScintilla Modified event.
            if(Events[_modifiedEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_modifiedEventKey])(this, ea);

            //	Now we use raw information from the Modified event to construct
            //	some more user friendly Events to fire.
            SCNotification scn	= ea.SCNotification;
            int modType			= scn.modificationType;

            if((modType & TEXT_MODIFIED_FLAGS) > 0)
            {
                TextModifiedEventArgs mea = new TextModifiedEventArgs
                    (
                    modType,
                    (modType & Constants.SC_PERFORMED_USER) != 0,
                    scn.line,
                    scn.position,
                    scn.length,
                    scn.linesAdded,
                    Utilities.IntPtrToString(_encoding, scn.text, scn.length)
                    );

                //	These messages all get fired seperately hence the if else ifs
                if ((modType & Constants.SC_MOD_BEFOREDELETE) > 0)
                {
                    OnBeforeTextDelete(mea);
                }
                else if ((modType & Constants.SC_MOD_BEFOREINSERT) > 0)
                {
                    OnBeforeTextInsert(mea);
                }
                else if ((modType & Constants.SC_MOD_DELETETEXT) > 0)
                {
                    OnTextDeleted(mea);
                }
                else if ((modType & Constants.SC_MOD_INSERTTEXT) > 0)
                {
                    OnTextInserted(mea);
                }
            }
            else if((modType & Constants.SC_MOD_CHANGEFOLD) > 0)
            {
                FoldChangedEventArgs fea = new FoldChangedEventArgs(scn.line, scn.foldLevelNow, scn.foldLevelPrev, scn.modificationType);
                OnFoldChanged(fea);
            }
            else if((modType & Constants.SC_MOD_CHANGESTYLE) > 0)
            {
                StyleChangedEventArgs sea = new StyleChangedEventArgs(scn.position, scn.length, scn.modificationType);
                OnStyleChanged(sea);
            }
            else if((modType & Constants.SC_MOD_CHANGEMARKER) > 0)
            {
                MarkerChangedEventArgs mea = new MarkerChangedEventArgs(scn.line, scn.modificationType);
                OnMarkerChanged(mea);
            }

            OnDocumentChange(ea);
        }


        internal void FireModifyAttemptRO(NativeScintillaEventArgs ea)
        {
            if(Events[_modifyAttemptROEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_modifyAttemptROEventKey])(this, ea);

            OnReadOnlyModifyAttempt(EventArgs.Empty);
        }


        internal void FireNeedShown(NativeScintillaEventArgs ea)
        {
            if(Events[_needShownEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_needShownEventKey])(this, ea);

            //	Again, this shoold look familiar...
            int pos			= ea.SCNotification.position;
            int firstLine	= _ns.LineFromPosition(pos);
            int lastLine	= _ns.LineFromPosition(pos + ea.SCNotification.length - 1);
            OnLinesNeedShown(new LinesNeedShownEventArgs(firstLine, lastLine));
        }


        internal void FirePainted(NativeScintillaEventArgs ea)
        {
            if(Events[_paintedEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_paintedEventKey])(this, ea);
        }


        internal void FireSavePointLeft(NativeScintillaEventArgs ea)
        {
            if(Events[_savePointLeftEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_savePointLeftEventKeyNative])(this, ea);

            // Update the local property (and if necessary raise the changed event)
            Modified = true;
        }


        internal void FireSavePointReached(NativeScintillaEventArgs ea)
        {
            if(Events[_savePointReachedEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_savePointReachedEventKeyNative])(this, ea);

            // Update the local property (and if necessary raise the changed event)
            Modified = false;
        }


        internal void FireStyleNeeded(NativeScintillaEventArgs ea)
        {
            if(Events[_styleNeededEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_styleNeededEventKeyNative])(this, ea);

            //	TODO: When this event fires it fires A LOT over and over again if
            //	you don't actually style the document. Additionally I'm making 2
            //	more calls to Scintilla to get the Start position of the style
            //	range. I need to come up with a good way to supress this logic
            //	unless the client app is actually interested in it. 

            //	Now that we've fired the Native event we do the same for the
            //	SourceEdit's StyleNeeded event. This code should look VERY familliar
            //	to anyone who's read the Scintilla Documentation
            int startPos	= _ns.GetEndStyled();
            int lineNumber	= _ns.LineFromPosition(startPos);
            startPos		= _ns.PositionFromLine(lineNumber);

            StyleNeededEventArgs snea = new StyleNeededEventArgs(new Range(startPos, ea.SCNotification.position, this));
            OnStyleNeeded(snea);
        }


        internal void FireUpdateUI(NativeScintillaEventArgs ea)
        {
            if (Events[_updateUIEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_updateUIEventKey])(this, ea);

            //	The SCN_UPDATEUI Notification message is sent whenever text, style or
            //	selection range changes. This means that the SelectionChangeEvent could
            //	potentially fire without the selection actually having changed. However
            //	I feel that it's important enough that SelectionChanged gets its own
            //	event.

            if (lastSelection.Start != this.Selection.Start
            || lastSelection.End != this.Selection.End
            || lastSelection.Length != this.Selection.Length)
            {
                OnSelectionChanged(EventArgs.Empty);
            }

            //I think the selection changed event should only be fired if the selection differs
            //from the selection values in the previous call to this function			
            //so here we take note of what the selection was last time 
            lastSelection.Start = this.Selection.Start;
            lastSelection.End = this.Selection.End;
            lastSelection.Length = this.Selection.Length;
        }


        internal void FireUriDropped(NativeScintillaEventArgs ea)
        {
            if(Events[_uriDroppedEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_uriDroppedEventKeyNative])(this, ea);
        }


        internal void FireUserListSelection(NativeScintillaEventArgs ea)
        {
            if(Events[_userListSelectionEventKeyNative] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_userListSelectionEventKeyNative])(this, ea);
        }


        internal void FireZoom(NativeScintillaEventArgs ea)
        {
            if(Events[_zoomEventKey] != null)
                ((EventHandler<NativeScintillaEventArgs>)Events[_zoomEventKey])(this, ea);

            OnZoomChanged(EventArgs.Empty);
        }


        void INativeScintilla.AddRefDocument(IntPtr pDoc)
        {
            _ns.SendMessageDirect(Constants.SCI_ADDREFDOCUMENT, IntPtr.Zero, pDoc);
        }


        unsafe void INativeScintilla.AddStyledText(int length, byte[] s)
        {
            fixed (byte* bp = s)
                _ns.SendMessageDirect(Constants.SCI_ADDSTYLEDTEXT, (IntPtr)length, (IntPtr)bp);
        }


        void INativeScintilla.AddText(int length, string s)
        {
            _ns.SendMessageDirect(Constants.SCI_ADDTEXT, length, s);
        }


        void INativeScintilla.Allocate(int bytes)
        {
            _ns.SendMessageDirect(Constants.SCI_ALLOCATE, bytes, 0);
        }


        void INativeScintilla.AppendText(int length, string s)
        {
            _ns.SendMessageDirect(Constants.SCI_APPENDTEXT, length, s);
        }


        void INativeScintilla.AssignCmdKey(int keyDefinition, int sciCommand)
        {
            _ns.SendMessageDirect(Constants.SCI_ASSIGNCMDKEY, keyDefinition, sciCommand);
        }


        bool INativeScintilla.AutoCActive()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCACTIVE, 0, 0) != 0;
        }


        void INativeScintilla.AutoCCancel()
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCCANCEL, 0, 0);
        }


        void INativeScintilla.AutoCComplete()
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCCOMPLETE, 0, 0);
        }


        bool INativeScintilla.AutoCGetAutoHide()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETAUTOHIDE, 0, 0) != 0;
        }


        bool INativeScintilla.AutoCGetCancelAtStart()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETCANCELATSTART, 0, 0) != 0;
        }


        bool INativeScintilla.AutoCGetChooseSingle()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETCHOOSESINGLE, 0, 0) != 0;
        }


        int INativeScintilla.AutoCGetCurrent()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETCURRENT, 0, 0);
        }


        bool INativeScintilla.AutoCGetDropRestOfWord()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETDROPRESTOFWORD, 0, 0) != 0;
        }


        bool INativeScintilla.AutoCGetIgnoreCase()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETIGNORECASE, 0, 0) != 0;
        }


        int INativeScintilla.AutoCGetMaxHeight()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETMAXHEIGHT, 0, 0);
        }


        int INativeScintilla.AutoCGetMaxWidth()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCGETMAXWIDTH, 0, 0);
        }


        char INativeScintilla.AutoCGetSeparator()
        {
            return (char)_ns.SendMessageDirect(Constants.SCI_AUTOCGETSEPARATOR, 0, 0);
        }


        char INativeScintilla.AutoCGetTypeSeparator()
        {
            return (char)_ns.SendMessageDirect(Constants.SCI_AUTOCGETTYPESEPARATOR, 0, 0);
        }


        int INativeScintilla.AutoCPosStart()
        {
            return _ns.SendMessageDirect(Constants.SCI_AUTOCPOSSTART, 0, 0);
        }


        void INativeScintilla.AutoCSelect(string select)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSELECT, VOID.NULL, select);
        }


        void INativeScintilla.AutoCSetAutoHide(bool autoHide)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETAUTOHIDE, autoHide, 0);
        }


        void INativeScintilla.AutoCSetCancelAtStart(bool cancel)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETCANCELATSTART, cancel, 0);
        }


        void INativeScintilla.AutoCSetChooseSingle(bool chooseSingle)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETCHOOSESINGLE, chooseSingle, 0);
        }


        void INativeScintilla.AutoCSetDropRestOfWord(bool dropRestOfWord)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETDROPRESTOFWORD, dropRestOfWord, 0);
        }


        void INativeScintilla.AutoCSetFillUps(string chars)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETFILLUPS, VOID.NULL, chars);
        }


        void INativeScintilla.AutoCSetIgnoreCase(bool ignoreCase)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETIGNORECASE, ignoreCase, 0);
        }


        void INativeScintilla.AutoCSetMaxHeight(int rowCount)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETMAXHEIGHT, rowCount, 0);
        }


        void INativeScintilla.AutoCSetMaxWidth(int characterCount)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETMAXWIDTH, characterCount, 0);
        }


        void INativeScintilla.AutoCSetSeparator(char separator)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETSEPARATOR, separator, 0);
        }


        void INativeScintilla.AutoCSetTypeSeparator(char separatorCharacter)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSETTYPESEPARATOR, (int)separatorCharacter, 0);
        }


        void INativeScintilla.AutoCShow(int lenEntered, string list)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSHOW, lenEntered, list);
        }


        void INativeScintilla.AutoCStops(string chars)
        {
            _ns.SendMessageDirect(Constants.SCI_AUTOCSTOPS, VOID.NULL, chars);
        }


        void INativeScintilla.BackTab()
        {
            _ns.SendMessageDirect(Constants.SCI_BACKTAB, 0, 0);
        }


        void INativeScintilla.BeginUndoAction()
        {
            _ns.SendMessageDirect(Constants.SCI_BEGINUNDOACTION, 0, 0);
        }


        void INativeScintilla.BraceBadLight(int pos1)
        {
            _ns.SendMessageDirect(Constants.SCI_BRACEBADLIGHT, pos1, 0);
        }


        void INativeScintilla.BraceHighlight(int pos1, int pos2)
        {
            _ns.SendMessageDirect(Constants.SCI_BRACEHIGHLIGHT, pos1, pos2);
        }


        int INativeScintilla.BraceMatch(int pos, int maxReStyle)
        {
            return _ns.SendMessageDirect(Constants.SCI_BRACEMATCH, pos, maxReStyle);
        }


        bool INativeScintilla.CallTipActive()
        {
            return _ns.SendMessageDirect(Constants.SCI_CALLTIPACTIVE, 0, 0) != 0;
        }


        void INativeScintilla.CallTipCancel()
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPCANCEL, 0, 0);
        }


        int INativeScintilla.CallTipGetPosStart()
        {
            return _ns.SendMessageDirect(Constants.SCI_CALLTIPPOSSTART, 0, 0);
        }


        void INativeScintilla.CallTipSetBack(int colour)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPSETBACK, colour, 0);
        }


        void INativeScintilla.CallTipSetFore(int colour)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPSETFORE, colour, 0);
        }


        void INativeScintilla.CallTipSetForeHlt(int colour)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPSETFOREHLT, colour, 0);
        }


        void INativeScintilla.CallTipSetHlt(int hlStart, int hlEnd)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPSETHLT, hlStart, hlEnd);
        }


        void INativeScintilla.CallTipShow(int posStart, string definition)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPSHOW, posStart, definition);
        }


        void INativeScintilla.CallTipUseStyle(int tabsize)
        {
            _ns.SendMessageDirect(Constants.SCI_CALLTIPUSESTYLE, tabsize, 0);
        }


        void INativeScintilla.Cancel()
        {
            _ns.SendMessageDirect(Constants.SCI_CANCEL, 0, 0);
        }


        bool INativeScintilla.CanRedo()
        {
            return _ns.SendMessageDirect(Constants.SCI_CANREDO, 0, 0) != 0;
        }


        bool INativeScintilla.CanUndo()
        {
            return _ns.SendMessageDirect(Constants.SCI_CANUNDO, 0, 0) != 0;
        }


        void INativeScintilla.CharLeft()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARLEFT, 0, 0);
        }


        void INativeScintilla.CharLeftExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARLEFTEXTEND, 0, 0);
        }


        void INativeScintilla.CharLeftRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARLEFTRECTEXTEND, 0, 0);
        }


        void INativeScintilla.CharRight()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARRIGHT, 0, 0);
        }


        void INativeScintilla.CharRightExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARRIGHTEXTEND, 0, 0);
        }


        void INativeScintilla.CharRightRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_CHARRIGHTRECTEXTEND, 0, 0);
        }


        void INativeScintilla.ChooseCaretX()
        {
            _ns.SendMessageDirect(Constants.SCI_CHOOSECARETX, 0, 0);
        }


        void INativeScintilla.Clear()
        {
            _ns.SendMessageDirect(Constants.SCI_CLEAR, 0, 0);
        }


        void INativeScintilla.ClearAll()
        {
            _ns.SendMessageDirect(Constants.SCI_CLEARALL, 0, 0);
        }


        void INativeScintilla.ClearAllCmdKeys()
        {
            _ns.SendMessageDirect(Constants.SCI_CLEARALLCMDKEYS, 0, 0);
        }


        void INativeScintilla.ClearCmdKey(int keyDefinition)
        {
            _ns.SendMessageDirect(Constants.SCI_CLEARCMDKEY, keyDefinition, 0);
        }


        void INativeScintilla.ClearDocumentStyle()
        {
            _ns.SendMessageDirect(Constants.SCI_CLEARDOCUMENTSTYLE, 0, 0);
        }


        void INativeScintilla.ClearRegisteredImages()
        {
            _ns.SendMessageDirect(Constants.SCI_CLEARREGISTEREDIMAGES, 0, 0);
        }


        void INativeScintilla.Colourise(int start, int end)
        {
            _ns.SendMessageDirect(Constants.SCI_COLOURISE, start, end);
        }


        void INativeScintilla.ConvertEols(int eolMode)
        {
            _ns.SendMessageDirect(Constants.SCI_CONVERTEOLS, eolMode, 0);
        }


        IntPtr INativeScintilla.CreateDocument()
        {
            return (IntPtr)_ns.SendMessageDirect(Constants.SCI_CREATEDOCUMENT, 0, 0);
        }


        void INativeScintilla.DeleteBack()
        {
            _ns.SendMessageDirect(Constants.SCI_DELETEBACK, 0, 0);
        }


        void INativeScintilla.DeleteBackNotLine()
        {
            _ns.SendMessageDirect(Constants.SCI_DELETEBACKNOTLINE, 0, 0);
        }


        void INativeScintilla.DelLineLeft()
        {
            _ns.SendMessageDirect(Constants.SCI_DELLINELEFT, 0, 0);
        }


        void INativeScintilla.DelLineRight()
        {
            _ns.SendMessageDirect(Constants.SCI_DELLINERIGHT, 0, 0);
        }


        void INativeScintilla.DelWordLeft()
        {
            _ns.SendMessageDirect(Constants.SCI_DELWORDLEFT, 0, 0);
        }


        void INativeScintilla.DelWordRight()
        {
            _ns.SendMessageDirect(Constants.SCI_DELWORDRIGHT, 0, 0);
        }


        int INativeScintilla.DocLineFromVisible(int displayLine)
        {
            return _ns.SendMessageDirect(Constants.SCI_DOCLINEFROMVISIBLE, displayLine, 0);
        }


        void INativeScintilla.DocumentEnd()
        {
            _ns.SendMessageDirect(Constants.SCI_DOCUMENTEND, 0, 0);
        }


        void INativeScintilla.DocumentEndExtend()
        {
            _ns.SendMessageDirect(2319, 0, 0);
        }


        void INativeScintilla.DocumentStart()
        {
            _ns.SendMessageDirect(Constants.SCI_DOCUMENTSTART, 0, 0);
        }


        void INativeScintilla.DocumentStartExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_DOCUMENTSTARTEXTEND, 0, 0);
        }


        void INativeScintilla.EditToggleOvertype()
        {
            _ns.SendMessageDirect(Constants.SCI_EDITTOGGLEOVERTYPE, 0, 0);
        }


        void INativeScintilla.EmptyUndoBuffer()
        {
            _ns.SendMessageDirect(Constants.SCI_EMPTYUNDOBUFFER, 0, 0);
        }


        int INativeScintilla.EncodeFromUtf8(string utf8, out string encoded)
        {
            throw new NotSupportedException();
        }


        void INativeScintilla.EndUndoAction()
        {
            _ns.SendMessageDirect(Constants.SCI_ENDUNDOACTION, 0, 0);
        }


        void INativeScintilla.EnsureVisible(int line)
        {
            _ns.SendMessageDirect(Constants.SCI_ENSUREVISIBLE, line, 0);
        }


        void INativeScintilla.EnsureVisibleEnforcePolicy(int line)
        {
            _ns.SendMessageDirect(Constants.SCI_ENSUREVISIBLEENFORCEPOLICY, line, 0);
        }


        int INativeScintilla.FindColumn(int line, int column)
        {
            return _ns.SendMessageDirect(Constants.SCI_FINDCOLUMN, line, column);
        }


        unsafe int INativeScintilla.FindText(int searchFlags, ref TextToFind ttf)
        {
            //	{wi17869} 2008-08-15 Chris Rickard
            //	searchFlags weren't getting sent to SendMessageDirect. IntPtr.Zero was.
            //	This has been fixed
            fixed (TextToFind* ttfp = &ttf)
                return (int)_ns.SendMessageDirect(Constants.SCI_FINDTEXT, (IntPtr)searchFlags, (IntPtr)ttfp);
        }


        unsafe int INativeScintilla.FormatRange(bool bDraw, ref RangeToFormat pfr)
        {
            fixed (RangeToFormat* rtfp = &pfr)
                return (int)_ns.SendMessageDirect(Constants.SCI_FORMATRANGE, (IntPtr)(bDraw ? 1 : 0), (IntPtr)rtfp);
        }


        void INativeScintilla.FormFeed()
        {
            _ns.SendMessageDirect(Constants.SCI_FORMFEED, 0, 0);
        }


        int INativeScintilla.GetAnchor()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETANCHOR, 0, 0);
        }


        bool INativeScintilla.GetBackSpaceUnIndents()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETBACKSPACEUNINDENTS, 0, 0) != 0;
        }


        bool INativeScintilla.GetBufferedDraw()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETBUFFEREDDRAW, 0, 0) != 0;
        }


        int INativeScintilla.GetCaretFore()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETFORE, 0, 0);
        }


        int INativeScintilla.GetCaretLineBack()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETLINEBACK, 0, 0);
        }


        int INativeScintilla.GetCaretLineBackAlpha()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETLINEBACKALPHA, 0, 0);
        }


        bool INativeScintilla.GetCaretLineVisible()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETLINEVISIBLE, 0, 0) != 0;
        }


        int INativeScintilla.GetCaretPeriod()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETPERIOD, 0, 0);
        }


        bool INativeScintilla.GetCaretSticky()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETSTICKY, 0, 0) != 0;
        }


        int INativeScintilla.GetCaretStyle()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETSTYLE, 0, 0);
        }


        int INativeScintilla.GetCaretWidth()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCARETWIDTH, 0, 0);
        }


        char INativeScintilla.GetCharAt(int position)
        {
            return (char)_ns.SendMessageDirect(Constants.SCI_GETCHARAT, position, 0);
        }


        int INativeScintilla.GetCodePage()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCODEPAGE, 0, 0);
        }


        int INativeScintilla.GetColumn(int position)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCOLUMN, position, 0);
        }


        int INativeScintilla.GetControlCharSymbol()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCONTROLCHARSYMBOL, 0, 0);
        }


        int INativeScintilla.GetCurrentPos()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCURRENTPOS, 0, 0);
        }


        int INativeScintilla.GetCursor()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETCURSOR, 0, 0);
        }


        IntPtr INativeScintilla.GetDocPointer()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETDOCPOINTER, IntPtr.Zero, IntPtr.Zero);
        }


        int INativeScintilla.GetEdgeColour()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETEDGECOLOUR, 0, 0);
        }


        int INativeScintilla.GetEdgeColumn()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETEDGECOLUMN, 0, 0);
        }


        int INativeScintilla.GetEdgeMode()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETEDGEMODE, 0, 0);
        }


        bool INativeScintilla.GetEndAtLastLine()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETENDATLASTLINE, 0, 0) != 0;
        }


        int INativeScintilla.GetEndStyled()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETENDSTYLED, 0, 0);
        }


        int INativeScintilla.GetEolMode()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETEOLMODE, 0, 0);
        }


        int INativeScintilla.GetFirstVisibleLine()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETFIRSTVISIBLELINE, 0, 0);
        }


        bool INativeScintilla.GetFocus()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETFOCUS, 0, 0) != 0;
        }


        bool INativeScintilla.GetFoldExpanded(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETFOLDEXPANDED, line, 0) != 0;
        }


        uint INativeScintilla.GetFoldLevel(int line)
        {
            return (uint)_ns.SendMessageDirect(Constants.SCI_GETFOLDLEVEL, line, 0);
        }


        int INativeScintilla.GetFoldParent(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETFOLDPARENT, line, 0);
        }


        int INativeScintilla.GetHighlightGuide()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHIGHLIGHTGUIDE, 0, 0);
        }


        int INativeScintilla.GetHotspotActiveBack()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHOTSPOTACTIVEBACK, 0, 0);
        }


        int INativeScintilla.GetHotspotActiveFore()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHOTSPOTACTIVEFORE, 0, 0);
        }


        bool INativeScintilla.GetHotspotActiveUnderline()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHOTSPOTACTIVEUNDERLINE, 0, 0) != 0;
        }


        bool INativeScintilla.GetHotspotSingleLine()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHOTSPOTSINGLELINE, 0, 0) != 0;
        }


        bool INativeScintilla.GetHScrollBar()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETHSCROLLBAR, 0, 0) != 0;
        }


        int INativeScintilla.GetIndent()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETINDENT, 0, 0);
        }


        bool INativeScintilla.GetIndentationGuides()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETINDENTATIONGUIDES, 0, 0) != 0;
        }


        int INativeScintilla.GetIndicatorCurrent()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETINDICATORCURRENT, 0, 0);
        }


        int INativeScintilla.GetIndicatorValue()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETINDICATORVALUE, 0, 0);
        }


        int INativeScintilla.GetLastChild(int line, int level)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLASTCHILD, line, level);
        }


        int INativeScintilla.GetLength()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLENGTH, 0, 0);
        }


        int INativeScintilla.GetLexer()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLEXER, 0, 0);
        }


        int INativeScintilla.GetLine(int line, out string text)
        {
            int length = _ns.SendMessageDirect(Constants.SCI_GETLINE, line, 0);
            if (length == 0)
            {
                text = string.Empty;
                return 0;
            }

            return _ns.SendMessageDirect(Constants.SCI_GETLINE, (IntPtr)line, out text, length);
        }


        int INativeScintilla.GetLineEndPosition(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINEENDPOSITION, line, 0);
        }


        int INativeScintilla.GetLineIndentation(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINEINDENTATION, line, 0);
        }


        int INativeScintilla.GetLineIndentPosition(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINEINDENTPOSITION, line, 0);
        }


        int INativeScintilla.GetLineSelEndPosition(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINESELENDPOSITION, line, 0);
        }


        int INativeScintilla.GetLineSelStartPosition(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINESELSTARTPOSITION, line, 0);
        }


        int INativeScintilla.GetLineState(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINESTATE, line, 0);
        }


        bool INativeScintilla.GetLineVisible(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETLINEVISIBLE, line, 0) != 0;
        }


        int INativeScintilla.GetMarginLeft()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINLEFT, 0, 0);
        }


        int INativeScintilla.GetMarginMaskN(int margin)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINMASKN, margin, 0);
        }


        int INativeScintilla.GetMarginRight()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINRIGHT, 0, 0);
        }


        bool INativeScintilla.GetMarginSensitiveN(int margin)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINSENSITIVEN, margin, 0) != 0;
        }


        int INativeScintilla.GetMarginTypeN(int margin)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINTYPEN, margin, 0);
        }


        int INativeScintilla.GetMarginWidthN(int margin)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMARGINWIDTHN, margin, 0);
        }


        int INativeScintilla.GetMaxLineState()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMAXLINESTATE, 0, 0);
        }


        int INativeScintilla.GetModEventMask()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMODEVENTMASK, 0, 0);
        }


        bool INativeScintilla.GetModify()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMODIFY, 0, 0) != 0;
        }


        bool INativeScintilla.GetMouseDownCaptures()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMOUSEDOWNCAPTURES, 0, 0) != 0;
        }


        int INativeScintilla.GetMouseDwellTime()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETMOUSEDWELLTIME, 0, 0);
        }


        bool INativeScintilla.GetOvertype()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETOVERTYPE, 0, 0) != 0;
        }


        int INativeScintilla.GetPrintColourMode()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETPRINTCOLOURMODE, 0, 0);
        }


        int INativeScintilla.GetPrintMagnification()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETPRINTMAGNIFICATION, 0, 0);
        }


        int INativeScintilla.GetPrintWrapMode()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETPRINTWRAPMODE, 0, 0);
        }


        void INativeScintilla.GetProperty(string key, out string value)
        {
            _ns.SendMessageDirect(Constants.SCI_GETPROPERTY, key, out value);
        }


        void INativeScintilla.GetPropertyExpanded(string key, out string value)
        {
            _ns.SendMessageDirect(Constants.SCI_GETPROPERTYEXPANDED, key, out value);
        }


        int INativeScintilla.GetPropertyInt(string key, int @default)
        {
            return _ns.SendMessageDirect(Constants.SCI_GETPROPERTYINT, key, @default);
        }


        bool INativeScintilla.GetReadOnly()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETREADONLY, 0, 0) != 0;
        }


        int INativeScintilla.GetScrollWidth()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSCROLLWIDTH, 0, 0);
        }


        int INativeScintilla.GetSearchFlags()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSEARCHFLAGS, 0, 0);
        }


        int INativeScintilla.GetSelectionEnd()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSELECTIONEND, 0, 0);
        }


        int INativeScintilla.GetSelectionMode()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSELECTIONMODE, 0, 0);
        }


        int INativeScintilla.GetSelectionStart()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSELECTIONSTART, 0, 0);
        }


        void INativeScintilla.GetSelText(out string text)
        {
            int length = _ns.GetSelectionEnd() - _ns.GetSelectionStart() + 1;
            _ns.SendMessageDirect(Constants.SCI_GETSELTEXT, IntPtr.Zero, out text, length);
        }


        int INativeScintilla.GetStatus()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSTATUS, 0, 0);
        }


        byte INativeScintilla.GetStyleAt(int position)
        {
            return (byte)_ns.SendMessageDirect(Constants.SCI_GETSTYLEAT, position, 0);
        }


        int INativeScintilla.GetStyleBits()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSTYLEBITS, 0, 0);
        }


        int INativeScintilla.GetStyleBitsNeeded()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETSTYLEBITSNEEDED, 0, 0);
        }


        unsafe void INativeScintilla.GetStyledText(ref TextRange tr)
        {
            fixed (TextRange* trp = &tr)
                _ns.SendMessageDirect(Constants.SCI_GETSTYLEDTEXT, IntPtr.Zero, (IntPtr)trp);
        }


        bool INativeScintilla.GetTabIndents()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTABINDENTS, 0, 0) != 0;
        }


        int INativeScintilla.GetTabWidth()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTABWIDTH, 0, 0);
        }


        int INativeScintilla.GetTargetEnd()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTARGETEND, 0, 0);
        }


        int INativeScintilla.GetTargetStart()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTARGETSTART, 0, 0);
        }


        int INativeScintilla.GetText(int length, out string text)
        {
            return (int)_ns.SendMessageDirect(Constants.SCI_GETTEXT, (IntPtr)length, out text, length);
        }


        unsafe int INativeScintilla.GetTextRange(ref TextRange tr)
        {
            fixed (TextRange* trp = &tr)
                return (int)_ns.SendMessageDirect(Constants.SCI_GETTEXTRANGE, IntPtr.Zero, (IntPtr)trp);
        }


        int INativeScintilla.GetTextLength()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTEXTLENGTH, 0, 0);
        }


        bool INativeScintilla.GetTwoPhaseDraw()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETTWOPHASEDRAW, 0, 0) != 0;
        }


        bool INativeScintilla.GetUndoCollection()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETUNDOCOLLECTION, 0, 0) != 0;
        }


        bool INativeScintilla.GetUsePalette()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETUSEPALETTE, 0, 0) != 0;
        }


        bool INativeScintilla.GetUseTabs()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETUSETABS, 0, 0) != 0;
        }


        bool INativeScintilla.GetViewEol()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETVIEWEOL, 0, 0) != 0;
        }


        int INativeScintilla.GetViewWs()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETVIEWWS, 0, 0);
        }


        bool INativeScintilla.GetVScrollBar()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETVSCROLLBAR, 0, 0) != 0;
        }


        int INativeScintilla.GetXOffset()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETXOFFSET, 0, 0);
        }


        int INativeScintilla.GetZoom()
        {
            return _ns.SendMessageDirect(Constants.SCI_GETZOOM, 0, 0);
        }


        void INativeScintilla.GotoLine(int line)
        {
            _ns.SendMessageDirect(Constants.SCI_GOTOLINE, line, 0);
        }


        void INativeScintilla.GotoPos(int position)
        {
            _ns.SendMessageDirect(Constants.SCI_GOTOPOS, position, 0);
        }


        void INativeScintilla.GrabFocus()
        {
            _ns.SendMessageDirect(Constants.SCI_GRABFOCUS, 0, 0);
        }


        void INativeScintilla.HideLines(int lineStart, int lineEnd)
        {
            _ns.SendMessageDirect(Constants.SCI_HIDELINES, lineStart, lineEnd);
        }


        void INativeScintilla.HideSelection(bool hide)
        {
            _ns.SendMessageDirect(Constants.SCI_HIDESELECTION, hide, 0);
        }


        void INativeScintilla.Home()
        {
            _ns.SendMessageDirect(Constants.SCI_HOME, 0, 0);
        }


        void INativeScintilla.HomeDisplay()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMEDISPLAY, 0, 0);
        }


        void INativeScintilla.HomeDisplayExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMEDISPLAYEXTEND, 0, 0);
        }


        void INativeScintilla.HomeExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMEEXTEND, 0, 0);
        }


        void INativeScintilla.HomeRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMERECTEXTEND, 0, 0);
        }


        void INativeScintilla.HomeWrap()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMEWRAP, 0, 0);
        }


        void INativeScintilla.HomeWrapExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_HOMEWRAPEXTEND, 0, 0);
        }


        uint INativeScintilla.IndicatorAllOnFor(int position)
        {
            return (uint)_ns.SendMessageDirect(Constants.SCI_INDICATORALLONFOR, position, 0);
        }


        void INativeScintilla.IndicatorClearRange(int position, int fillLength)
        {
            _ns.SendMessageDirect(Constants.SCI_INDICATORCLEARRANGE, position, fillLength);
        }


        int INativeScintilla.IndicatorEnd(int indicator, int position)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICATOREND, indicator, position);
        }


        void INativeScintilla.IndicatorFillRange(int position, int fillLength)
        {
            _ns.SendMessageDirect(Constants.SCI_INDICATORFILLRANGE, position, fillLength);
        }


        int INativeScintilla.IndicatorStart(int indicator, int position)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICATORSTART, indicator, position);
        }


        int INativeScintilla.IndicatorValueAt(int indicator, int position)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICATORVALUEAT, indicator, position);
        }


        int INativeScintilla.IndicGetFore(int indicatorNumber)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICGETFORE, indicatorNumber, 0);
        }


        int INativeScintilla.IndicGetStyle(int indicatorNumber)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICGETSTYLE, indicatorNumber, 0);
        }


        bool INativeScintilla.IndicGetUnder(int indicatorNumber)
        {
            return _ns.SendMessageDirect(Constants.SCI_INDICGETUNDER, indicatorNumber, 0) != 0;
        }


        void INativeScintilla.IndicSetFore(int indicatorNumber, int colour)
        {
            _ns.SendMessageDirect(Constants.SCI_INDICSETFORE, indicatorNumber, colour);
        }


        void INativeScintilla.IndicSetStyle(int indicatorNumber, int indicatorStyle)
        {
            _ns.SendMessageDirect(Constants.SCI_INDICSETSTYLE, indicatorNumber, indicatorStyle);
        }


        void INativeScintilla.IndicSetUnder(int indicatorNumber, bool under)
        {
            _ns.SendMessageDirect(Constants.SCI_INDICSETUNDER, indicatorNumber, under);
        }


        void INativeScintilla.InsertText(int pos, string text)
        {
            _ns.SendMessageDirect(Constants.SCI_INSERTTEXT, pos, text);
        }


        void INativeScintilla.LineCopy()
        {
            _ns.SendMessageDirect(Constants.SCI_LINECOPY, 0, 0);
        }


        void INativeScintilla.LineCut()
        {
            _ns.SendMessageDirect(Constants.SCI_LINECUT, 0, 0);
        }


        void INativeScintilla.LineDelete()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEDELETE, 0, 0);
        }


        void INativeScintilla.LineDown()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEDOWN, 0, 0);
        }


        void INativeScintilla.LineDownExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEDOWNEXTEND, 0, 0);
        }


        void INativeScintilla.LineDownRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEDOWNRECTEXTEND, 0, 0);
        }


        void INativeScintilla.LineDuplicate()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEDUPLICATE, 0, 0);
        }


        void INativeScintilla.LineEnd()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEEND, 0, 0);
        }


        void INativeScintilla.LineEndDisplay()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDDISPLAY, 0, 0);
        }


        void INativeScintilla.LineEndDisplayExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDDISPLAYEXTEND, 0, 0);
        }


        void INativeScintilla.LineEndExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDEXTEND, 0, 0);
        }


        void INativeScintilla.LineEndRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDRECTEXTEND, 0, 0);
        }


        void INativeScintilla.LineEndWrap()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDWRAP, 0, 0);
        }


        void INativeScintilla.LineEndWrapExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEENDWRAPEXTEND, 0, 0);
        }


        int INativeScintilla.LineFromPosition(int pos)
        {
            return _ns.SendMessageDirect(Constants.SCI_LINEFROMPOSITION, pos, 0);
        }


        int INativeScintilla.LineLength(int line)
        {
            return _ns.SendMessageDirect(Constants.SCI_LINELENGTH, line, 0);
        }


        void INativeScintilla.LineScroll(int columns, int lines)
        {
            _ns.SendMessageDirect(Constants.SCI_LINESCROLL, columns, lines);
        }


        void INativeScintilla.LineScrollDown()
        {
            _ns.SendMessageDirect(Constants.SCI_LINESCROLLDOWN, 0, 0);
        }


        void INativeScintilla.LineScrollUp()
        {
            _ns.SendMessageDirect(Constants.SCI_LINESCROLLUP, 0, 0);
        }


        int INativeScintilla.LinesOnScreen()
        {
            return _ns.SendMessageDirect(Constants.SCI_LINESONSCREEN, 0, 0);
        }


        void INativeScintilla.LineTranspose()
        {
            _ns.SendMessageDirect(Constants.SCI_LINETRANSPOSE, 0, 0);
        }


        void INativeScintilla.LineUp()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEUP, 0, 0);
        }


        void INativeScintilla.LineUpExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEUPEXTEND, 0, 0);
        }


        void INativeScintilla.LineUpRectExtend()
        {
            _ns.SendMessageDirect(Constants.SCI_LINEUPRECTEXTEND, 0, 0);
        }


        void INativeScintilla.LoadLexerLibrary(string path)
        {
            _ns.SendMessageDirect(Constants.SCI_LOADLEXERLIBRARY, VOID.NULL, path);
        }


        void INativeS…