public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			
			if (this.CompletionPossible(editor, ch)) {
				
				ResourceResolveResult result = ResourceResolverService.Resolve(editor, ch);
				if (result != null) {
					IResourceFileContent content;
					if ((content = result.ResourceFileContent) != null) {
						
						// If the resolved resource set is the local ICSharpCode.Core resource set
						// (this may happen through the ICSharpCodeCoreNRefactoryResourceResolver),
						// we will have to merge in the host resource set (if available)
						// for the code completion window.
						if (result.ResourceSetReference.ResourceSetName == ICSharpCodeCoreResourceResolver.ICSharpCodeCoreLocalResourceSetName) {
							IResourceFileContent hostContent = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent;
							if (hostContent != null) {
								content = new MergedResourceFileContent(content, new IResourceFileContent[] { hostContent });
							}
						}
						
						editor.ShowCompletionWindow(new ResourceCodeCompletionDataProvider(content, this.OutputVisitor, result.CallingClass != null ? result.CallingClass.Name+"." : null), ch);
						return true;
					}
				}
				
			}
			
			return false;
		}
コード例 #2
0
        protected IList <ResolveResult> ResolveCallParameters(SharpDevelopTextAreaControl editor, InspectedCall call)
        {
            List <ResolveResult> rr = new List <ResolveResult>();
            int    offset           = LocationToOffset(editor, call.start);
            string documentText     = editor.Text;
            int    newOffset;

            foreach (Location loc in call.commas)
            {
                newOffset = LocationToOffset(editor, loc);
                if (newOffset < 0)
                {
                    break;
                }
                string text = editor.Document.GetText(offset + 1, newOffset - (offset + 1));
                rr.Add(ParserService.Resolve(new ExpressionResult(text), loc.Line, loc.Column, editor.FileName, documentText));
            }
            // the last argument is between the last comma and the caret position
            newOffset = editor.ActiveTextAreaControl.Caret.Offset;
            if (offset < newOffset)
            {
                string text = editor.Document.GetText(offset + 1, newOffset - (offset + 1));
                rr.Add(ParserService.Resolve(new ExpressionResult(text),
                                             editor.ActiveTextAreaControl.Caret.Line + 1,
                                             editor.ActiveTextAreaControl.Caret.Column + 1,
                                             editor.FileName, documentText));
            }
            return(rr);
        }
        public SharpSnippetCompilerControl()
        {
            InitializeComponent();

            textEditor = new SharpDevelopTextAreaControl();
            textEditor.Dock = DockStyle.Fill;
            this.Controls.Add(textEditor);
        }
コード例 #4
0
        public virtual bool CtrlSpace(SharpDevelopTextAreaControl editor)
        {
            CtrlSpaceCompletionDataProvider provider = new CtrlSpaceCompletionDataProvider();

            provider.AllowCompleteExistingExpression = true;
            editor.ShowCompletionWindow(provider, '\0');
            return(true);
        }
コード例 #5
0
        public QuickClassBrowserPanel(SharpDevelopTextAreaControl textAreaControl)
        {
            InitializeComponent();
            this.membersComboBox.MaxDropDownItems = 20;

            base.Dock            = DockStyle.Top;
            this.textAreaControl = textAreaControl;
            this.textAreaControl.ActiveTextAreaControl.Caret.PositionChanged += new EventHandler(CaretPositionChanged);
        }
コード例 #6
0
        protected int LocationToOffset(SharpDevelopTextAreaControl editor, Location loc)
        {
            if (loc.IsEmpty || loc.Line - 1 >= editor.Document.TotalNumberOfLines)
            {
                return(-1);
            }
            LineSegment seg = editor.Document.GetLineSegment(loc.Line - 1);

            return(seg.Offset + Math.Min(loc.Column, seg.Length) - 1);
        }
コード例 #7
0
 public TextEditorDisplayBindingWrapper()
 {
     textAreaControl             = CreateSharpDevelopTextAreaControl();
     textAreaControl.RightToLeft = RightToLeft.No;
     textAreaControl.Document.DocumentChanged += new DocumentEventHandler(TextAreaChangedEvent);
     textAreaControl.ActiveTextAreaControl.Caret.CaretModeChanged += new EventHandler(CaretModeChanged);
     textAreaControl.ActiveTextAreaControl.Enter += new EventHandler(CaretUpdate);
     textAreaControl.ActiveTextAreaControl.Caret.PositionChanged += CaretUpdate;
     watcher = new FileChangeWatcher(this);
 }
コード例 #8
0
        public TextEditorDisplayBindingWrapper(OpenedFile file) : base(file)
        {
            this.TabPageText = "${res:FormsDesigner.DesignTabPages.SourceTabPage}";

            textEditorControl             = CreateSharpDevelopTextAreaControl();
            textEditorControl.RightToLeft = RightToLeft.No;
            textEditorControl.Document.DocumentChanged += new DocumentEventHandler(TextAreaChangedEvent);
            textEditorControl.ActiveTextAreaControl.Caret.CaretModeChanged += new EventHandler(CaretModeChanged);
            textEditorControl.ActiveTextAreaControl.Enter += new EventHandler(CaretUpdate);
            textEditorControl.ActiveTextAreaControl.Caret.PositionChanged += CaretUpdate;

            textEditorControl.FileName = file.FileName;
        }
コード例 #9
0
		public bool CtrlSpace(SharpDevelopTextAreaControl editor)
		{
			string ext = Path.GetExtension(editor.FileName);
			foreach (string extension in extensions) {
				if (ext.Equals(extension, StringComparison.OrdinalIgnoreCase)) {
					if (binding == null) {
						binding = (ICodeCompletionBinding)codon.AddIn.CreateObject(codon.Properties["class"]);
					}
					return binding.CtrlSpace(editor);
				}
			}
			return false;
		}
コード例 #10
0
		public bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			string ext = Path.GetExtension(editor.FileName);
			foreach (string extension in extensions) {
				if (ext.Equals(extension, StringComparison.InvariantCultureIgnoreCase)) {
					if (binding == null) {
						binding = (ICodeCompletionBinding)codon.AddIn.CreateObject(codon.Properties["class"]);
					}
					return binding.HandleKeyPress(editor, ch);
				}
			}
			return false;
		}
コード例 #11
0
        protected IMember GetCurrentMember(SharpDevelopTextAreaControl editor)
        {
            ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
            NRefactoryResolver           r     = new NRefactoryResolver(ParserService.CurrentProjectContent, languageProperties);

            if (r.Initialize(editor.FileName, caret.Line + 1, caret.Column + 1))
            {
                return(r.CallingMember);
            }
            else
            {
                return(null);
            }
        }
		public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			
			if (ch == ':') {
				
				if (editor.ActiveTextAreaControl.Caret.Offset >= 5 && editor.Document.GetText(editor.ActiveTextAreaControl.Caret.Offset-5, 5) == "${res") {
					
					IResourceFileContent content = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreLocalResourceSet(editor.FileName).ResourceFileContent;
					#if DEBUG
					if (content != null) {
						LoggingService.Debug("ResourceToolkit: Found local ICSharpCode.Core resource file: "+content.FileName);
					}
					#endif
					
					IResourceFileContent hostContent = ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent;
					if (hostContent != null) {
						#if DEBUG
						LoggingService.Debug("ResourceToolkit: Found host ICSharpCode.Core resource file: "+hostContent.FileName);
						#endif
						if (content != null) {
							content = new MergedResourceFileContent(content, new IResourceFileContent[] { hostContent });
						} else {
							content = hostContent;
						}
					}
					
					if (content != null) {
						editor.ShowCompletionWindow(new ResourceCodeCompletionDataProvider(content, null, null), ch);
						return true;
					}
					
				}
				
			} else if (ch == '$') {
				
				// Provide ${res: as code completion
				// in an ICSharpCode.Core application
				if (ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreHostResourceSet(editor.FileName).ResourceFileContent != null ||
				    ICSharpCodeCoreResourceResolver.GetICSharpCodeCoreLocalResourceSet(editor.FileName).ResourceFileContent != null) {
					
					editor.ShowCompletionWindow(new ICSharpCodeCoreTagCompletionDataProvider(), ch);
					return true;
					
				}
				
			}
			
			return false;
		}
コード例 #13
0
		public override bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
		{
			switch (word.ToLowerInvariant()) {
				case "import":
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Importable), ' ');
					return true;
				case "as":
				case "isa":
					if (IsInComment(editor)) return false;
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Type), ' ');
					return true;
				default:
					return base.HandleKeyword(editor, word);
			}
		}
コード例 #14
0
        public bool CtrlSpace(SharpDevelopTextAreaControl editor)
        {
            string ext = Path.GetExtension(editor.FileName);

            foreach (string extension in extensions)
            {
                if (ext.Equals(extension, StringComparison.OrdinalIgnoreCase))
                {
                    if (binding == null)
                    {
                        binding = (ICodeCompletionBinding)codon.AddIn.CreateObject(codon.Properties["class"]);
                    }
                    return(binding.CtrlSpace(editor));
                }
            }
            return(false);
        }
コード例 #15
0
        public bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
        {
            string ext = Path.GetExtension(editor.FileName);

            foreach (string extension in extensions)
            {
                if (ext.Equals(extension, StringComparison.InvariantCultureIgnoreCase))
                {
                    if (binding == null)
                    {
                        binding = (ICodeCompletionBinding)codon.AddIn.CreateObject(codon.Properties["class"]);
                    }
                    return(binding.HandleKeyPress(editor, ch));
                }
            }
            return(false);
        }
コード例 #16
0
		public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			if (ch == '[') {
				int cursor = editor.ActiveTextAreaControl.Caret.Offset;
				for (int i = cursor - 1; i > 0; i--) {
					char c = editor.Document.GetCharAt(i);
					if (c == '\n' || c == '(' || c == ',') {
						// -> Attribute completion
						editor.ShowCompletionWindow(new AttributesDataProvider(ExpressionFinder.BooAttributeContext.Instance), ch);
						return true;
					}
					if (!char.IsWhiteSpace(c))
						break;
				}
			}
			return base.HandleKeyPress(editor, ch);
		}
コード例 #17
0
        protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped)
        {
            int paramCount = parameters.Count;

            dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea);
            List <IMethodOrProperty> methods = dp.Methods;

            if (methods.Count == 0)
            {
                return;
            }
            bool overloadIsSure;

            if (methods.Count == 1)
            {
                overloadIsSure  = true;
                dp.DefaultIndex = 0;
            }
            else
            {
                IReturnType[] argumentTypes = new IReturnType[paramCount + 1];
                int           i             = 0;
                foreach (ResolveResult rr in parameters)
                {
                    if (rr != null)
                    {
                        argumentTypes[i] = rr.ResolvedType;
                    }
                    i++;
                }
                IMethodOrProperty result = Dom.CSharp.OverloadResolution.FindOverload(
                    methods, argumentTypes, true, false, out overloadIsSure);
                dp.DefaultIndex = methods.IndexOf(result);
            }
            editor.ShowInsightWindow(dp);
            if (overloadIsSure)
            {
                IMethodOrProperty method = methods[dp.DefaultIndex];
                if (paramCount < method.Parameters.Count)
                {
                    IParameter param = method.Parameters[paramCount];
                    ProvideContextCompletion(editor, param.ReturnType, charTyped);
                }
            }
        }
コード例 #18
0
        protected bool ProvideContextCompletion(SharpDevelopTextAreaControl editor, IReturnType expected, char charTyped)
        {
            if (expected == null)
            {
                return(false);
            }
            IClass c = expected.GetUnderlyingClass();

            if (c == null)
            {
                return(false);
            }
            if (c.ClassType == ClassType.Enum)
            {
                CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
                cdp.ForceNewExpression = true;
                ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp);
                cache.activationKey = charTyped;
                cache.GenerateCompletionData(editor.FileName, editor.ActiveTextAreaControl.TextArea, charTyped);
                ICompletionData[] completionData = cache.CompletionData;
                Array.Sort(completionData);
                for (int i = 0; i < completionData.Length; i++)
                {
                    CodeCompletionData ccd = completionData[i] as CodeCompletionData;
                    if (ccd != null && ccd.Class != null)
                    {
                        if (ccd.Class.FullyQualifiedName == expected.FullyQualifiedName)
                        {
                            cache.DefaultIndex = i;
                            break;
                        }
                    }
                }
                if (cache.DefaultIndex >= 0)
                {
                    if (charTyped != ' ')
                    {
                        cdp.InsertSpace = true;
                    }
                    editor.ShowCompletionWindow(cache, charTyped);
                    return(true);
                }
            }
            return(false);
        }
コード例 #19
0
		bool DoCaseCompletion(SharpDevelopTextAreaControl editor)
		{
			ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
			NRefactoryResolver r = new NRefactoryResolver(ParserService.CurrentProjectContent, LanguageProperties.CSharp);
			if (r.Initialize(editor.FileName, caret.Line + 1, caret.Column + 1)) {
				AST.INode currentMember = r.ParseCurrentMember(editor.Text);
				if (currentMember != null) {
					CaseCompletionSwitchFinder ccsf = new CaseCompletionSwitchFinder(caret.Line + 1, caret.Column + 1);
					currentMember.AcceptVisitor(ccsf, null);
					if (ccsf.bestStatement != null) {
						r.RunLookupTableVisitor(currentMember);
						ResolveResult rr = r.ResolveInternal(ccsf.bestStatement.SwitchExpression, ExpressionContext.Default);
						if (rr != null && rr.ResolvedType != null) {
							return ProvideContextCompletion(editor, rr.ResolvedType, ' ');
						}
					}
				}
			}
			return false;
		}
コード例 #20
0
ファイル: PNTabItem.cs プロジェクト: nhannhan159/PAT
        public PNTabItem(string moduleName)
        {
            InitializeComponent();

            DeclarationNode = new TreeNode("Declaration");
            ModelNode = new TreeNode("Models");
            TreeNode treeNode8 = new TreeNode("Petri Nets Model",
                new TreeNode[] {
                    DeclarationNode,
                    ModelNode
                });

            MenuButton_SetError.Visible = false;

            //treeNode8.Name = "Root";
            treeNode8.Text = "Petri Nets";
            this.TreeView_Structure.Nodes.AddRange(new TreeNode[] { treeNode8 });

            //AssertionNode.Name = "Declaration";
            DeclarationNode.StateImageIndex = 0;
            //AssertionNode.Text = "Declaration";
            ModelNode.Name = "Models";
            ModelNode.StateImageIndex = 1;
            //ModelNode.Text = "Processes";

            AddEventHandlerForButtons();

            textEditorControl = new SharpDevelopTextAreaControl();
            textEditorControl.Dock = DockStyle.Fill;
            textEditorControl.ContextMenuStrip = EditorContextMenuStrip;
            textEditorControl.BorderStyle = BorderStyle.Fixed3D;
            textEditorControl.Visible = true;

            this.splitContainer1.Panel2.Controls.Add(textEditorControl);

            this.TabText = Resources.Document_ + counter;
            counter++;

            textEditorControl.FileNameChanged += new EventHandler(_EditorControl_FileNameChanged);
            textEditorControl.TextChanged += new EventHandler(textEditorControl_TextChanged);
            textEditorControl.Tag = this;

            this.Padding = new Padding(2, 2, 2, 2);
            this.DockableAreas = DockAreas.Document;

            secondaryViewContentCollection = new SecondaryViewContentCollection(this);
            InitFiles();

            file = FileService.CreateUntitledOpenedFile(TabText, new byte[] { });
            file.CurrentView = this;
            textEditorControl.FileName = file.FileName;
            files.Clear();
            files.Add(file);

            this.SetSyntaxLanguage(moduleName);

            textEditorControl.Document.FoldingManager.FoldingStrategy = new FoldingStrategy();

            // Highlight the matching bracket or not...
            this.textEditorControl.ShowMatchingBracket = true;

            this.textEditorControl.BracketMatchingStyle = BracketMatchingStyle.Before;

            HostCallbackImplementation.Register(this);
            CodeCompletionKeyHandler.Attach(this, textEditorControl);
            ToolTipProvider.Attach(this, textEditorControl);

            pcRegistry = new ProjectContentRegistry(); // Default .NET 2.0 registry

            // Persistence lets SharpDevelop.Dom create a cache file on disk so that
            // future starts are faster.
            // It also caches XML documentation files in an on-disk hash table, thus
            // reducing memory usage.
            pcRegistry.ActivatePersistence(Path.Combine(Path.GetTempPath(), "CSharpCodeCompletion"));

            myProjectContent = new DefaultProjectContent();
            myProjectContent.Language = LanguageProperties.CSharp;

            this.TreeView_Structure.HideSelection = false;
            splitContainer1.SplitterDistance = 100;

            addProcessToolStripMenuItem.PerformClick();

            this.TreeView_Structure.ExpandAll();

            Button_AddNewNail.Visible = false;

            //show the declaration
            TreeView_Structure.SelectedNode = DeclarationNode;
            TreeView_Structure_NodeMouseDoubleClick(null, new TreeNodeMouseClickEventArgs(DeclarationNode, MouseButtons.Left, 2, 0, 0));
        }
コード例 #21
0
		bool ShowNewCompletion(SharpDevelopTextAreaControl editor)
		{
			CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName);
			int cursor = editor.ActiveTextAreaControl.Caret.Offset;
			string documentToCursor = editor.Document.GetText(0, cursor);
			ExpressionResult expressionResult = ef.FindExpression(documentToCursor, cursor);
			
			LoggingService.Debug("ShowNewCompletion: expression is " + expressionResult);
			if (expressionResult.Context.IsObjectCreation) {
				LineSegment currentLine = editor.Document.GetLineSegmentForOffset(cursor);
				string lineText = editor.Document.GetText(currentLine.Offset, cursor - currentLine.Offset);
				// when the new follows an assignment, improve code-completion by detecting the
				// type of the variable that is assigned to
				if (lineText.Replace(" ", "").EndsWith("=new")) {
					int pos = lineText.LastIndexOf('=');
					ExpressionContext context = FindExactContextForNewCompletion(editor, documentToCursor,
					                                                             currentLine, pos);
					if (context != null)
						expressionResult.Context = context;
				}
				editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(expressionResult.Context), ' ');
				return true;
			}
			return false;
		}
コード例 #22
0
        protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection <ResolveResult> parameters, char charTyped)
        {
            int paramCount = parameters.Count;

            dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea);
            List <IMethodOrProperty> methods = dp.Methods;

            if (methods.Count == 0)
            {
                return;
            }
            bool overloadIsSure;

            if (methods.Count == 1)
            {
                overloadIsSure  = true;
                dp.DefaultIndex = 0;
            }
            else
            {
                IReturnType[] parameterTypes = new IReturnType[paramCount + 1];
                int           i = 0;
                foreach (ResolveResult rr in parameters)
                {
                    if (rr != null)
                    {
                        parameterTypes[i] = rr.ResolvedType;
                    }
                    i++;
                }
                IReturnType[][] tmp;
                int[]           ranking      = MemberLookupHelper.RankOverloads(methods, parameterTypes, true, out overloadIsSure, out tmp);
                bool            multipleBest = false;
                int             bestRanking  = -1;
                int             best         = 0;
                for (i = 0; i < ranking.Length; i++)
                {
                    if (ranking[i] > bestRanking)
                    {
                        bestRanking  = ranking[i];
                        best         = i;
                        multipleBest = false;
                    }
                    else if (ranking[i] == bestRanking)
                    {
                        multipleBest = true;
                    }
                }
                if (multipleBest)
                {
                    overloadIsSure = false;
                }
                dp.DefaultIndex = best;
            }
            editor.ShowInsightWindow(dp);
            if (overloadIsSure)
            {
                IMethodOrProperty method = methods[dp.DefaultIndex];
                if (paramCount < method.Parameters.Count)
                {
                    IParameter param = method.Parameters[paramCount];
                    ProvideContextCompletion(editor, param.ReturnType, charTyped);
                }
            }
        }
コード例 #23
0
        protected bool InsightRefreshOnComma(SharpDevelopTextAreaControl editor, char ch)
        {
            // Show MethodInsightWindow or IndexerInsightWindow
            NRefactoryResolver r = new NRefactoryResolver(ParserService.CurrentProjectContent, languageProperties);
            Location           cursorLocation = new Location(editor.ActiveTextAreaControl.Caret.Column + 1, editor.ActiveTextAreaControl.Caret.Line + 1);

            if (r.Initialize(editor.FileName, cursorLocation.Y, cursorLocation.X))
            {
                TextReader currentMethod = r.ExtractCurrentMethod(editor.Text);
                if (currentMethod != null)
                {
                    ILexer        lexer = ParserFactory.CreateLexer(language, currentMethod);
                    Token         token;
                    InspectedCall call = new InspectedCall(Location.Empty, null);
                    call.parent = call;
                    while ((token = lexer.NextToken()) != null &&
                           token.kind != eofToken &&
                           token.Location < cursorLocation)
                    {
                        if (token.kind == commaToken)
                        {
                            call.commas.Add(token.Location);
                        }
                        else if (token.kind == openParensToken || token.kind == openBracketToken || token.kind == openBracesToken)
                        {
                            call = new InspectedCall(token.Location, call);
                        }
                        else if (token.kind == closeParensToken || token.kind == closeBracketToken || token.kind == closeBracesToken)
                        {
                            call = call.parent;
                        }
                    }
                    int offset = LocationToOffset(editor, call.start);
                    if (offset >= 0 && offset < editor.Document.TextLength)
                    {
                        char c = editor.Document.GetCharAt(offset);
                        if (c == '(')
                        {
                            ShowInsight(editor,
                                        new MethodInsightDataProvider(offset, true),
                                        ResolveCallParameters(editor, call),
                                        ch);
                            return(true);
                        }
                        else if (c == '[')
                        {
                            ShowInsight(editor,
                                        new IndexerInsightDataProvider(offset, true),
                                        ResolveCallParameters(editor, call),
                                        ch);
                            return(true);
                        }
                        else
                        {
                            LoggingService.Warn("Expected '(' or '[' at start position");
                        }
                    }
                }
            }
            return(false);
        }
コード例 #24
0
		public virtual bool CtrlSpace(SharpDevelopTextAreaControl editor)
		{
			CtrlSpaceCompletionDataProvider provider = new CtrlSpaceCompletionDataProvider();
			provider.AllowCompleteExistingExpression = true;
			editor.ShowCompletionWindow(provider, '\0');
			return true;
		}
コード例 #25
0
		public virtual bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			switch (ch) {
				case '(':
					if (enableMethodInsight && CodeCompletionOptions.InsightEnabled) {
						editor.ShowInsightWindow(new MethodInsightDataProvider());
						return true;
					} else {
						return false;
					}
				case '[':
					if (enableIndexerInsight && CodeCompletionOptions.InsightEnabled) {
						editor.ShowInsightWindow(new IndexerInsightDataProvider());
						return true;
					} else {
						return false;
					}
				case '<':
					if (enableXmlCommentCompletion) {
						editor.ShowCompletionWindow(new CommentCompletionDataProvider(), ch);
						return true;
					} else {
						return false;
					}
				case '.':
					if (enableDotCompletion) {
						editor.ShowCompletionWindow(new CodeCompletionDataProvider(), ch);
						return true;
					} else {
						return false;
					}
				case ' ':
					if (!CodeCompletionOptions.KeywordCompletionEnabled)
						return false;
					string word = editor.GetWordBeforeCaret();
					if (word != null)
						return HandleKeyword(editor, word);
					else
						return false;
				default:
					return false;
			}
		}
コード例 #26
0
		public TextEditorDisplayBindingWrapper(OpenedFile file) : base(file)
		{
			this.TabPageText = "${res:FormsDesigner.DesignTabPages.SourceTabPage}";
			
			textEditorControl = CreateSharpDevelopTextAreaControl();
			textEditorControl.RightToLeft = RightToLeft.No;
			textEditorControl.Document.DocumentChanged += new DocumentEventHandler(TextAreaChangedEvent);
			textEditorControl.ActiveTextAreaControl.Caret.CaretModeChanged += new EventHandler(CaretModeChanged);
			textEditorControl.ActiveTextAreaControl.Enter += new EventHandler(CaretUpdate);
			textEditorControl.ActiveTextAreaControl.Caret.PositionChanged += CaretUpdate;
			
			textEditorControl.FileName = file.FileName;
		}
コード例 #27
0
		protected IList<ResolveResult> ResolveCallParameters(SharpDevelopTextAreaControl editor, InspectedCall call)
		{
			List<ResolveResult> rr = new List<ResolveResult>();
			int offset = LocationToOffset(editor, call.start);
			string documentText = editor.Text;
			int newOffset;
			foreach (Location loc in call.commas) {
				newOffset = LocationToOffset(editor, loc);
				if (newOffset < 0) break;
				string text = editor.Document.GetText(offset+1,newOffset-(offset+1));
				rr.Add(ParserService.Resolve(new ExpressionResult(text), loc.Line, loc.Column, editor.FileName, documentText));
			}
			// the last argument is between the last comma and the caret position
			newOffset = editor.ActiveTextAreaControl.Caret.Offset;
			if (offset < newOffset) {
				string text = editor.Document.GetText(offset+1,newOffset-(offset+1));
				rr.Add(ParserService.Resolve(new ExpressionResult(text),
				                             editor.ActiveTextAreaControl.Caret.Line + 1,
				                             editor.ActiveTextAreaControl.Caret.Column + 1,
				                             editor.FileName, documentText));
			}
			return rr;
		}
コード例 #28
0
		protected IMember GetCurrentMember(SharpDevelopTextAreaControl editor)
		{
			ICSharpCode.TextEditor.Caret caret = editor.ActiveTextAreaControl.Caret;
			NRefactoryResolver r = new NRefactoryResolver(languageProperties);
			if (r.Initialize(ParserService.GetParseInformation(editor.FileName), caret.Line + 1, caret.Column + 1)) {
				return r.CallingMember;
			} else {
				return null;
			}
		}
コード例 #29
0
 public virtual bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
 {
     // DefaultCodeCompletionBinding does not support Keyword handling, but this
     // method can be overridden
     return(false);
 }
コード例 #30
0
		protected void ShowInsight(SharpDevelopTextAreaControl editor, MethodInsightDataProvider dp, ICollection<ResolveResult> parameters, char charTyped)
		{
			int paramCount = parameters.Count;
			dp.SetupDataProvider(editor.FileName, editor.ActiveTextAreaControl.TextArea);
			List<IMethodOrProperty> methods = dp.Methods;
			if (methods.Count == 0) return;
			bool overloadIsSure;
			if (methods.Count == 1) {
				overloadIsSure = true;
				dp.DefaultIndex = 0;
			} else {
				IReturnType[] argumentTypes = new IReturnType[paramCount + 1];
				int i = 0;
				foreach (ResolveResult rr in parameters) {
					if (rr != null) {
						argumentTypes[i] = rr.ResolvedType;
					}
					i++;
				}
				IMethodOrProperty result = Dom.CSharp.OverloadResolution.FindOverload(
					methods, argumentTypes, true, false, out overloadIsSure);
				dp.DefaultIndex = methods.IndexOf(result);
			}
			editor.ShowInsightWindow(dp);
			if (overloadIsSure) {
				IMethodOrProperty method = methods[dp.DefaultIndex];
				if (paramCount < method.Parameters.Count) {
					IParameter param = method.Parameters[paramCount];
					ProvideContextCompletion(editor, param.ReturnType, charTyped);
				}
			}
		}
コード例 #31
0
		protected bool ProvideContextCompletion(SharpDevelopTextAreaControl editor, IReturnType expected, char charTyped)
		{
			if (expected == null) return false;
			IClass c = expected.GetUnderlyingClass();
			if (c == null) return false;
			if (c.ClassType == ClassType.Enum) {
				CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider();
				ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp);
				cache.activationKey = charTyped;
				cache.GenerateCompletionData(editor.FileName, editor.ActiveTextAreaControl.TextArea, charTyped);
				ICompletionData[] completionData = cache.CompletionData;
				Array.Sort(completionData, DefaultCompletionData.Compare);
				for (int i = 0; i < completionData.Length; i++) {
					CodeCompletionData ccd = completionData[i] as CodeCompletionData;
					if (ccd != null && ccd.Class != null) {
						if (ccd.Class.FullyQualifiedName == expected.FullyQualifiedName) {
							cache.DefaultIndex = i;
							break;
						}
					}
				}
				if (cache.DefaultIndex >= 0) {
					if (charTyped != ' ') cdp.InsertSpace = true;
					editor.ShowCompletionWindow(cache, charTyped);
					return true;
				}
			}
			return false;
		}
コード例 #32
0
		protected bool InsightRefreshOnComma(SharpDevelopTextAreaControl editor, char ch)
		{
			// Show MethodInsightWindow or IndexerInsightWindow
			NRefactoryResolver r = new NRefactoryResolver(languageProperties);
			Location cursorLocation = new Location(editor.ActiveTextAreaControl.Caret.Column + 1, editor.ActiveTextAreaControl.Caret.Line + 1);
			if (r.Initialize(ParserService.GetParseInformation(editor.FileName), cursorLocation.Y, cursorLocation.X)) {
				TextReader currentMethod = r.ExtractCurrentMethod(editor.Text);
				if (currentMethod != null) {
					ILexer lexer = ParserFactory.CreateLexer(language, currentMethod);
					Token token;
					InspectedCall call = new InspectedCall(Location.Empty, null);
					call.parent = call;
					while ((token = lexer.NextToken()) != null
					       && token.Kind != eofToken
					       && token.Location < cursorLocation)
					{
						if (token.Kind == commaToken) {
							call.commas.Add(token.Location);
						} else if (token.Kind == openParensToken || token.Kind == openBracketToken || token.Kind == openBracesToken) {
							call = new InspectedCall(token.Location, call);
						} else if (token.Kind == closeParensToken || token.Kind == closeBracketToken || token.Kind == closeBracesToken) {
							call = call.parent;
						}
					}
					int offset = LocationToOffset(editor, call.start);
					if (offset >= 0 && offset < editor.Document.TextLength) {
						char c = editor.Document.GetCharAt(offset);
						if (c == '(') {
							ShowInsight(editor,
							            new MethodInsightDataProvider(offset, true),
							            ResolveCallParameters(editor, call),
							            ch);
							return true;
						} else if (c == '[') {
							ShowInsight(editor,
							            new IndexerInsightDataProvider(offset, true),
							            ResolveCallParameters(editor, call),
							            ch);
							return true;
						} else {
							LoggingService.Warn("Expected '(' or '[' at start position");
						}
					}
				}
			}
			return false;
		}
コード例 #33
0
		public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			CSharpExpressionFinder ef = new CSharpExpressionFinder(editor.FileName);
			int cursor = editor.ActiveTextAreaControl.Caret.Offset;
			ExpressionContext context = null;
			if (ch == '(') {
				if (CodeCompletionOptions.KeywordCompletionEnabled) {
					switch (editor.GetWordBeforeCaret().Trim()) {
						case "for":
						case "lock":
							context = ExpressionContext.Default;
							break;
						case "using":
							context = ExpressionContext.TypeDerivingFrom(ParserService.CurrentProjectContent.GetClass("System.IDisposable"), false);
							break;
						case "catch":
							context = ExpressionContext.TypeDerivingFrom(ParserService.CurrentProjectContent.GetClass("System.Exception"), false);
							break;
						case "foreach":
						case "typeof":
						case "sizeof":
						case "default":
							context = ExpressionContext.Type;
							break;
					}
				}
				if (context != null) {
					if (IsInComment(editor)) return false;
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ch);
					return true;
				} else if (EnableMethodInsight && CodeCompletionOptions.InsightEnabled) {
					editor.ShowInsightWindow(new MethodInsightDataProvider());
					return true;
				}
				return false;
			} else if (ch == '[') {
				LineSegment line = editor.Document.GetLineSegmentForOffset(cursor);
				if (TextUtilities.FindPrevWordStart(editor.Document, cursor) <= line.Offset) {
					// [ is first character on the line
					// -> Attribute completion
					editor.ShowCompletionWindow(new AttributesDataProvider(ParserService.CurrentProjectContent), ch);
					return true;
				}
			} else if (ch == ',' && CodeCompletionOptions.InsightRefreshOnComma && CodeCompletionOptions.InsightEnabled) {
				if (InsightRefreshOnComma(editor, ch))
					return true;
			} else if(ch == '=') {
				LineSegment curLine = editor.Document.GetLineSegmentForOffset(cursor);
				string documentText = editor.Text;
				int position = editor.ActiveTextAreaControl.Caret.Offset - 2;
				
				if (position > 0 && (documentText[position + 1] == '+')) {
					ExpressionResult result = ef.FindFullExpression(documentText, position);
					
					if(result.Expression != null) {
						ResolveResult resolveResult = ParserService.Resolve(result, editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1, editor.FileName, documentText);
						if (resolveResult != null && resolveResult.ResolvedType != null) {
							IClass underlyingClass = resolveResult.ResolvedType.GetUnderlyingClass();
							if (underlyingClass != null && underlyingClass.IsTypeInInheritanceTree(ParserService.CurrentProjectContent.GetClass("System.MulticastDelegate"))) {
								EventHandlerCompletitionDataProvider eventHandlerProvider = new EventHandlerCompletitionDataProvider(result.Expression, resolveResult);
								eventHandlerProvider.InsertSpace = true;
								editor.ShowCompletionWindow(eventHandlerProvider, ch);
							}
						}
					}
				} else if (position > 0) {
					ExpressionResult result = ef.FindFullExpression(documentText, position);
					
					if(result.Expression != null) {
						ResolveResult resolveResult = ParserService.Resolve(result, editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1, editor.FileName, documentText);
						if (resolveResult != null && resolveResult.ResolvedType != null) {
							if (ProvideContextCompletion(editor, resolveResult.ResolvedType, ch)) {
								return true;
							}
						}
					}
				}
			} else if (ch == ';') {
				LineSegment curLine = editor.Document.GetLineSegmentForOffset(cursor);
				// don't return true when inference succeeds, otherwise the ';' won't be added to the document.
				TryDeclarationTypeInference(editor, curLine);
			}
			
			return base.HandleKeyPress(editor, ch);
		}
コード例 #34
0
		public QuickClassBrowserPanel(SharpDevelopTextAreaControl textAreaControl)
		{
			InitializeComponent();
			this.membersComboBox.MaxDropDownItems = 20;
			
			base.Dock = DockStyle.Top;
			this.textAreaControl = textAreaControl;
			this.textAreaControl.ActiveTextAreaControl.Caret.PositionChanged += new EventHandler(CaretPositionChanged);
		}
コード例 #35
0
		/// <summary>
		/// Determines if the specified character should trigger resource resolve attempt and possibly code completion at the current position.
		/// </summary>
		protected override bool CompletionPossible(SharpDevelopTextAreaControl editor, char ch)
		{
			return ch == '(' || ch == '[';
		}
コード例 #36
0
		public virtual bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
		{
			// DefaultCodeCompletionBinding does not support Keyword handling, but this
			// method can be overridden
			return false;
		}
コード例 #37
0
        public virtual bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
        {
            switch (ch)
            {
            case '(':
                if (enableMethodInsight && CodeCompletionOptions.InsightEnabled)
                {
                    editor.ShowInsightWindow(new MethodInsightDataProvider());
                    return(true);
                }
                else
                {
                    return(false);
                }

            case '[':
                if (enableIndexerInsight && CodeCompletionOptions.InsightEnabled)
                {
                    editor.ShowInsightWindow(new IndexerInsightDataProvider());
                    return(true);
                }
                else
                {
                    return(false);
                }

            case '<':
                if (enableXmlCommentCompletion)
                {
                    editor.ShowCompletionWindow(new CommentCompletionDataProvider(), ch);
                    return(true);
                }
                else
                {
                    return(false);
                }

            case '.':
                if (enableDotCompletion)
                {
                    editor.ShowCompletionWindow(new CodeCompletionDataProvider(), ch);
                    return(true);
                }
                else
                {
                    return(false);
                }

            case ' ':
                if (!CodeCompletionOptions.KeywordCompletionEnabled)
                {
                    return(false);
                }
                string word = editor.GetWordBeforeCaret();
                if (word != null)
                {
                    return(HandleKeyword(editor, word));
                }
                else
                {
                    return(false);
                }

            default:
                return(false);
            }
        }
コード例 #38
0
		public override bool HandleKeyPress(SharpDevelopTextAreaControl editor, char ch)
		{
			CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName);
			int cursor = editor.ActiveTextAreaControl.Caret.Offset;
			ExpressionContext context = null;
			if (ch == '(') {
				if (context != null) {
					if (IsInComment(editor)) return false;
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ch);
					return true;
				} else if (EnableMethodInsight && CodeCompletionOptions.InsightEnabled) {
					editor.ShowInsightWindow(new MethodInsightDataProvider());
					return true;
				}
				return false;
			} else if (ch == '[') {
				LineSegment line = editor.Document.GetLineSegmentForOffset(cursor);
				if (TextUtilities.FindPrevWordStart(editor.Document, cursor) <= line.Offset) {
					// [ is first character on the line
					// -> Attribute completion
					editor.ShowCompletionWindow(new AttributesDataProvider(ParserService.CurrentProjectContent), ch);
					return true;
				}
			} else if (ch == ',' && CodeCompletionOptions.InsightRefreshOnComma && CodeCompletionOptions.InsightEnabled) {
				if (InsightRefreshOnComma(editor, ch))
					return true;
			} else if(ch == '=') {
				LineSegment curLine = editor.Document.GetLineSegmentForOffset(cursor);
				string documentText = editor.Text;
				int position = editor.ActiveTextAreaControl.Caret.Offset - 2;
				
				if (position > 0 && (documentText[position + 1] == '+')) {
					ExpressionResult result = ef.FindFullExpression(documentText, position);
					
					if(result.Expression != null) {
						ResolveResult resolveResult = ParserService.Resolve(result, editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1, editor.FileName, documentText);
						if (resolveResult != null && resolveResult.ResolvedType != null) {
							IClass underlyingClass = resolveResult.ResolvedType.GetUnderlyingClass();
							if (underlyingClass != null && underlyingClass.IsTypeInInheritanceTree(ParserService.CurrentProjectContent.GetClass("System.MulticastDelegate", 0))) {
								EventHandlerCompletitionDataProvider eventHandlerProvider = new EventHandlerCompletitionDataProvider(result.Expression, resolveResult);
								eventHandlerProvider.InsertSpace = true;
								editor.ShowCompletionWindow(eventHandlerProvider, ch);
							}
						}
					}
				} else if (position > 0) {
					ExpressionResult result = ef.FindFullExpression(documentText, position);
					
					if(result.Expression != null) {
						ResolveResult resolveResult = ParserService.Resolve(result, editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1, editor.FileName, documentText);
						if (resolveResult != null && resolveResult.ResolvedType != null) {
							if (ProvideContextCompletion(editor, resolveResult.ResolvedType, ch)) {
								return true;
							}
						}
					}
				}
			} else if (ch == '.') {
				editor.ShowCompletionWindow(new CSharpCodeCompletionDataProvider(), ch);
				return true;
			} else if (ch == '>') {
				if (IsInComment(editor)) return false;
				char prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
				if (prevChar == '-') {
					editor.ShowCompletionWindow(new PointerArrowCompletionDataProvider(), ch);
					
					return true;
				}
			}
			
			if (char.IsLetter(ch) && CodeCompletionOptions.CompleteWhenTyping) {
				if (editor.ActiveTextAreaControl.SelectionManager.HasSomethingSelected) {
					// allow code completion when overwriting an identifier
					cursor = editor.ActiveTextAreaControl.SelectionManager.SelectionCollection[0].Offset;
					int endOffset = editor.ActiveTextAreaControl.SelectionManager.SelectionCollection[0].EndOffset;
					// but block code completion when overwriting only part of an identifier
					if (endOffset < editor.Document.TextLength && char.IsLetterOrDigit(editor.Document.GetCharAt(endOffset)))
						return false;
					editor.ActiveTextAreaControl.SelectionManager.RemoveSelectedText();
					editor.ActiveTextAreaControl.Caret.Position = editor.Document.OffsetToPosition(cursor);
				}
				char prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
				bool afterUnderscore = prevChar == '_';
				if (afterUnderscore) {
					cursor--;
					prevChar = cursor > 1 ? editor.Document.GetCharAt(cursor - 1) : ' ';
				}
				if (!char.IsLetterOrDigit(prevChar) && prevChar != '.' && !IsInComment(editor)) {
					ExpressionResult result = ef.FindExpression(editor.Text, cursor);
					LoggingService.Debug("CC: Beginning to type a word, result=" + result);
					if (result.Context != ExpressionContext.IdentifierExpected) {
						editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(result.Context) {
						                            	ShowTemplates = true,
						                            	AllowCompleteExistingExpression = afterUnderscore
						                            }, '\0');
					}
				}
			}
			
			return base.HandleKeyPress(editor, ch);
		}
コード例 #39
0
		bool TryDeclarationTypeInference(SharpDevelopTextAreaControl editor, LineSegment curLine)
		{
			string lineText = editor.Document.GetText(curLine.Offset, curLine.Length);
			ILexer lexer = ParserFactory.CreateLexer(SupportedLanguage.CSharp, new System.IO.StringReader(lineText));
			Token typeToken = lexer.NextToken();
			if (typeToken.kind == CSTokens.Question) {
				if (lexer.NextToken().kind == CSTokens.Identifier) {
					Token t = lexer.NextToken();
					if (t.kind == CSTokens.Assign) {
						string expr = lineText.Substring(t.col);
						LoggingService.Debug("DeclarationTypeInference: >" + expr + "<");
						ResolveResult rr = ParserService.Resolve(new ExpressionResult(expr),
						                                         editor.ActiveTextAreaControl.Caret.Line + 1,
						                                         t.col, editor.FileName,
						                                         editor.Document.TextContent);
						if (rr != null && rr.ResolvedType != null) {
							ClassFinder context = new ClassFinder(editor.FileName, editor.ActiveTextAreaControl.Caret.Line, t.col);
							if (CodeGenerator.CanUseShortTypeName(rr.ResolvedType, context))
								CSharpAmbience.Instance.ConversionFlags = ConversionFlags.None;
							else
								CSharpAmbience.Instance.ConversionFlags = ConversionFlags.UseFullyQualifiedNames;
							string typeName = CSharpAmbience.Instance.Convert(rr.ResolvedType);
							editor.Document.Replace(curLine.Offset + typeToken.col - 1, 1, typeName);
							editor.ActiveTextAreaControl.Caret.Column += typeName.Length - 1;
							return true;
						}
					}
				}
			}
			return false;
		}
コード例 #40
0
		bool IsInComment(SharpDevelopTextAreaControl editor)
		{
			CSharpExpressionFinder ef = new CSharpExpressionFinder(editor.FileName);
			int cursor = editor.ActiveTextAreaControl.Caret.Offset - 1;
			return ef.FilterComments(editor.Document.GetText(0, cursor + 1), ref cursor) == null;
		}
コード例 #41
0
		public override bool HandleKeyword(SharpDevelopTextAreaControl editor, string word)
		{
			// TODO: Assistance writing Methods/Fields/Properties/Events:
			// use public/static/etc. as keywords to display a list with other modifiers
			// and possible return types.
			switch (word) {
				case "using":
					if (IsInComment(editor)) return false;
					
					// TODO: check if we are inside class/namespace
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Namespace), ' ');
					return true;
				case "as":
				case "is":
					if (IsInComment(editor)) return false;
					editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(ExpressionContext.Type), ' ');
					return true;
				case "override":
					if (IsInComment(editor)) return false;
					editor.ShowCompletionWindow(new OverrideCompletionDataProvider(), ' ');
					return true;
				case "new":
					return ShowNewCompletion(editor);
				case "case":
					if (IsInComment(editor)) return false;
					return DoCaseCompletion(editor);
				case "return":
					if (IsInComment(editor)) return false;
					IMember m = GetCurrentMember(editor);
					if (m != null) {
						return ProvideContextCompletion(editor, m.ReturnType, ' ');
					} else {
						goto default;
					}
				default:
					return base.HandleKeyword(editor, word);
			}
		}
コード例 #42
0
		ExpressionContext FindExactContextForNewCompletion(SharpDevelopTextAreaControl editor, string documentToCursor,
		                                                   LineSegment currentLine, int pos)
		{
			CSharpExpressionFinder ef = CreateExpressionFinder(editor.FileName);
			// find expression on left hand side of the assignment
			ExpressionResult lhsExpr = ef.FindExpression(documentToCursor, currentLine.Offset + pos);
			if (lhsExpr.Expression != null) {
				ResolveResult rr = ParserService.Resolve(lhsExpr, currentLine.LineNumber, pos, editor.FileName, editor.Text);
				if (rr != null && rr.ResolvedType != null) {
					ExpressionContext context;
					IClass c;
					if (rr.ResolvedType.IsArrayReturnType) {
						// when creating an array, all classes deriving from the array's element type are allowed
						IReturnType elementType = rr.ResolvedType.CastToArrayReturnType().ArrayElementType;
						c = elementType != null ? elementType.GetUnderlyingClass() : null;
						context = ExpressionContext.TypeDerivingFrom(elementType, false);
					} else {
						// when creating a normal instance, all non-abstract classes deriving from the type
						// are allowed
						c = rr.ResolvedType.GetUnderlyingClass();
						context = ExpressionContext.TypeDerivingFrom(rr.ResolvedType, true);
					}
					if (c != null && context.ShowEntry(c)) {
						// Try to suggest an entry (List<int> a = new => suggest List<int>).
						
						string suggestedClassName = LanguageProperties.CSharp.CodeGenerator.GenerateCode(
							CodeGenerator.ConvertType(
								rr.ResolvedType,
								new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.ActiveTextAreaControl.Caret.Line + 1, editor.ActiveTextAreaControl.Caret.Column + 1)
							), "");
						if (suggestedClassName != c.Name) {
							// create an IClass instance that includes the type arguments in its name
							context.SuggestedItem = new RenamedClass(c, suggestedClassName);
						} else {
							context.SuggestedItem = c;
						}
					}
					return context;
				}
			}
			return null;
		}
コード例 #43
0
		bool ShowNewCompletion(SharpDevelopTextAreaControl editor)
		{
			CSharpExpressionFinder ef = new CSharpExpressionFinder(editor.FileName);
			int cursor = editor.ActiveTextAreaControl.Caret.Offset;
			ExpressionContext context = ef.FindExpression(editor.Document.GetText(0, cursor) + " T.", cursor + 2).Context;
			if (context.IsObjectCreation) {
				editor.ShowCompletionWindow(new CtrlSpaceCompletionDataProvider(context), ' ');
				return true;
			}
			return false;
		}
コード例 #44
0
		protected int LocationToOffset(SharpDevelopTextAreaControl editor, Location loc)
		{
			if (loc.IsEmpty || loc.Line - 1 >= editor.Document.TotalNumberOfLines)
				return -1;
			LineSegment seg = editor.Document.GetLineSegment(loc.Line - 1);
			return seg.Offset + Math.Min(loc.Column, seg.Length) - 1;
		}
		// ********************************************************************************************************************************
		
		/// <summary>
		/// Determines if the specified character should trigger resource resolve attempt and possibly code completion at the current position.
		/// </summary>
		protected abstract bool CompletionPossible(SharpDevelopTextAreaControl editor, char ch);