/* (non-JavaDoc) * Method declared in IAction. */ public final void run() { ITextSelection selection = getTextSelection(); ISourceRange newRange = getNewSelectionRange(createSourceRange(selection), null); // Check if new selection differs from current selection if (selection.getOffset() == newRange.getOffset() && selection.getLength() == newRange.getLength()) return; fEditor.selectAndReveal(newRange.getOffset(), newRange.getLength()); }
/** * Checks, whether giver selection is correct selection, or can be expanded to correct selection * region. As result will set this.actualSelection(Start|End) properly. In case of incorrect * selection, will return false. * * @param source * @param start * @param end * @return */ protected boolean checkSelection(String source, int start, int end) { if (start > end) { int x = start; start = end; end = x; } if (start + 1 == end) { ISourceRange range = RubySyntaxUtils.getEnclosingName(source, end); if (range != null) { this.actualSelectionStart = range.getOffset(); this.actualSelectionEnd = this.actualSelectionStart + range.getLength(); // return true; } ISourceRange range2 = RubySyntaxUtils.insideMethodOperator(source, end); if (range != null && (range2 == null || range2.getLength() < range.getLength())) return true; if (range2 != null) { this.actualSelectionStart = range2.getOffset(); this.actualSelectionEnd = this.actualSelectionStart + range2.getLength(); return true; } } else { if (start >= 0 && end < source.length()) { String str = source.substring(start, end + 1); if (RubySyntaxUtils.isRubyName(str)) { this.actualSelectionStart = start; this.actualSelectionEnd = end + 1; return true; } } } return false; }
public void update() { boolean enabled = false; ISourceReference ref = getSourceReference(); if (ref != null) { ISourceRange range; try { range = ref.getSourceRange(); enabled = range != null && range.getLength() > 0; } catch (ModelException e) { // enabled= false; } } setEnabled(enabled); }
private void printDefinition(StringBuffer buffer, String s, TypedDefinition typed) { buffer.append("<dd>"); // $NON-NLS-1$ if (s != null && s.length() != 0) { if (typed == TypedDefinition.NONE) { buffer.append(s); } else if (typed == TypedDefinition.PARAM) { final ISourceRange param = getParamRange(s); if (param != null) { if (param.getOffset() > 0) { buffer.append("<i>"); buffer.append(TextUtils.escapeHTML(s.substring(0, param.getOffset()))); buffer.append("</i>"); } buffer.append("<b>"); // $NON-NLS-1$ buffer.append( TextUtils.escapeHTML( s.substring(param.getOffset(), param.getOffset() + param.getLength()))); buffer.append("</b>"); // $NON-NLS-1$ buffer.append(s.substring(param.getOffset() + param.getLength())); } else { buffer.append(s); } } else { assert (typed == TypedDefinition.AUTO); int endOfType = skipTypeDefinition(s); if (endOfType > 0) { buffer.append("<i>"); buffer.append(TextUtils.escapeHTML(s.substring(0, endOfType))); buffer.append("</i>"); } buffer.append(s.substring(endOfType)); } } buffer.append("</dd>"); // $NON-NLS-1$ }
private boolean isCoveringFunction(IMethod fun, int offset) { try { ISourceRange sr = fun.getSourceRange(); int declOff = sr.getOffset(); int declLen = sr.getLength(); int declEnd = declOff + declLen; int start = fun.getNameRange().getOffset(); return start < offset && declEnd > offset; } catch (ModelException e) { throw new RuntimeException(e); } }
/** @see ISourceReference */ @Override public String getSource() throws ModelException { IOpenable openable = this.parent.getOpenableParent(); IBuffer buffer = openable.getBuffer(); if (buffer == null) { return null; } ISourceRange range = getSourceRange(); int offset = range.getOffset(); int length = range.getLength(); if (offset == -1 || length == 0) { return null; } try { return buffer.getText(offset, length); } catch (RuntimeException e) { return null; } }
/* * non java doc * * @see StructureSelectionAction#internalGetNewSelectionRange(ISourceRange, * ICompilationUnit, SelectionAnalyzer) */ public ISourceRange internalGetNewSelectionRange( ISourceRange oldSourceRange, ISourceReference sr, SelectionAnalyzer selAnalyzer) throws ModelException { if (oldSourceRange.getLength() == 0 && selAnalyzer.getLastCoveringNode() != null) { ASTNode previousNode = NextNodeAnalyzer.perform(oldSourceRange.getOffset(), selAnalyzer.getLastCoveringNode()); if (previousNode != null) return getSelectedNodeSourceRange(sr, previousNode); } org.eclipse.php.internal.core.ast.nodes.ASTNode first = selAnalyzer.getFirstSelectedNode(); if (first == null) return getLastCoveringNodeRange(oldSourceRange, sr, selAnalyzer); org.eclipse.php.internal.core.ast.nodes.ASTNode parent = first.getParent(); if (parent == null) return getLastCoveringNodeRange(oldSourceRange, sr, selAnalyzer); org.eclipse.php.internal.core.ast.nodes.ASTNode lastSelectedNode = selAnalyzer.getSelectedNodes()[selAnalyzer.getSelectedNodes().length - 1]; org.eclipse.php.internal.core.ast.nodes.ASTNode nextNode = getNextNode(parent, lastSelectedNode); if (nextNode == parent) return getSelectedNodeSourceRange(sr, first.getParent()); int offset = oldSourceRange.getOffset(); int end = Math.min(sr.getSourceRange().getLength(), nextNode.getEnd() - 1); return createSourceRange(offset, end); }
public ISourceRange getNewSelectionRange(ISourceRange oldSourceRange, IType[] types) { try { if (types == null) types = getTypes(); Integer[] offsetArray = createOffsetArray(types); if (offsetArray.length == 0) return oldSourceRange; Arrays.sort(offsetArray); Integer oldOffset = new Integer(oldSourceRange.getOffset()); int index = Arrays.binarySearch(offsetArray, oldOffset); if (fIsGotoNext) return createNewSourceRange(getNextOffset(index, offsetArray, oldOffset)); else return createNewSourceRange(getPreviousOffset(index, offsetArray, oldOffset)); } catch (ModelException e) { DLTKUIPlugin.log(e); // dialog would be too heavy here return oldSourceRange; } }
public IGoal[] init() { ClassVariableDeclarationGoal typedGoal = (ClassVariableDeclarationGoal) goal; IType[] types = typedGoal.getTypes(); if (types == null) { TypeContext context = (TypeContext) typedGoal.getContext(); types = PHPTypeInferenceUtils.getModelElements(context.getInstanceType(), context); } if (types == null) { return null; } IContext context = typedGoal.getContext(); IModelAccessCache cache = null; if (context instanceof IModelCacheContext) { cache = ((IModelCacheContext) context).getCache(); } String variableName = typedGoal.getVariableName(); final List<IGoal> subGoals = new LinkedList<IGoal>(); for (final IType type : types) { try { ITypeHierarchy hierarchy = null; if (cache != null) { hierarchy = cache.getSuperTypeHierarchy(type, null); } IField[] fields = PHPModelUtils.getTypeHierarchyField(type, hierarchy, variableName, true, null); Map<IType, IType> fieldDeclaringTypeSet = new HashMap<IType, IType>(); for (IField field : fields) { IType declaringType = field.getDeclaringType(); if (declaringType != null) { fieldDeclaringTypeSet.put(declaringType, type); ISourceModule sourceModule = declaringType.getSourceModule(); ModuleDeclaration moduleDeclaration = SourceParserUtil.getModuleDeclaration(sourceModule); TypeDeclaration typeDeclaration = PHPModelUtils.getNodeByClass(moduleDeclaration, declaringType); if (typeDeclaration != null && field instanceof SourceRefElement) { SourceRefElement sourceRefElement = (SourceRefElement) field; ISourceRange sourceRange = sourceRefElement.getSourceRange(); ClassDeclarationSearcher searcher = new ClassDeclarationSearcher( sourceModule, typeDeclaration, sourceRange.getOffset(), sourceRange.getLength(), null, type, declaringType); try { moduleDeclaration.traverse(searcher); if (searcher.getResult() != null) { subGoals.add(new ExpressionTypeGoal(searcher.getContext(), searcher.getResult())); } } catch (Exception e) { if (DLTKCore.DEBUG) { e.printStackTrace(); } } } } } if (subGoals.size() == 0) { getGoalFromStaticDeclaration(variableName, subGoals, type, null); } fieldDeclaringTypeSet.remove(type); if (subGoals.size() == 0 && !fieldDeclaringTypeSet.isEmpty()) { for (Iterator iterator = fieldDeclaringTypeSet.keySet().iterator(); iterator.hasNext(); ) { IType fieldDeclaringType = (IType) iterator.next(); getGoalFromStaticDeclaration( variableName, subGoals, fieldDeclaringType, fieldDeclaringTypeSet.get(fieldDeclaringType)); } } } catch (CoreException e) { if (DLTKCore.DEBUG) { e.printStackTrace(); } } } resolveMagicClassVariableDeclaration(types, variableName, cache); return subGoals.toArray(new IGoal[subGoals.size()]); }
/** * Adds the self function with the relevant data to the proposals array * * @param context * @param reporter * @throws BadLocationException */ protected void addSelf(AbstractCompletionContext context, ICompletionReporter reporter) throws BadLocationException { String prefix = context.getPrefix(); SourceRange replaceRange = getReplacementRange(context); if (CodeAssistUtils.startsWithIgnoreCase("self", prefix)) { if (!context.getCompletionRequestor().isContextInformationMode() || prefix.length() == 4) { // "self".length() String suffix = getSuffix(context); // get the class data for "self". In case of null, the self // function will not be added IType selfClassData = CodeAssistUtils.getSelfClassData(context.getSourceModule(), context.getOffset()); if (selfClassData != null) { try { IMethod ctor = null; for (IMethod method : selfClassData.getMethods()) { if (method.isConstructor()) { ctor = method; break; } } if (ctor != null) { ISourceRange sourceRange = selfClassData.getSourceRange(); FakeMethod ctorMethod = new FakeMethod( (ModelElement) selfClassData, "self", sourceRange.getOffset(), sourceRange.getLength(), sourceRange.getOffset(), sourceRange.getLength()) { public boolean isConstructor() throws ModelException { return true; } }; ctorMethod.setParameters(ctor.getParameters()); reporter.reportMethod(ctorMethod, suffix, replaceRange); } else { ISourceRange sourceRange = selfClassData.getSourceRange(); reporter.reportMethod( new FakeMethod( (ModelElement) selfClassData, "self", sourceRange.getOffset(), sourceRange.getLength(), sourceRange.getOffset(), sourceRange.getLength()), "()", replaceRange); } } catch (ModelException e) { PHPCorePlugin.log(e); } } } } }
private void generate( final List<GetterSetterEntry> entries, final int modifier, final boolean generateComments) throws Exception { ISourceModule source = type.getSourceModule(); String name = type.getElementName().replace("$", ""); StringBuffer buffer = new StringBuffer(name); buffer.replace(0, 1, Character.toString(Character.toUpperCase(name.charAt(0)))); name = buffer.toString(); ASTParser parser = ASTParser.newParser(source); parser.setSource(document.get().toCharArray()); Program program = parser.createAST(new NullProgressMonitor()); // program.recordModifications(); // AST ast = program.getAST(); ISourceRange range = type.getSourceRange(); ASTNode node = program.getElementAt(range.getOffset()); if (!(node instanceof ClassDeclaration)) { return; } char indentChar = FormatPreferencesSupport.getInstance().getIndentationChar(document); String indent = String.valueOf(indentChar); ClassDeclaration clazz = (ClassDeclaration) node; Block body = clazz.getBody(); List<Statement> bodyStatements = body.statements(); int end = bodyStatements.get(bodyStatements.size() - 1).getEnd(); if (insertFirst) { end = bodyStatements.get(0).getStart() - 1; } else if (insertAfter != null) { boolean found = false; for (IMethod method : type.getMethods()) { if (method == insertAfter) { ISourceRange r = method.getSourceRange(); end = r.getOffset() + r.getLength(); found = true; } } if (!found) { for (IField field : type.getFields()) { ISourceRange r = field.getSourceRange(); end = r.getOffset() + r.getLength() + 1; } } } lineDelim = TextUtilities.getDefaultLineDelimiter(document); String methods = ""; int i = 0; for (GetterSetterEntry entry : entries) { String code = ""; if (!entry.isGetter) { code = GetterSetterUtil.getSetterStub( entry.field, entry.getIdentifier(), entry.getType(), generateComments, modifier, indent); } else { code = GetterSetterUtil.getGetterStub( entry.field, entry.getIdentifier(), generateComments, modifier, indent); } code = lineDelim + code; String formatted = indentPattern(code, indent, lineDelim); if (i++ == 0) { formatted = lineDelim + formatted; } methods += formatted; } document.replace(end, 0, methods); Formatter formatter = new Formatter(); Region region = new Region(end, methods.length()); formatter.format(document, region); }