Example #1
0
        public void InsertCompletion(object obj, EventArgs args)
        {
            if (widget.BanCompletion)
            {
                return;
            }

            CompletionWindowManager.IsTemplateModes = false;
            ICompletionDataList completionList = new CompletionDataList();

            currentCompletionContext = widget.CreateCodeCompletionContext();

            string writeWord = widget.GetCompletionText(currentCompletionContext, false);
            string fullWord  = widget.GetCompletionText(currentCompletionContext, true);

            CompletionTyp completiontype = (CompletionTyp)widget.GetCompletionTyp();

            if (completiontype == CompletionTyp.includeType)
            {
                completionList = editor.GetCompletionData(writeWord, fullWord);
            }
            else
            {
                completionList = editor.GetCompletionData(writeWord, fullWord, completiontype);               //ParseString(writeWord,fullWord,completiontype);
            }
            CompletionWindowManager.ShowWindow((char)0, completionList, widget, currentCompletionContext, OnCompletionWindowClosed);
            editor.GrabFocus();
        }
Example #2
0
        /// <summary>
        /// Vrati vsetky mozne autokompletion , do zoznamu prida aj slova zo samotneho dokumentu
        /// </summary>
        /// <returns>
        /// Zoznam autoCompletion slov odpovesajuci baseWord a completiontype
        /// </returns>
        public static ICompletionDataList GetCompletionData(this TextEditor editor, string baseWord, string fullWord, CompletionTyp completiontype)
        {
            string codestring = editor.Document.Text;
            string type       = "";
            string parent     = "";

            editor.ParseString(fullWord, out parent, out type);

            Regex regex = new Regex(@"\W", RegexOptions.Compiled);

            codestring = regex.Replace(codestring, " ");

            string[]           list         = codestring.Split(' ');
            CompletionDataList listComplete = new CompletionDataList();

            listComplete.CompletionSelectionMode = CompletionSelectionMode.OwnTextField;

            if (!String.IsNullOrEmpty(type))
            {
                //List<CompletionData> lst = MainClass.CompletedCache.AllCompletionOnlyOne.FindAll(x=>x.Parent == type);
                List <CompletionData> lst = MainClass.CompletedCache.AllCompletionRepeat.FindAll(x => x.Parent == type);
                foreach (CompletionData cd in lst)
                {
                    string expres = cd.Parent + ".on";
                    if (cd.Signature.StartsWith(expres))
                    {
                        //expres = cd.Signature.Replace(cd.Parent+".", cd.DisplayText +" = function ");
                        expres = cd.Signature.Replace(cd.Parent + "." + cd.DisplayText, cd.DisplayText + " = function ");
                        cd.DisplayDescription = expres + "{}";
                        cd.CompletionText     = expres + "{" + Environment.NewLine + "}";
                    }
                }

                if (lst != null)
                {
                    listComplete.AddRange(lst.ToArray());
                }

                if (listComplete != null && listComplete.Count > 0)
                {
                    return(listComplete);
                }
            }

            switch (completiontype)
            {
            case CompletionTyp.allType:
            {
                listComplete.AddRange(MainClass.CompletedCache.AllCompletionOnlyOne);
                break;
            }

            case CompletionTyp.newType:
            {
                listComplete.AddRange(MainClass.CompletedCache.NewCompletion);
                break;
            }

            case CompletionTyp.dotType:
            {
                listComplete.AddRange(MainClass.CompletedCache.DotCompletion);
                break;
            }
            }


            int i = 0;

            foreach (string s in list)
            {
                if (!String.IsNullOrEmpty(s.Trim()))
                {
                    if (s == baseWord)
                    {
                        i++;
                    }

                    if ((listComplete.Find(s) == null) && (s.Length > 2) && ((s != baseWord) || (i == 1)))
                    {
                        CompletionData cd = new CompletionData(s, null, s, s);

                        if (completiontype == CompletionTyp.newType)
                        {
                            if (char.ToUpper(s[0]) == s[0] && !char.IsDigit(s[0]) && !char.IsSymbol(s[0]) && char.IsLetter(s[0]))
                            {
                                CompletionData cdParent = listComplete.Find(cd.DisplayText);
                                if (cdParent == null)
                                {
                                    listComplete.Add(cd);
                                }
                                else
                                {
                                    if (!cdParent.Description.Contains(cd.Description))
                                    {
                                        cdParent.Description = cdParent.Description + Environment.NewLine + cd.Description;
                                    }
                                }
                            }
                        }
                        else
                        {
                            CompletionData cdParent = listComplete.Find(cd.DisplayText);
                            if (cdParent == null)
                            {
                                listComplete.Add(cd);
                            }
                            else
                            {
                                if (!cdParent.Description.Contains(cd.Description))
                                {
                                    cdParent.Description = cdParent.Description + Environment.NewLine + cd.Description;
                                }
                            }
                        }
                    }
                }
            }

            return(listComplete);
        }
Example #3
0
        private CompletionDataList GetCompletionData(CompletionTyp completiontype, bool onlyOne)
        {
            CompletionDataList listComplete = new CompletionDataList();

            if (completiontype == CompletionTyp.includeType)
            {
                listComplete.Add(new CompletionData("lib", null, "lib", "lib://"));
                listComplete.Add(new CompletionData("app", null, "app", "app://"));
                return(listComplete);
            }

            if (MainClass.CompletedCache.ListDataKeywords != null)
            {
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataKeywords)
                {
                    if (cd != null)
                    {
                        CompletionData cdParent = listComplete.Find(cd.DisplayText);

                        if ((cdParent == null) || (!onlyOne))
                        {
                            if (completiontype != CompletionTyp.newType)
                            {
                                cdParent = cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }
                        else
                        {
                            if (!cdParent.Description.Contains(cd.Description))
                            {
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description = cdParent.Description + Environment.NewLine + Environment.NewLine + cd.Description;
                            }
                        }
                    }
                }
            }

            //Types (from doc T:)
            //i = 0;
            if (MainClass.CompletedCache.ListDataTypes != null)
            {
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataTypes)
                {
                    if (cd != null)
                    {
                        CompletionData cdParent = listComplete.Find(cd.DisplayText);
                        if ((cdParent == null) || (!onlyOne))
                        {
                            if (completiontype != CompletionTyp.dotType)
                            {
                                cdParent = cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }
                        else
                        {
                            if (!cdParent.Description.Contains(cd.Description))
                            {
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description = cdParent.Description + Environment.NewLine + Environment.NewLine + cd.Description;
                            }
                        }
                    }
                }
            }

            // M P E

            //Member (from doc M: )
            //i = 0;
            if (MainClass.CompletedCache.ListDataMembers != null)
            {
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataMembers)
                {
                    if (cd != null)
                    {
                        //if (cd.DisplayText==baseWord)
                        //	i++;

                        CompletionData cdParent = listComplete.Find(cd.DisplayText);
                        if ((cdParent == null) || (!onlyOne))
                        {
                            if (completiontype != CompletionTyp.newType)
                            {
                                cdParent = cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }
                        else
                        {
                            if (!cdParent.Description.Contains(cd.Description))
                            {
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description = cdParent.Description + Environment.NewLine + Environment.NewLine + cd.Description;
                            }
                        }
                    }
                }
            }

            //Member (from doc P:)
            //i = 0;
            if (MainClass.CompletedCache.ListDataProperties != null)
            {
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataProperties)
                {
                    if (cd != null)
                    {
                        //if (cd.DisplayText==baseWord)
                        //	i++;
                        //if(!onlyOne)
                        //	if(cd.DisplayText=="width")
                        //		Console.WriteLine("1");

                        CompletionData cdParent = listComplete.Find(cd.DisplayText);
                        if ((cdParent == null) || (!onlyOne))
                        {
                            if (completiontype != CompletionTyp.newType)
                            {
                                cdParent = cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }
                        else
                        {
                            if (!cdParent.Description.Contains(cd.Description))
                            {
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description = cdParent.Description + Environment.NewLine + Environment.NewLine + cd.Description;
                            }
                        }
                    }
                }
            }

            //Member (from doc  E:)
            //i = 0;
            if (MainClass.CompletedCache.ListDataEvents != null)
            {
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataEvents)
                {
                    if (cd != null)
                    {
                        //if (cd.DisplayText==baseWord)
                        //	i++;

                        CompletionData cdParent = listComplete.Find(cd.DisplayText);
                        if ((cdParent == null) || (!onlyOne))
                        {
                            if (completiontype != CompletionTyp.newType)
                            {
                                cdParent = cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }
                        else
                        {
                            if (!cdParent.Description.Contains(cd.Description))
                            {
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description = cdParent.Description + Environment.NewLine + Environment.NewLine + cd.Description;
                            }
                        }
                    }
                }
            }

            return(listComplete);
        }
Example #4
0
        protected override bool OnKeyPressEvent(Gdk.EventKey evnt)
        {
            char charKey = (char)Gdk.Keyval.ToUnicode(evnt.KeyValue);

            if ((evnt.State == Gdk.ModifierType.ControlMask) && (charKey == 'v'))
            {
                PasteClipboard();
                return(true);
            }
            ;
            if ((evnt.State == Gdk.ModifierType.ControlMask) && (charKey == 'c'))
            {
                CopyClipboard();
                return(true);
            }
            ;

            KeyActions ka = KeyActions.None;

            //if (currentCompletionContext != null) {
            if (CompletionWindowManager.PreProcessKeyEvent(evnt.Key, (char)evnt.Key, evnt.State, out ka))
            {
                CompletionWindowManager.PostProcessKeyEvent(ka);

                if (evnt.Key == Gdk.Key.Up || evnt.Key == Gdk.Key.Down || evnt.Key == Gdk.Key.Return ||
                    evnt.Key == Gdk.Key.Left || evnt.Key == Gdk.Key.Right)                          //)
                {
                    return(true);
                }
            }
            //}

            if (ParameterInformationWindowManager.IsWindowVisible)
            {
                if (ParameterInformationWindowManager.ProcessKeyEvent(this, evnt.Key, evnt.State))
                {
                    return(false);
                }
            }

            if (CompletionWindowManager.IsTemplateModes)
            {
                return(true);
            }


            bool result = base.OnKeyPressEvent(evnt);

            if (!MainClass.Settings.SourceEditorSettings.AggressivelyTriggerCL)
            {
                return(result);
            }
            if (banCompletion)
            {
                return(result);
            }

            completionType = CompletionTyp.allType;

            if ((evnt.State != Gdk.ModifierType.None) && charKey != '(' && charKey != ')')
            {
                return(result);
            }

            int         offset      = this.Document.LocationToOffset(this.Caret.Location);
            int         lineNumber  = this.Document.OffsetToLineNumber(offset);
            LineSegment lineSegment = this.Document.GetLine(lineNumber);

            string lineText = this.Document.GetTextBetween(lineSegment.Offset, offset);


            int countBrackets1 = lineText.Count(c => c == '(');
            int countBrackets2 = lineText.Count(c => c == ')');

            if (countBrackets1 <= countBrackets2)
            {
                ParameterInformationWindowManager.HideWindow(this);
            }

            if (((charKey == '\0') || (char.IsPunctuation(charKey)) &&
                 (char.IsSymbol(charKey))
                 // ||( char.IsWhiteSpace(charKey) )
                 ) &&
                (charKey != '#') &&
                (charKey != '_') &&
                (charKey != '.'))
            {
                return(result);
            }


            int endOffset = offset;

            offset = FindPrevWordOffset(offset);

            if (offset > 0 || endOffset > 0 || offset < endOffset)
            {
                int    offset2      = FindPrevWordOffsetStartSpace(offset);
                string previousWord = this.Document.GetTextBetween(offset2, offset).Trim();

                int    offset3         = FindPrevWordOffsetWithoutDot(offset);
                string previousWordDot = this.Document.GetTextBetween(offset3, offset).Trim();

                //Console.WriteLine("previousWord-> {0}",previousWord);
                //Console.WriteLine("previousWord-> {0}",previousWordDot);

                /*int lineNumber= this.Document.OffsetToLineNumber(endOffset);
                 * LineSegment lineSegment = this.Document.GetLine(lineNumber);
                 *
                 * string lineText =this.Document.GetTextBetween(lineSegment.Offset,endOffset);
                 */

                if (!string.IsNullOrEmpty(lineText))                  // som za komentarom
                {
                    if (lineText.Contains("//"))
                    {
                        return(result);
                    }
                }

                string docText = this.Document.GetTextBetween(0, endOffset);

                int countCommentStart = CountExpresion("/*", docText);             //
                int countCommentEnd   = CountExpresion("*/", docText);             //
                //int countComment = CountExpresion(""",docText);

                int countSem = docText.Count(c => c == '"');

                if (charKey == '(')
                {
                    int    offsetB       = FindPrevWordOffsetWithoutBrackets(offset);
                    string previousWordB = this.Document.GetTextBetween(offsetB, offset - 1).Trim();
                    if ((charKey == '(') || (previousWordB.Trim().Contains('(')))
                    {
                        ParameterDataProvider pdp = new ParameterDataProvider(this, previousWordB.Trim());

                        /*IParameterDataProvider cp = null;
                         * CodeCompletionContext ctx = CreateCodeCompletionContext (cpos);
                         * cp = ParameterCompletionCommand (ctx);
                         */
                        ParameterInformationWindowManager.ShowWindow(this, pdp);

                        return(result);
                    }
                    return(result);
                }
                if (charKey == ')')
                {
                    ParameterInformationWindowManager.HideWindow(this);
                    return(result);
                }

                /*if(lineText.Trim().StartsWith("include")){
                 *      completionType = CompletionTyp.includeType;
                 *
                 *      Gtk.Action act = MainClass.MainWindow.EditorNotebook.EditorAction.GetAction("sourceeditor_insertautocomplete");
                 *      if (act!=null){
                 *              act.Activate();
                 *      }
                 *      return result;
                 * }*/

                // komentar alebo string "" /**/
                if ((countCommentStart > countCommentEnd) || (!ItEven(countSem)))
                {
                    return(result);
                }

                if ((charKey == '.') || (previousWordDot.Trim().Contains('.')))
                {
                    completionType = CompletionTyp.dotType;
                }

                if (previousWord.Trim() == "new")
                {
                    completionType = CompletionTyp.newType;
                }



                string word = this.Document.GetTextAt(offset, endOffset - offset).Trim();
                if ((!IsKeyvord(previousWord.Trim()) && IsIdentifier(word)) ||
                    (previousWord.Trim() == "new") ||
                    (charKey == '.'))
                {
                    Gtk.Action act = MainClass.MainWindow.EditorNotebook.EditorAction.GetAction("sourceeditor_insertautocomplete");
                    if (act != null)
                    {
                        act.Activate();
                    }
                }
            }

            return(result);
        }
Example #5
0
        private CompletionDataList GetCompletionData(CompletionTyp completiontype, bool onlyOne )
        {
            CompletionDataList listComplete = new CompletionDataList();

            if(completiontype == CompletionTyp.includeType){
                listComplete.Add(new CompletionData("lib",null,"lib","lib://"));
                listComplete.Add(new CompletionData("app",null,"app","app://"));
                return listComplete;
            }

            if(MainClass.CompletedCache.ListDataKeywords != null){
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataKeywords) {
                    if ( cd != null ){

                        CompletionData cdParent =listComplete.Find(cd.DisplayText);

                        if ((cdParent== null) || (!onlyOne))  {

                            if (completiontype != CompletionTyp.newType){
                                cdParent =cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        } else {
                            if(!cdParent.Description.Contains(cd.Description)){
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description =cdParent.Description+Environment.NewLine+Environment.NewLine+ cd.Description;

                            }
                        }
                    }
                }
            }

            //Types (from doc T:)
            //i = 0;
            if(MainClass.CompletedCache.ListDataTypes != null){
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataTypes) {
                    if ( cd != null ){
                        CompletionData cdParent =listComplete.Find(cd.DisplayText);
                        if ((cdParent== null) || (!onlyOne)){

                            if (completiontype != CompletionTyp.dotType){
                                cdParent =cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        } else {
                            if(!cdParent.Description.Contains(cd.Description)){
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description =cdParent.Description+Environment.NewLine+Environment.NewLine+ cd.Description;
                            }
                        }
                    }
                }
            }

            // M P E

            //Member (from doc M: )
            //i = 0;
            if(MainClass.CompletedCache.ListDataMembers != null){
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataMembers) {
                    if ( cd != null ){
                        //if (cd.DisplayText==baseWord)
                        //	i++;

                        CompletionData cdParent =listComplete.Find(cd.DisplayText);
                        if ((cdParent== null) || (!onlyOne)){
                            if (completiontype != CompletionTyp.newType){
                                cdParent =cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }  else {
                            if(!cdParent.Description.Contains(cd.Description)){
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description =cdParent.Description+Environment.NewLine+Environment.NewLine+ cd.Description;
                            }
                        }
                    }
                }
            }

            //Member (from doc P:)
            //i = 0;
            if(MainClass.CompletedCache.ListDataProperties != null){
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataProperties) {
                    if ( cd != null ){
                        //if (cd.DisplayText==baseWord)
                        //	i++;
                        //if(!onlyOne)
                        //	if(cd.DisplayText=="width")
                        //		Console.WriteLine("1");

                        CompletionData cdParent =listComplete.Find(cd.DisplayText);
                        if ((cdParent== null) || (!onlyOne)){
                            if (completiontype != CompletionTyp.newType){
                                cdParent =cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }else {
                            if(!cdParent.Description.Contains(cd.Description)){
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description =cdParent.Description+Environment.NewLine+Environment.NewLine+cd.Description;
                            }
                         }
                    }
                }
            }

            //Member (from doc  E:)
            //i = 0;
            if(MainClass.CompletedCache.ListDataEvents != null){
                foreach (CompletionData cd in MainClass.CompletedCache.ListDataEvents) {
                    if ( cd != null ){
                        //if (cd.DisplayText==baseWord)
                        //	i++;

                        CompletionData cdParent =listComplete.Find(cd.DisplayText);
                        if ((cdParent== null) || (!onlyOne)){
                            if (completiontype != CompletionTyp.newType){
                                cdParent =cd.Clone();
                                cdParent.OverloadedData.Add(cd.Clone());
                                listComplete.Add(cdParent);
                            }
                        }else {
                            if(!cdParent.Description.Contains(cd.Description)){
                                cdParent.IsOverloaded = true;
                                cdParent.OverloadedData.Add(cd.Clone());
                                cdParent.Description =cdParent.Description+Environment.NewLine+ Environment.NewLine +cd.Description;
                            }
                        }
                    }
                }
            }

            return listComplete;
        }
Example #6
0
        /// <summary>
        /// Vrati vsetky mozne autokompletion , do zoznamu prida aj slova zo samotneho dokumentu
        /// </summary>
        /// <returns>
        /// Zoznam autoCompletion slov odpovesajuci baseWord a completiontype
        /// </returns>
        public static ICompletionDataList GetCompletionData(this TextEditor editor ,string baseWord,string fullWord ,CompletionTyp completiontype)
        {
            string codestring = editor.Document.Text;
            string type = "";
            string parent = "";

            editor.ParseString(fullWord,out parent,out type);

            Regex regex = new Regex(@"\W", RegexOptions.Compiled);
            codestring = regex.Replace(codestring, " ");

            string[] list = codestring.Split(' ');
            CompletionDataList listComplete = new CompletionDataList();
            listComplete.CompletionSelectionMode = CompletionSelectionMode.OwnTextField;

            if(!String.IsNullOrEmpty(type)){
                //List<CompletionData> lst = MainClass.CompletedCache.AllCompletionOnlyOne.FindAll(x=>x.Parent == type);
                List<CompletionData> lst = MainClass.CompletedCache.AllCompletionRepeat.FindAll(x=>x.Parent == type);
                foreach ( CompletionData cd in lst){
                    string expres =cd.Parent+".on";
                    if(cd.Signature.StartsWith(expres) ){
                        //expres = cd.Signature.Replace(cd.Parent+".", cd.DisplayText +" = function ");
                        expres = cd.Signature.Replace(cd.Parent+"."+ cd.DisplayText, cd.DisplayText +" = function ");
                        cd.DisplayDescription =expres+"{}";
                        cd.CompletionText =expres+"{"+Environment.NewLine+"}";
                    }

                }

                if (lst != null)
                    listComplete.AddRange(lst.ToArray());

                if(listComplete != null && listComplete.Count>0){
                    return listComplete;
                }
            }

            switch (completiontype) {
            case CompletionTyp.allType:
                {
                    listComplete.AddRange(MainClass.CompletedCache.AllCompletionOnlyOne);
                    break;
                }
            case CompletionTyp.newType:
                {
                    listComplete.AddRange(MainClass.CompletedCache.NewCompletion);
                    break;
                }
            case CompletionTyp.dotType:
                {
                    listComplete.AddRange(MainClass.CompletedCache.DotCompletion);
                    break;
                }
            }

            int i = 0;
            foreach (string s in list) {
                if ( !String.IsNullOrEmpty(s.Trim()) ){
                    if (s==baseWord)
                        i++;

                    if ((listComplete.Find(s)== null) && (s.Length>2) && ( (s!= baseWord) || (i ==1) ) ){
                        CompletionData cd = new CompletionData(s, null, s, s);

                        if (completiontype == CompletionTyp.newType){
                            if(char.ToUpper(s[0]) == s[0]  && !char.IsDigit(s[0]) && !char.IsSymbol(s[0]) &&char.IsLetter(s[0]) ){

                                CompletionData cdParent =listComplete.Find(cd.DisplayText);
                                if (cdParent== null){
                                    listComplete.Add(cd);
                                } else {
                                    if(!cdParent.Description.Contains(cd.Description))
                                        cdParent.Description =cdParent.Description+Environment.NewLine+cd.Description;
                                }
                            }
                        }  else{
                            CompletionData cdParent =listComplete.Find(cd.DisplayText);
                            if (cdParent== null){
                                listComplete.Add(cd);
                            } else {
                                if(!cdParent.Description.Contains(cd.Description))
                                    cdParent.Description =cdParent.Description+Environment.NewLine+cd.Description;
                            }
                        }
                    }
                }
            }

             			return listComplete;
        }
Example #7
0
        protected override bool OnKeyPressEvent(Gdk.EventKey evnt)
        {
            char charKey = (char)Gdk.Keyval.ToUnicode (evnt.KeyValue);
            if ((evnt.State == Gdk.ModifierType.ControlMask) &&(charKey=='v')) {
                PasteClipboard();
                return true;
            };
            if ((evnt.State == Gdk.ModifierType.ControlMask) &&(charKey=='c')) {
                CopyClipboard();
                return true;
            };

            KeyActions ka = KeyActions.None;
            //if (currentCompletionContext != null) {
                if (CompletionWindowManager.PreProcessKeyEvent (evnt.Key,(char)evnt.Key, evnt.State, out ka)) {
                    CompletionWindowManager.PostProcessKeyEvent (ka);

                    if(evnt.Key == Gdk.Key.Up || evnt.Key == Gdk.Key.Down || evnt.Key == Gdk.Key.Return
                    || evnt.Key == Gdk.Key.Left || evnt.Key == Gdk.Key.Right  ) //)
                        return true;
                }
            //}

            if (ParameterInformationWindowManager.IsWindowVisible) {
                if (ParameterInformationWindowManager.ProcessKeyEvent (this, evnt.Key, evnt.State))
                    return false;
            }

            if(CompletionWindowManager.IsTemplateModes){
                return true;
            }

            bool result = base.OnKeyPressEvent (evnt);

            if(!MainClass.Settings.SourceEditorSettings.AggressivelyTriggerCL)
                return result;
            if(banCompletion){
                return result;
            }

            completionType = CompletionTyp.allType;

            if ((evnt.State != Gdk.ModifierType.None) && charKey!='(' && charKey!=')') return result;

            int offset =this.Document.LocationToOffset(this.Caret.Location);
            int lineNumber= this.Document.OffsetToLineNumber(offset);
            LineSegment lineSegment = this.Document.GetLine(lineNumber);

            string lineText =this.Document.GetTextBetween(lineSegment.Offset,offset);

            int countBrackets1 = lineText.Count(c => c == '(');
            int countBrackets2 = lineText.Count(c => c == ')');
            if(countBrackets1<=countBrackets2){
                ParameterInformationWindowManager.HideWindow(this);
            }

            if( ( (charKey == '\0') || (char.IsPunctuation(charKey)) &&
                        ( char.IsSymbol(charKey) )
                        // ||( char.IsWhiteSpace(charKey) )
                )
                        && ( charKey!= '#')
                        && ( charKey!= '_')
                        && ( charKey!= '.'))
            {

                return result;
            }

            int endOffset = offset;
            offset = FindPrevWordOffset(offset);

            if ( offset > 0 || endOffset > 0 || offset < endOffset)
            {
                int offset2 =FindPrevWordOffsetStartSpace(offset);
                string  previousWord = this.Document.GetTextBetween(offset2,offset).Trim();

                int offset3 = FindPrevWordOffsetWithoutDot(offset);
                string  previousWordDot = this.Document.GetTextBetween(offset3,offset).Trim();

                //Console.WriteLine("previousWord-> {0}",previousWord);
                //Console.WriteLine("previousWord-> {0}",previousWordDot);

                /*int lineNumber= this.Document.OffsetToLineNumber(endOffset);
                LineSegment lineSegment = this.Document.GetLine(lineNumber);

                string lineText =this.Document.GetTextBetween(lineSegment.Offset,endOffset);
            */

                if (!string.IsNullOrEmpty(lineText)){ // som za komentarom
                    if (lineText.Contains("//")) return result;
                }

                string docText =this.Document.GetTextBetween(0,endOffset);

                int countCommentStart = CountExpresion("/*",docText);//
                int countCommentEnd = CountExpresion("*/",docText);//
                //int countComment = CountExpresion(""",docText);

                int countSem = docText.Count(c => c == '"');

                if(charKey=='('){
                    int offsetB = FindPrevWordOffsetWithoutBrackets(offset);
                    string  previousWordB = this.Document.GetTextBetween(offsetB,offset-1).Trim();
                    if ((charKey == '('  ) || (previousWordB.Trim().Contains('(')   )){
                        ParameterDataProvider pdp = new ParameterDataProvider(this,previousWordB.Trim());
                        /*IParameterDataProvider cp = null;
                    CodeCompletionContext ctx = CreateCodeCompletionContext (cpos);
                    cp = ParameterCompletionCommand (ctx);
            */
                        ParameterInformationWindowManager.ShowWindow(this,pdp);

                        return result;
                    }
                    return result;
                }
                if(charKey==')'){
                    ParameterInformationWindowManager.HideWindow(this);
                    return result;
                }

                /*if(lineText.Trim().StartsWith("include")){
                    completionType = CompletionTyp.includeType;

                    Gtk.Action act = MainClass.MainWindow.EditorNotebook.EditorAction.GetAction("sourceeditor_insertautocomplete");
                    if (act!=null){
                        act.Activate();
                    }
                    return result;
                }*/

                // komentar alebo string "" /**/
                if((countCommentStart>countCommentEnd) ||(!ItEven(countSem)) ) return result;

                if ((charKey == '.'  ) || (previousWordDot.Trim().Contains('.')   ))
                    completionType = CompletionTyp.dotType;

                if (previousWord.Trim()=="new")
                    completionType = CompletionTyp.newType;

                string word = this.Document.GetTextAt (offset, endOffset - offset).Trim();
                if ((!IsKeyvord(previousWord.Trim()) && IsIdentifier(word)) ||
                    (previousWord.Trim()=="new") ||
                    ( charKey == '.'  ))
                {
                    Gtk.Action act = MainClass.MainWindow.EditorNotebook.EditorAction.GetAction("sourceeditor_insertautocomplete");
                    if (act!=null){
                        act.Activate();
                    }
                }
            }

            return result;
        }