private int findCodeConstructStartLine(int startLine) {
  DocumentEx document = myEditor.getDocument();
  CharSequence text = document.getImmutableCharSequence();
  int lineStartOffset = document.getLineStartOffset(startLine);
  int firstNonWsOffset = CharArrayUtil.shiftForward(text, lineStartOffset, " \t");
  FileType type = PsiUtilBase.getPsiFileAtOffset(myFile, firstNonWsOffset).getFileType();
  Language language = PsiUtilCore.getLanguageAtOffset(myFile, firstNonWsOffset);
  BraceMatcher braceMatcher = BraceMatchingUtil.getBraceMatcher(type, language);
  HighlighterIterator iterator = myEditor.getHighlighter().createIterator(firstNonWsOffset);
  if (braceMatcher.isLBraceToken(iterator, text, type)) {
    int codeConstructStart = braceMatcher.getCodeConstructStart(myFile, firstNonWsOffset);
    return document.getLineNumber(codeConstructStart);
  }
  else {
    return startLine;
  }
}
 

private int findCodeConstructStartLine(int startLine) {
  DocumentEx document = myEditor.getDocument();
  CharSequence text = document.getImmutableCharSequence();
  int lineStartOffset = document.getLineStartOffset(startLine);
  int firstNonWsOffset = CharArrayUtil.shiftForward(text, lineStartOffset, " \t");
  FileType type = PsiUtilBase.getPsiFileAtOffset(myFile, firstNonWsOffset).getFileType();
  Language language = PsiUtilCore.getLanguageAtOffset(myFile, firstNonWsOffset);
  BraceMatcher braceMatcher = BraceMatchingUtil.getBraceMatcher(type, language);
  HighlighterIterator iterator = myEditor.getHighlighter().createIterator(firstNonWsOffset);
  if (braceMatcher.isLBraceToken(iterator, text, type)) {
    int codeConstructStart = braceMatcher.getCodeConstructStart(myFile, firstNonWsOffset);
    return document.getLineNumber(codeConstructStart);
  }
  else {
    return startLine;
  }
}
 

@Override
public void actionPerformedImpl(@NotNull final Project project, final Editor editor) {
    PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
    if(file == null) {
        return;
    }

    int offset = editor.getCaretModel().getOffset();
    PsiElement psiElement = file.findElementAt(offset);
    if(psiElement == null) {
        return;
    }

    PsiMethodCallExpression psiMethodCallExpression = PsiTreeUtil.getParentOfType(psiElement, PsiMethodCallExpression.class);
    if(psiMethodCallExpression == null) {
        return;
    }

    PsiFile xmlFile = matchInflate(psiMethodCallExpression);
    generate(psiMethodCallExpression, xmlFile, editor, file);
}
 

@Override
public void actionPerformedImpl(@NotNull final Project project, final Editor editor) {
    PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
    if(file == null) {
        return;
    }

    int offset = editor.getCaretModel().getOffset();
    PsiElement psiElement = file.findElementAt(offset);
    if(psiElement == null) {
        return;
    }

    PsiLocalVariable psiLocalVariable = PsiTreeUtil.getParentOfType(psiElement, PsiLocalVariable.class);
    InflateViewAnnotator.InflateContainer inflateContainer = InflateViewAnnotator.matchInflate(psiLocalVariable);
    if(inflateContainer == null) {
        return;
    }

    generate(inflateContainer, editor, file);
}
 

private boolean propertiesHandling(Editor editor, DataContext dataContext, SelectionModel selectionModel,
		PsiFile psiFile) {
	PsiElement elementAtCaret = PsiUtilBase.getElementAtCaret(editor);
	if (elementAtCaret instanceof PsiWhiteSpace) {
		return false;
	} else if (elementAtCaret instanceof LeafPsiElement) {
		IElementType elementType = ((LeafPsiElement) elementAtCaret).getElementType();
		if (elementType.toString().equals("Properties:VALUE_CHARACTERS")
				|| elementType.toString().equals("Properties:KEY_CHARACTERS")) {
			TextRange textRange = elementAtCaret.getTextRange();
			if (textRange.getLength() == 0) {
				return super.selectSomethingUnderCaret(editor, dataContext, selectionModel);
			}
			selectionModel.setSelection(textRange.getStartOffset(), textRange.getEndOffset());
			return true;
		}
	}
	return false;
}
 

private boolean invokePhpClass(Project project, Editor editor) {

        PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
        if(file == null) {
            return false;
        }

        int offset = editor.getCaretModel().getOffset();
        if(offset <= 0) {
            return false;
        }

        PsiElement psiElement = file.findElementAt(offset);
        if(psiElement == null) {
            return false;
        }

        PhpClass phpClass = PsiTreeUtil.getParentOfType(psiElement, PhpClass.class);
        if(phpClass == null) {
            return false;
        }

        invokeServiceGenerator(project, file, phpClass, editor);

        return true;
    }
 

public void format(PsiFile psiFile, int startOffset, int endOffset) throws FileDoesNotExistsException {
	LOG.debug("#format " + startOffset + "-" + endOffset);
	boolean wholeFile = FileUtils.isWholeFile(startOffset, endOffset, psiFile.getText());
	Range range = new Range(startOffset, endOffset, wholeFile);

	final Editor editor = PsiUtilBase.findEditor(psiFile);
	if (editor != null) {
		TemplateState templateState = TemplateManagerImpl.getTemplateState(editor);
		if (templateState != null && !settings.isUseForLiveTemplates()) {
			throw new ReformatItInIntelliJ();
		}
		formatWhenEditorIsOpen(editor, range, psiFile);
	} else {
		formatWhenEditorIsClosed(range, psiFile);
	}
	               
}
 

protected boolean shouldSkipFormatting(PsiFile psiFile, Collection<TextRange> textRanges) {
	VirtualFile virtualFile = psiFile.getVirtualFile();

	if (settings.isFormatSeletedTextInAllFileTypes()) {             
		// when file is being edited, it is important to load text from editor, i think
		final Editor editor = PsiUtilBase.findEditor(psiFile);
		if (editor != null) {
			Document document = editor.getDocument();
			String text = document.getText();
			if (!FileUtils.isWholeFile(textRanges, text)) {
				return false;
			}
		}
	}
	//not else
	if (settings.isFormatOtherFileTypesWithIntelliJ()) {
		return isDisabledFileType(virtualFile);
	}
	return true;
}
 

@Override
	public boolean isInContext(@NotNull PsiFile file, int offset) {
		// offset is where cursor or insertion point is I guess
		if ( !PsiUtilBase.getLanguageAtOffset(file, offset).isKindOf(ANTLRv4Language.INSTANCE) ) {
			return false;
		}
		if ( offset==file.getTextLength() ) { // allow at EOF
			offset--;
		}
		PsiElement element = file.findElementAt(offset);

//		String trace = DebugUtil.currentStackTrace();
//		System.out.println("isInContext: element " + element +", text="+element.getText());
//		System.out.println(trace);

		if ( element==null ) {
			return false;
		}

		return isInContext(file, element, offset);
	}
 

@Override
public void actionPerformedImpl(Project project, Editor editor) {
    PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
    PsiFile layout = Utils.getLayoutFileFromCaret(editor, file);

    if (layout == null) {
        Utils.showErrorNotification(project, "No layout found");
        return; // no layout found
    }

    log.info("Layout file: " + layout.getVirtualFile());

    ArrayList<Element> elements = Utils.getIDsFromLayout(layout);
    if (!elements.isEmpty()) {
        showDialog(project, editor, elements);
    } else {
        Utils.showErrorNotification(project, "No IDs found in layout");
    }
}
 

public void onConfirm(Project project, Editor editor, ArrayList<Element> elements, String fieldNamePrefix, boolean createHolder, boolean splitOnclickMethods) {
    PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
    if (file == null) {
        return;
    }
    PsiFile layout = Utils.getLayoutFileFromCaret(editor, file);

    closeDialog();


    if (Utils.getInjectCount(elements) > 0 || Utils.getClickCount(elements) > 0) { // generate injections
        new InjectWriter(file, getTargetClass(editor, file), "Generate Injections", elements, layout.getName(), fieldNamePrefix, createHolder, splitOnclickMethods).execute();
    } else { // just notify user about no element selected
        Utils.showInfoNotification(project, "No injection was selected");
    }

}
 

@RequiredUIAccess
public void actionPerformedImpl(@Nonnull final Project project, final Editor editor) {
  if (editor == null) return;
  //final PsiFile psiFile = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
  final PsiFile psiFile = PsiUtilBase.getPsiFileInEditor(editor, project);
  if (psiFile == null) return;
  final CodeInsightActionHandler handler = getHandler();
  PsiElement elementToMakeWritable = handler.getElementToMakeWritable(psiFile);
  if (elementToMakeWritable != null && !(EditorModificationUtil.checkModificationAllowed(editor) && FileModificationService.getInstance().preparePsiElementsForWrite(elementToMakeWritable))) {
    return;
  }

  CommandProcessor.getInstance().executeCommand(project, () -> {
    final Runnable action = () -> {
      if (!ApplicationManager.getApplication().isHeadlessEnvironment() && !editor.getContentComponent().isShowing()) return;
      handler.invoke(project, editor, psiFile);
    };
    if (handler.startInWriteAction()) {
      ApplicationManager.getApplication().runWriteAction(action);
    }
    else {
      action.run();
    }
  }, getCommandName(), DocCommandGroupId.noneGroupId(editor.getDocument()), editor.getDocument());
}
 

@RequiredUIAccess
@Override
public void update(@Nonnull AnActionEvent e) {
  Presentation presentation = e.getPresentation();

  Project project = e.getProject();
  if (project == null) {
    presentation.setEnabled(false);
    return;
  }

  final DataContext dataContext = e.getDataContext();
  Editor editor = getEditor(dataContext, project, true);
  if (editor == null) {
    presentation.setEnabled(false);
    return;
  }

  final PsiFile file = PsiUtilBase.getPsiFileInEditor(editor, project);
  if (file == null) {
    presentation.setEnabled(false);
    return;
  }

  update(presentation, project, editor, file, dataContext, e.getPlace());
}
 

@Override
public Collection<AbstractTreeNode> getChildrenImpl() {
  VirtualFile ourVirtualFile = getVirtualFile();
  if(ourVirtualFile == null) {
    return super.getChildrenImpl();
  }
  BackgroundTaskByVfsChangeManager vfsChangeManager = BackgroundTaskByVfsChangeManager.getInstance(getProject());
  List<BackgroundTaskByVfsChangeTask> tasks = vfsChangeManager.findTasks(ourVirtualFile);
  if(tasks.isEmpty()) {
    return super.getChildrenImpl();
  }
  List<VirtualFile> generatedFiles = new ArrayList<VirtualFile>();
  for (BackgroundTaskByVfsChangeTask task : tasks) {
    Collections.addAll(generatedFiles, task.getGeneratedFiles());
  }
  if(generatedFiles.isEmpty()) {
    return super.getChildrenImpl();
  }
  PsiFile[] psiFiles = PsiUtilBase.virtualToPsiFiles(generatedFiles, myProject);
  List<AbstractTreeNode> newChildren = new ArrayList<AbstractTreeNode>(psiFiles.length);
  for (PsiFile psiFile : psiFiles) {
    newChildren.add(new PsiFileNode(getProject(), psiFile, getSettings()));
  }
  return newChildren;
}
 

private static WatchingInsertionContext callHandleInsert(CompletionProgressIndicator indicator, LookupElement item, char completionChar) {
  final Editor editor = indicator.getEditor();

  final int caretOffset = indicator.getCaret().getOffset();
  final int idEndOffset = calcIdEndOffset(indicator);
  PsiFile psiFile = PsiUtilBase.getPsiFileInEditor(editor, indicator.getProject());

  WatchingInsertionContext context = createInsertionContext(indicator.getLookup(), item, completionChar, editor, psiFile, caretOffset, idEndOffset, indicator.getOffsetMap());
  try {
    item.handleInsert(context);
  }
  finally {
    context.stopWatching();
  }
  return context;
}
 

private void repaintTrafficIcon(@Nonnull final PsiFile file, @Nullable Editor editor, double progress) {
  if (ApplicationManager.getApplication().isCommandLine()) return;

  if (repaintIconAlarm.isEmpty() || progress >= 1) {
    repaintIconAlarm.addRequest(() -> {
      Project myProject = file.getProject();
      if (myProject.isDisposed()) return;
      Editor myeditor = editor;
      if (myeditor == null) {
        myeditor = PsiUtilBase.findEditor(file);
      }
      if (myeditor != null && !myeditor.isDisposed()) {
        repaintErrorStripeAndIcon(myeditor, myProject);
      }
    }, 50, null);
  }
}
 

public void setHighlightingSettingForRoot(@Nonnull PsiElement root, @Nonnull FileHighlightingSetting setting) {
  final PsiFile containingFile = root.getContainingFile();
  final VirtualFile virtualFile = containingFile.getVirtualFile();
  if (virtualFile == null) return;
  FileHighlightingSetting[] defaults = myHighlightSettings.get(virtualFile);
  int rootIndex = PsiUtilBase.getRootIndex(root);
  if (defaults != null && rootIndex >= defaults.length) defaults = null;
  if (defaults == null) defaults = getDefaults(containingFile);
  defaults[rootIndex] = setting;
  boolean toRemove = true;
  for (FileHighlightingSetting aDefault : defaults) {
    if (aDefault != FileHighlightingSetting.NONE) toRemove = false;
  }
  if (toRemove) {
    myHighlightSettings.remove(virtualFile);
  }
  else {
    myHighlightSettings.put(virtualFile, defaults);
  }

  myBus.syncPublisher(FileHighlightingSettingListener.SETTING_CHANGE).settingChanged(root, setting);
}
 

private static void iterateOverCarets(@Nonnull final Project project,
                                      @Nonnull final Editor hostEditor,
                                      @Nonnull final MultiCaretCodeInsightActionHandler handler) {
  PsiDocumentManager documentManager = PsiDocumentManager.getInstance(project);
  final PsiFile psiFile = documentManager.getCachedPsiFile(hostEditor.getDocument());
  documentManager.commitAllDocuments();

  hostEditor.getCaretModel().runForEachCaret(new CaretAction() {
    @Override
    public void perform(Caret caret) {
      Editor editor = hostEditor;
      if (psiFile != null) {
        Caret injectedCaret = InjectedLanguageUtil.getCaretForInjectedLanguageNoCommit(caret, psiFile);
        if (injectedCaret != null) {
          caret = injectedCaret;
          editor = caret.getEditor();
        }
      }
      final PsiFile file = PsiUtilBase.getPsiFileInEditor(caret, project);
      if (file != null) {
        handler.invoke(project, editor, caret, file);
      }
    }
  });
}
 

@Nullable
private static PsiFile getRoot(final PsiFile file, final Editor editor) {
  if (file == null) return null;
  int offset = editor.getCaretModel().getOffset();
  if (offset == editor.getDocument().getTextLength()) offset--;
  if (offset<0) return null;
  PsiElement leafElement = file.findElementAt(offset);
  if (leafElement == null) return null;
  if (leafElement.getLanguage() instanceof DependentLanguage) {
    leafElement = file.getViewProvider().findElementAt(offset, file.getViewProvider().getBaseLanguage());
    if (leafElement == null) return null;
  }
  ASTNode node = leafElement.getNode();
  if (node == null) return null;
  return (PsiFile)PsiUtilBase.getRoot(node).getPsi();
}
 

private void applyAction(@Nonnull IntentionActionWithTextCaching cachedAction) {
  myFinalRunnable = () -> {
    HintManager.getInstance().hideAllHints();
    if (myProject.isDisposed()) return;
    if (myEditor != null && (myEditor.isDisposed() || (!myEditor.getComponent().isShowing() && !ApplicationManager.getApplication().isUnitTestMode()))) return;

    if (DumbService.isDumb(myProject) && !DumbService.isDumbAware(cachedAction)) {
      DumbService.getInstance(myProject).showDumbModeNotification(cachedAction.getText() + " is not available during indexing");
      return;
    }

    PsiDocumentManager.getInstance(myProject).commitAllDocuments();

    PsiFile file = myEditor != null ? PsiUtilBase.getPsiFileInEditor(myEditor, myProject) : myFile;
    if (file == null) {
      return;
    }

    ShowIntentionActionsHandler.chooseActionAndInvoke(file, myEditor, cachedAction.getAction(), cachedAction.getText(), myProject);
  };
}
 

private static boolean isEnabled(DataContext dataContext) {
  Project project = dataContext.getData(CommonDataKeys.PROJECT);
  if (project == null) {
    return false;
  }

  Editor editor = dataContext.getData(PlatformDataKeys.EDITOR);
  if (editor == null) {
    UsageTarget[] target = dataContext.getData(UsageView.USAGE_TARGETS_KEY);
    return target != null && target.length > 0;
  }
  else {
    PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(editor.getDocument());
    if (file == null) {
      return false;
    }

    Language language = PsiUtilBase.getLanguageInEditor(editor, project);
    if (language == null) {
      language = file.getLanguage();
    }
    return !(LanguageFindUsages.INSTANCE.forLanguage(language) instanceof EmptyFindUsagesProvider);
  }
}
 

@Override
public void select(Object object, VirtualFile file, boolean requestFocus) {
  if (!(object instanceof PsiElement)) return;
  /*PsiElement element = (PsiElement)object;
  PsiFile psiFile = element.getContainingFile();
  if (psiFile != null) {
    element = psiFile;
  }

  if (element instanceof PsiJavaFile) {
    final PsiClass[] classes = ((PsiJavaFile)element).getClasses();
    if (classes.length > 0) {
      element = classes[0];
    }
  }

  final PsiElement originalElement = element.getOriginalElement();*/
  final VirtualFile virtualFile = PsiUtilBase.getVirtualFile((PsiElement)object);
  final String list = FavoritesViewSelectInTarget.findSuitableFavoritesList(virtualFile, myProject, getSubId());
  if (list == null) return;
  if (!list.equals(getSubId())) {
    ProjectView.getInstance(myProject).changeView(ID, list);
  }
  myViewPanel.selectElement(object, virtualFile, requestFocus);
}
 

@Override
public String getElementDescription(@Nonnull final PsiElement element, @Nonnull final ElementDescriptionLocation location) {
  if (location instanceof DeleteTypeDescriptionLocation) {
    final boolean plural = ((DeleteTypeDescriptionLocation)location).isPlural();
    final int count = plural ? 2 : 1;
    if (element instanceof PsiFileSystemItem && PsiUtilBase.isSymLink((PsiFileSystemItem)element)) {
      return IdeBundle.message("prompt.delete.symlink", count);
    }
    if (element instanceof PsiFile) {
      return IdeBundle.message("prompt.delete.file", count);
    }
    if (element instanceof PsiDirectory) {
      return IdeBundle.message("prompt.delete.directory", count);
    }
    if (!plural) {
      return LanguageFindUsages.INSTANCE.forLanguage(element.getLanguage()).getType(element);
    }
    return "elements";
  }
  return null;
}
 

@Nonnull
private PsiElement[] getSelectedPsiElements() {
  final TreePath[] treePaths = myTree.getSelectionPaths();
  if (treePaths != null) {
    Set<PsiElement> result = new HashSet<PsiElement>();
    for (TreePath path : treePaths) {
      PackageDependenciesNode node = (PackageDependenciesNode)path.getLastPathComponent();
      final PsiElement psiElement = node.getPsiElement();
      if (psiElement != null && psiElement.isValid()) {
        result.add(psiElement);
      }
    }
    return PsiUtilBase.toPsiElementArray(result);
  }
  return PsiElement.EMPTY_ARRAY;
}
 

@Override
public void deleteElement(@Nonnull DataContext dataContext) {
  List<PsiElement> allElements = Arrays.asList(getSelectedPsiElements());
  ArrayList<PsiElement> validElements = new ArrayList<PsiElement>();
  for (PsiElement psiElement : allElements) {
    if (psiElement != null && psiElement.isValid()) validElements.add(psiElement);
  }
  final PsiElement[] elements = PsiUtilBase.toPsiElementArray(validElements);

  LocalHistoryAction a = LocalHistory.getInstance().startAction(IdeBundle.message("progress.deleting"));
  try {
    DeleteHandler.deletePsiElement(elements, myProject);
  }
  finally {
    a.finish();
  }
}
 

public static PsiFile getCurrentEditFile(AnActionEvent anActionEvent) {
  PsiFile psiFile = anActionEvent.getData(CommonDataKeys.PSI_FILE);
  if (psiFile != null) {
    return psiFile;
  }

  Project project = anActionEvent.getProject();
  Editor editor = anActionEvent.getData(CommonDataKeys.EDITOR_EVEN_IF_INACTIVE);

  if (editor == null || project == null) {
    return null;
  }

  return PsiUtilBase.getPsiFileInEditor(editor, project);
}
 

/**
 * save the current change
 */
public static void pushPostponedChanges(PsiElement element) {
    Editor editor = PsiUtilBase.findEditor(element.getContainingFile());
    if (editor != null) {
        PsiDocumentManager.getInstance(element.getProject())
            .doPostponedOperationsAndUnblockDocument(editor.getDocument());
    }
}
 

@Override
public void actionPerformed(ActionEvent e) {
	Project project = event.getData(PlatformDataKeys.PROJECT);
	Editor editor = event.getData(PlatformDataKeys.EDITOR);
	PsiFile currentFile = PsiUtilBase.getPsiFileInEditor(editor, project);

	if (JavaFileType.INSTANCE != currentFile.getFileType())
		return;

	try {
		File outputZip = File.createTempFile(project.getName(), ".zip");
		VirtualFile file = buildTestProject(project, editor, currentFile);
		Module module = ProjectRootManager.getInstance(project).getFileIndex().getModuleForFile(file);
		Ziper ziper = new Ziper(outputZip.getAbsolutePath(), project);

		//sources folder
		buildSources(ziper, module);

		//Classpath
		buildClasspath(ziper, module);

		ProgressManager.getInstance().run(new NoPolTask(project, "NoPol is Fixing", outputZip.getAbsolutePath()));
		ziper.close();
		this.parent.close(0);
	} catch (IOException e1) {
		throw new RuntimeException(e1);
	}
}
 

/**
 * This method is responsible to add the current test case, if the current file is, otherwise it
 * it will send a empty array of String in that way nopol will run all tests cases
 * @param project
 * @param editor
 * @param currentFile
 * @return
 */
private VirtualFile buildTestProject(Project project, Editor editor, PsiFile currentFile) {
	VirtualFile file = PsiUtilBase.getPsiFileInEditor(editor, project).getVirtualFile();
	String fullQualifiedNameOfCurrentFile = ((PsiJavaFile) currentFile).getPackageName() + "." + currentFile.getName();
	fullQualifiedNameOfCurrentFile = fullQualifiedNameOfCurrentFile.substring(0, fullQualifiedNameOfCurrentFile.length() - JavaFileType.DEFAULT_EXTENSION.length() - 1);
	if (ProjectRootManager.getInstance(project).getFileIndex().isInTestSourceContent(file)) {
		nopolContext.setProjectTests(fullQualifiedNameOfCurrentFile.split(" "));
	} else {
		nopolContext.setProjectTests(new String[0]);// we will hit all the test case in the project
	}
	return file;
}
 

public void actionPerformed(AnActionEvent event) {
    Project project = event.getData(PlatformDataKeys.PROJECT);
    Editor editor = event.getData(PlatformDataKeys.EDITOR);
    PsiFile mFile = PsiUtilBase.getPsiFileInEditor(editor, project);
    PsiClass psiClass = getTargetClass(editor, mFile);
    JsonDialog jsonD = new JsonDialog(psiClass, mFile, project);
    jsonD.setClass(psiClass);
    jsonD.setFile(mFile);
    jsonD.setProject(project);
    jsonD.setSize(600, 400);
    jsonD.setLocationRelativeTo(null);
    jsonD.setVisible(true);

}