private void setupMetadataPanel(Project project,SimpletoolWindowPanel MetadataPanel) {
    RestClientService restClientService = ServiceManager.getService(project,RestClientService.class);
    SimpleNode MetadaTarootNode = new MetadataExplorerRootNode(project,restClientService,"Metadata");

    SimpleTree MetadataTree = new SimpleTree();
    SimpleTreeBuilder MetadataTreeBuilder = new SimpleTreeBuilder(MetadataTree,(DefaultTreeModel)MetadataTree.getModel(),new ExplorerTreeStructure(MetadaTarootNode),null);
    disposer.register(project,MetadataTreeBuilder);
    MetadataTree.addTreeExpansionListener(new ExplorerTreeExpansionListener(MetadataTreeBuilder));
    MetadataTree.setCellRenderer(new ExplorerCellRenderer());

    ActionToolbar toolbar = createtoolbar(MetadaTarootNode,MetadataTreeBuilder);
    toolbar.setTargetComponent(MetadataPanel);
    MetadataPanel.setToolbar(toolbar.getComponent());
    MetadataPanel.setContent(ScrollPaneFactory.createScrollPane(MetadataTree));

    MetadataTree.setShowsRootHandles(true);

}

private void setupToolingMetadataPanel(Project project,SimpletoolWindowPanel toolingMetadataPanel) {
    ToolingRestClientService toolingRestClientService = ServiceManager.getService(project,ToolingRestClientService.class);
    SimpleNode toolingMetadaTarootNode = new MetadataExplorerRootNode(project,toolingRestClientService," Tooling Metadata");

    SimpleTree toolingMetadataTree = new SimpleTree();
    SimpleTreeBuilder toolingMetadataTreeBuilder = new SimpleTreeBuilder(toolingMetadataTree,(DefaultTreeModel)toolingMetadataTree.getModel(),new ExplorerTreeStructure(toolingMetadaTarootNode),toolingMetadataTreeBuilder);
    toolingMetadataTree.addTreeExpansionListener(new ExplorerTreeExpansionListener(toolingMetadataTreeBuilder));
    toolingMetadataTree.setCellRenderer(new ExplorerCellRenderer());

    ActionToolbar toolbar = createtoolbar(toolingMetadaTarootNode,toolingMetadataTreeBuilder);
    toolbar.setTargetComponent(toolingMetadataPanel);
    toolingMetadataPanel.setToolbar(toolbar.getComponent());
    toolingMetadataPanel.setContent(ScrollPaneFactory.createScrollPane(toolingMetadataTree));

    toolingMetadataTree.setShowsRootHandles(true);

}

SeedStackStructure(Project project,SimpleTree tree) {
    this.project = project;

    tree.setRootVisible(true);
    tree.setShowsRootHandles(true);

    rootNode = new RootNode();
    treeBuilder = new SimpleTreeBuilder(tree,(DefaultTreeModel) tree.getModel(),this,null);
    disposer.register(this.project,treeBuilder);

    treeBuilder.initRoot();
}

public SourceItemsTree(ArtifactEditorContext editorContext,ArtifactEditorImpl artifactsEditor) {
  myArtifactsEditor = artifactsEditor;
  myBuilder = new SimpleTreeBuilder(this,this.getBuilderModel(),new SourceItemsTreeStructure(editorContext,artifactsEditor),new WeightBasedComparator(true));
  setRootVisible(false);
  setShowsRootHandles(true);
  disposer.register(this,myBuilder);
  PopupHandler.installPopupHandler(this,createPopupGroup(),ActionPlaces.UNKNowN,ActionManager.getInstance());
  installDnD();
}

public JahiaTreeStructure(Project project,SimpleTree tree) {
    tree.setRootVisible(false);
    tree.setShowsRootHandles(true);

    myTreeBuilder = new SimpleTreeBuilder(tree,(DefaultTreeModel)tree.getModel(),myTreeBuilder);

    myRoot = new RootNode(project);
    myTreeBuilder.expand(myRoot,null);
    myTreeBuilder.initRoot();
}

/**
 * Populates table with appropriate metrics
 *
 * @param testRun - testRun to display inside the table
 */
public void setTestRun(TestRun testRun) {
    //setup presentation
    TestRunNode node = new TestRunNode(testRun);
    this.model.setRoot(new DefaultMutableTreeNode(node));
    final SimpleTreeStructure treeStructure = new SimpleTreeStructure.Impl(node);
    this.treeBuilder = new SimpleTreeBuilder(this.tree.getTree(),this.model,treeStructure,null);
    disposer.register(this,this.treeBuilder);

    this.treeBuilder.expand(treeStructure.getRootElement(),() -> this.expandFailing(treeStructure,treeStructure.getRootElement()));

    this.treeBuilder.initRoot();
}

public SourceItemsTree(ArtifactEditorContext editorContext,ActionManager.getInstance());
  installDnD();
}

private void setupDataSplitPane(Project project) {
    RestClientService restClientService = ServiceManager.getService(project,RestClientService.class);
    SimpleNode daTarootNode = new DataExplorerRootNode(project,"sObjects");

    SimpleTree dataTree = new SimpleTree();
    dataTree.setShowsRootHandles(true);
    SimpleTreeBuilder dataTreeBuilder = new SimpleTreeBuilder(dataTree,(DefaultTreeModel) dataTree.getModel(),new ExplorerTreeStructure(daTarootNode),dataTreeBuilder);
    dataTree.addTreeExpansionListener(new ExplorerTreeExpansionListener(dataTreeBuilder));
    dataTree.setCellRenderer(new ExplorerCellRenderer());
    JBTable dataTable = new JBTable();
    dataTable.setStriped(true);
    dataTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

    // Setup left panel which will display all the available sObjects
    SimpletoolWindowPanel treePanel = new SimpletoolWindowPanel(true,true);
    ActionToolbar treetoolbar = createTreetoolbar(daTarootNode,dataTreeBuilder);
    treetoolbar.setTargetComponent(treePanel);
    treePanel.setToolbar(treetoolbar.getComponent());
    treePanel.setContent(ScrollPaneFactory.createScrollPane(dataTree));
    dataSplitPane.add(treePanel,JSplitPane.LEFT);

    // Setup right panel which will display the data in the selected sObject
    SimpletoolWindowPanel dataPanel = new SimpletoolWindowPanel(true,true);
    ActionToolbar dataToolbar = createDataToolbar(dataTable);
    dataToolbar.setTargetComponent(dataPanel);
    dataPanel.setToolbar(dataToolbar.getComponent());
    dataPanel.setContent(ScrollPaneFactory.createScrollPane(dataTable));
    dataSplitPane.add(dataPanel,JSplitPane.RIGHT);

    dataSplitPane.getLeftComponent().setPreferredSize(new Dimension(250,0));
    dataSplitPane.getRightComponent().setPreferredSize(new Dimension(0,0));

    dataTree.addMouseListener(new DataExplorerMouseListener(dataTable,dataTree));

}

private void setupToolingDataSplitPane(Project project) {
    ToolingRestClientService toolingRestClientService = ServiceManager.getService(project,ToolingRestClientService.class);
    SimpleNode toolingDaTarootNode = new DataExplorerRootNode(project,"Tooling sObjects");

    SimpleTree toolingDataTree = new SimpleTree();
    toolingDataTree.setShowsRootHandles(true);
    SimpleTreeBuilder toolingDataTreeBuilder = new SimpleTreeBuilder(toolingDataTree,(DefaultTreeModel) toolingDataTree.getModel(),new ExplorerTreeStructure(toolingDaTarootNode),toolingDataTreeBuilder);
    toolingDataTree.addTreeExpansionListener(new ExplorerTreeExpansionListener(toolingDataTreeBuilder));
    toolingDataTree.setCellRenderer(new ExplorerCellRenderer());
    JBTable toolingDataTable = new JBTable();
    toolingDataTable.setStriped(true);
    toolingDataTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);

    // Setup left panel which will display all the available sObjects
    SimpletoolWindowPanel treePanel = new SimpletoolWindowPanel(true,true);
    ActionToolbar treetoolbar = createTreetoolbar(toolingDaTarootNode,toolingDataTreeBuilder);
    treetoolbar.setTargetComponent(treePanel);
    treePanel.setToolbar(treetoolbar.getComponent());
    treePanel.setContent(ScrollPaneFactory.createScrollPane(toolingDataTree));
    toolingDataSplitPane.add(treePanel,true);
    ActionToolbar dataToolbar = createDataToolbar(toolingDataTable);
    dataToolbar.setTargetComponent(dataPanel);
    dataPanel.setToolbar(dataToolbar.getComponent());
    dataPanel.setContent(ScrollPaneFactory.createScrollPane(toolingDataTable));
    toolingDataSplitPane.add(dataPanel,JSplitPane.RIGHT);

    toolingDataSplitPane.getLeftComponent().setPreferredSize(new Dimension(250,0));
    toolingDataSplitPane.getRightComponent().setPreferredSize(new Dimension(0,0));

    toolingDataTree.addMouseListener(new DataExplorerMouseListener(toolingDataTable,toolingDataTree));
}

public SourceItemsTree(ArtifactEditorContext editorContext,ActionManager.getInstance());
  installDnD();
}

private ActionToolbar createtoolbar(SimpleNode rootNode,SimpleTreeBuilder builder) {
    DefaultActionGroup group = new DefaultActionGroup();
    group.add(new ExplorerCollapseAllAction(rootNode,builder));
    return ActionManager.getInstance().createActionToolbar(ActionPlaces.UNKNowN,group,true);
}

private ActionToolbar createTreetoolbar(SimpleNode rootNode,true);
}

public ExplorerCollapseAllAction(SimpleNode rootNode,SimpleTreeBuilder builder) {
    super("Collapse All","Collapse all nodes",AllIcons.Actions.Collapseall);
    this.rootNode = rootNode;
    this.builder = builder;
}

public ExplorerTreeExpansionListener(SimpleTreeBuilder builder) {
    this.builder = builder;
}

private RetrieveChildrenSwingWorker(AbstractExplorerNode node,SimpleTreeBuilder builder) {
    this.node = node;
    this.builder = builder;
}

@Nullable
private StructureViewComposite.StructureViewDescriptor createBaseLanguageStructureView(final FileEditor fileEditor,final Language language) {
  if (!myVirtualFile.isValid()) return null;

  final FileViewProvider viewProvider = getViewProvider();
  if (viewProvider == null) return null;

  final PsiFile dataFile = viewProvider.getPsi(language);
  if (dataFile == null || !isAcceptableBaseLanguageFile(dataFile)) return null;

  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
  if (factory == null) return null;

  final Structureviewbuilder builder = factory.getStructureviewbuilder(dataFile);
  if (builder == null) return null;

  StructureView structureView = builder.createStructureView(fileEditor,myProject);
  return new StructureViewComposite.StructureViewDescriptor(IdeBundle.message("tab.structureview.baselanguage.view",language.getdisplayName()),structureView,findFileType(language).getIcon());
}

@Nullable
private StructureViewComposite.StructureViewDescriptor createBaseLanguageStructureView(final FileEditor fileEditor,final Language language) {
  if (!myVirtualFile.isValid()) return null;

  final TemplateLanguageFileViewProvider viewProvider = getViewProvider();
  if (viewProvider == null) return null;

  final PsiFile dataFile = viewProvider.getPsi(language);
  if (dataFile == null || !isAcceptableBaseLanguageFile(dataFile)) return null;

  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
  if (factory == null) return null;

  final Structureviewbuilder builder = factory.getStructureviewbuilder(dataFile);
  if (builder == null) return null;

  StructureView structureView = builder.createStructureView(fileEditor,findFileType(language).getIcon());
}

@Nullable
private StructureViewComposite.StructureViewDescriptor createBaseLanguageStructureView(final FileEditor fileEditor,findFileType(language).getIcon());
}

@Nullable
private static Structureviewbuilder getStructureviewbuilderForExtensions(final PsiFile psiFile)
{
    for(Language language : XMLLanguage.INSTANCE.getLanguageExtensionsForFile(psiFile))
    {
        PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
        if(factory == null)
        {
            continue;
        }
        final Structureviewbuilder builder = factory.getStructureviewbuilder(psiFile);
        if(builder != null)
        {
            return builder;
        }
    }
    return null;
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@NotNull FileType fileType,@NotNull VirtualFile file,@NotNull Project project)
{
    if(fileType == JavaClassFileType.INSTANCE)
    {
        PsiFile psiFile = PsiManager.getInstance(project).findFile(file);

        if(psiFile instanceof PsiCompiledFile)
        {
            psiFile = ((PsiCompiledFile) psiFile).getDecompiledPsiFile();
        }

        if(psiFile != null)
        {
            PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(psiFile.getLanguage());
            if(factory != null)
            {
                return factory.getStructureviewbuilder(psiFile);
            }
        }
    }

    return null;
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@NotNull FileType fileType,@NotNull Project project) {
  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);

  if (fileType == JavaClassFileType.INSTANCE && psiFile != null) {
    Language language = psiFile.getLanguage();
    if (language != JavaLanguage.INSTANCE) {
      PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
      if (factory != null) {
        return factory.getStructureviewbuilder(psiFile);
      }
    }
  }

  if (psiFile instanceof PsiClassOwner) {
    return new TreeBasedStructureviewbuilder() {
      @Override
      @NotNull
      public Structureviewmodel createStructureviewmodel(@Nullable Editor editor) {
        return new JavafiletreeModel((PsiClassOwner)psiFile,editor);
      }
    };
  }

  return null;
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@NotNull final FileType fileType,@NotNull final VirtualFile file,@NotNull final Project project) {
  if (!(fileType instanceof LanguageFileType)) return null;

  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
  if (psiFile == null) return null;

  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(psiFile.getLanguage());
  return factory == null ?  null : factory.getStructureviewbuilder(psiFile);
}

private static void addNavigationElements(Collection<PsiElement> array,PsiFile element) {
  Structureviewbuilder structureviewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(element);
  if (structureviewbuilder instanceof TreeBasedStructureviewbuilder) {
    TreeBasedStructureviewbuilder builder = (TreeBasedStructureviewbuilder) structureviewbuilder;
    Structureviewmodel model = builder.createStructureviewmodel(null);
    try {
      addStructureViewElements(model.getRoot(),array,element);
    }
    finally {
      model.dispose();
    }
  }
}

public String getQualifiedname() {
  String presentableurl = myFile.getPresentableurl();
  if (myFile.isDirectory()) return presentableurl;

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();
  final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);

  if (psiFile == null) return presentableurl;

  Structureviewbuilder builder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  if (builder instanceof TreeBasedStructureviewbuilder) {
    Structureviewmodel model = ((TreeBasedStructureviewbuilder)builder).createStructureviewmodel(null);
    Object element;
    try {
      element = model.getCurrentEditorElement();
    }
    finally {
      model.dispose();
    }
    if (element instanceof NavigationItem) {
      ItemPresentation presentation = ((NavigationItem)element).getPresentation();
      if (presentation != null) {
        presentableurl = ((NavigationItem)element).getName() + " " + presentation.getLocationString();
      }
    }
  }

  return IdeBundle.message("bookmark.file.X.line.Y",presentableurl,getLine() + 1);
}

@Nullable
private static Navigatable findMember(String pattern,PsiElement psiElement,VirtualFile file) {
  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(psiElement.getLanguage());
  final Structureviewbuilder builder = factory == null ? null : factory.getStructureviewbuilder(psiElement.getContainingFile());
  final FileEditor[] editors = FileEditorManager.getInstance(psiElement.getProject()).getEditors(file);
  if (builder == null || editors.length == 0) {
    return null;
  }

  final StructureView view = builder.createStructureView(editors[0],psiElement.getProject());
  try {
    final StructureViewTreeElement element = findElement(view.getTreeModel().getRoot(),psiElement,4);
    if (element == null) {
      return null;
    }

    final MinusculeMatcher matcher = new MinusculeMatcher(pattern,NameUtil.MatchingCaseSensitivity.NONE);
    int max = Integer.MIN_VALUE;
    Object target = null;
    for (TreeElement treeElement : element.getChildren()) {
      if (treeElement instanceof StructureViewTreeElement) {
        String presentableText = treeElement.getPresentation().getPresentableText();
        if (presentableText != null) {
          final int degree = matcher.matchingDegree(presentableText);
          if (degree > max) {
            max = degree;
            target = ((StructureViewTreeElement)treeElement).getValue();
          }
        }
      }
    }
    return target instanceof Navigatable ? (Navigatable)target : null;
  }
  finally {
    disposer.dispose(view);
  }
}

@Nullable
private static Structureviewbuilder getStructureviewbuilderForExtensions(final PsiFile psiFile) {
  for (Language language : XMLLanguage.INSTANCE.getLanguageExtensionsForFile(psiFile)) {
    PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
    if (factory == null) continue;
    final Structureviewbuilder builder = factory.getStructureviewbuilder(psiFile);
    if (builder != null) {
      return builder;
    }
  }
  return null;
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@NotNull final FileType fileType,@NotNull final Project project) {

  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);

  final ContentBasedFileSubstitutor[] processors = Extensions.getExtensions(ContentBasedFileSubstitutor.EP_NAME);
  for (ContentBasedFileSubstitutor processor : processors) {
    if (processor.isApplicable(project,file)) {
      final Language language = processor.obtainLanguageForFile(file);
      if (language != null) {
        final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
        if (factory != null) return factory.getStructureviewbuilder(psiFile);
      }
    }
  }

  final PsiJavaFile javaFile = (PsiJavaFile)psiFile;
  if (javaFile == null) return null;
  return new TreeBasedStructureviewbuilder() {
    @Override
    @NotNull
    public Structureviewmodel createStructureviewmodel(@Nullable Editor editor) {
      return new JavafiletreeModel(javaFile,editor);
    }
  };
}

private static void addNavigationElements(Collection<PsiElement> array,element);
    }
    finally {
      model.dispose();
    }
  }
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@NotNull final FileType fileType,@NotNull final Project project) {
  if (!(fileType instanceof LanguageFileType)) return null;

  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
  if (psiFile == null) return null;

  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(psiFile.getLanguage());
  return factory == null ?  null : factory.getStructureviewbuilder(psiFile);
}

public String getQualifiedname() {
  String presentableurl = myFile.getPresentableurl();
  if (myFile.isDirectory()) return presentableurl;

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();
  final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);

  if (psiFile == null) return presentableurl;

  Structureviewbuilder builder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  if (builder instanceof TreeBasedStructureviewbuilder) {
    Structureviewmodel model = ((TreeBasedStructureviewbuilder)builder).createStructureviewmodel(null);
    Object element;
    try {
      element = model.getCurrentEditorElement();
    }
    finally {
      model.dispose();
    }
    if (element instanceof NavigationItem) {
      ItemPresentation presentation = ((NavigationItem)element).getPresentation();
      if (presentation != null) {
        presentableurl = ((NavigationItem)element).getName() + " " + presentation.getLocationString();
      }
    }
  }

  return IdeBundle.message("bookmark.file.X.line.Y",getLine() + 1);
}

@Nullable private static Navigatable findMember(String pattern,NameUtil.MatchingCaseSensitivity.NONE);
    int max = Integer.MIN_VALUE;
    Object target = null;
    for (TreeElement treeElement : element.getChildren()) {
      if (treeElement instanceof StructureViewTreeElement) {
        final ItemPresentation presentation = treeElement.getPresentation();
        String presentableText = presentation == null ? null : presentation.getPresentableText();
        if (presentableText != null) {
          final int degree = matcher.matchingDegree(presentableText);
          if (degree > max) {
            max = degree;
            target = ((StructureViewTreeElement)treeElement).getValue();
          }
        }
      }
    }
    return target instanceof Navigatable ? (Navigatable)target : null;
  }
  finally {
    disposer.dispose(view);
  }
}

@Nullable
private static Structureviewbuilder getStructureviewbuilderForExtensions(final PsiFile psiFile) {
  for (Language language : XMLLanguage.INSTANCE.getLanguageExtensionsForFile(psiFile)) {
    PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(language);
    if (factory == null) continue;
    final Structureviewbuilder builder = factory.getStructureviewbuilder(psiFile);
    if (builder != null) {
      return builder;
    }
  }
  return null;
}

private static void addNavigationElements(Collection<PsiElement> array,element);
    }
    finally {
      model.dispose();
    }
  }
}

@Override
@Nullable
public Structureviewbuilder getStructureviewbuilder(@Nonnull final FileType fileType,@Nonnull final VirtualFile file,@Nonnull final Project project) {
  if (!(fileType instanceof LanguageFileType)) return null;

  final PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
  if (psiFile == null) return null;

  final PsiStructureViewFactory factory = LanguageStructureviewbuilder.INSTANCE.forLanguage(psiFile.getLanguage());
  return factory == null ?  null : factory.getStructureviewbuilder(psiFile);
}

public String getQualifiedname() {
  String presentableurl = myFile.getPresentableurl();
  if (myFile.isDirectory()) return presentableurl;

  PsiDocumentManager.getInstance(myProject).commitAllDocuments();
  final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(myFile);

  if (psiFile == null) return presentableurl;

  Structureviewbuilder builder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  if (builder instanceof TreeBasedStructureviewbuilder) {
    Structureviewmodel model = ((TreeBasedStructureviewbuilder)builder).createStructureviewmodel(null);
    Object element;
    try {
      element = model.getCurrentEditorElement();
    }
    finally {
      model.dispose();
    }
    if (element instanceof NavigationItem) {
      ItemPresentation presentation = ((NavigationItem)element).getPresentation();
      if (presentation != null) {
        presentableurl = ((NavigationItem)element).getName() + " " + presentation.getLocationString();
      }
    }
  }

  return IdeBundle.message("bookmark.file.X.line.Y",getLine() + 1);
}

@Nullable
private static Navigatable findMember(String pattern,4);
    if (element == null) {
      return null;
    }
    final MinusculeMatcher matcher = NameUtil.buildMatcher(pattern).build();
    int max = Integer.MIN_VALUE;
    Object target = null;
    for (TreeElement treeElement : element.getChildren()) {
      if (treeElement instanceof StructureViewTreeElement) {
        String presentableText = treeElement.getPresentation().getPresentableText();
        if (presentableText != null) {
          final int degree = matcher.matchingDegree(presentableText);
          if (degree > max) {
            max = degree;
            target = ((StructureViewTreeElement)treeElement).getValue();
          }
        }
      }
    }
    return target instanceof Navigatable ? (Navigatable)target : null;
  }
  finally {
    disposer.dispose(view);
  }
}

@Override
protected boolean isValidForFile(@NotNull Project project,@NotNull Editor editor,@NotNull final PsiFile file) {
  return LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file) instanceof TreeBasedStructureviewbuilder;
}

static boolean checkValidForFile(final PsiFile file) {
  final Structureviewbuilder structureviewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file);
  return structureviewbuilder instanceof TreeBasedStructureviewbuilder || structureviewbuilder instanceof TemplateLanguageStructureviewbuilder;
}

protected boolean isShowRoot(final PsiFile psiFile) {
  Structureviewbuilder viewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  return viewbuilder instanceof TreeBasedStructureviewbuilder && ((TreeBasedStructureviewbuilder)viewbuilder).isRootNodeShown();
}

@Override
protected boolean isValidForFile(@NotNull Project project,@NotNull final PsiFile file) {
  return LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file) instanceof TreeBasedStructureviewbuilder;
}

static boolean checkValidForFile(final PsiFile file) {
  final Structureviewbuilder structureviewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file);
  return structureviewbuilder instanceof TreeBasedStructureviewbuilder || structureviewbuilder instanceof TemplateLanguageStructureviewbuilder;
}

protected boolean isShowRoot(final PsiFile psiFile) {
  Structureviewbuilder viewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  return viewbuilder instanceof TreeBasedStructureviewbuilder && ((TreeBasedStructureviewbuilder)viewbuilder).isRootNodeShown();
}

@Override
protected boolean isValidForFile(@Nonnull Project project,@Nonnull Editor editor,@Nonnull final PsiFile file) {
  return LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file) instanceof TreeBasedStructureviewbuilder;
}

@requireddispatchThread
@Override
public void invoke(@Nonnull final Project project,@Nonnull final Editor editor,@Nonnull PsiFile file) {
  PsiDocumentManager.getInstance(project).commitAllDocuments();

  PsiElement container = null;
  WeakReference<LightweightHint> ref = editor.getUserData(MY_LAST_HINT_KEY);
  LightweightHint hint = SoftReference.dereference(ref);
  if (hint != null && hint.isVisible()){
    hint.hide();
    container = hint.getUserData(CONTAINER_KEY);
    if (container != null && !container.isValid()){
      container = null;
    }
  }

  Structureviewbuilder builder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file);
  if (builder instanceof TreeBasedStructureviewbuilder) {
    Structureviewmodel model = ((TreeBasedStructureviewbuilder) builder).createStructureviewmodel(editor);
    boolean goOneLevelUp = true;
    try {
      if (container == null) {
        goOneLevelUp = false;
        Object element = model.getCurrentEditorElement();
        if (element instanceof PsiElement) {
          container = (PsiElement) element;
        }
      }
    }
    finally {
      model.dispose();
    }
    while(true) {
      if (container == null || container instanceof PsiFile) {
        return;
      }
      if (goOneLevelUp) {
        goOneLevelUp = false;
      }
      else {
        if (!isDeclarationVisible(container,editor)) {
          break;
        }
      }

      container = container.getParent();
      while(container != null && DeclarationRangeUtil.getPossibleDeclarationAtRange(container) == null) {
        container = container.getParent();
        if (container instanceof PsiFile) return;
      }
    }
  }
  if (container == null) {
    return;
  }

  final TextRange range = DeclarationRangeUtil.getPossibleDeclarationAtRange(container);
  if (range == null) {
    return;
  }
  final PsiElement _container = container;
  ApplicationManager.getApplication().invokelater(() -> {
    LightweightHint hint1 = EditorFragmentComponent.showEditorFragmentHint(editor,range,true,true);
    if (hint1 != null) {
      hint1.putUserData(CONTAINER_KEY,_container);
      editor.putUserData(MY_LAST_HINT_KEY,new WeakReference<>(hint1));
    }
  });
}

static boolean checkValidForFile(final PsiFile file) {
  final Structureviewbuilder structureviewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(file);
  return structureviewbuilder instanceof TreeBasedStructureviewbuilder || structureviewbuilder instanceof TemplateLanguageStructureviewbuilder;
}

protected boolean isShowRoot(final PsiFile psiFile) {
  Structureviewbuilder viewbuilder = LanguageStructureviewbuilder.INSTANCE.getStructureviewbuilder(psiFile);
  return viewbuilder instanceof TreeBasedStructureviewbuilder && ((TreeBasedStructureviewbuilder)viewbuilder).isRootNodeShown();
}

public JavaCoreApplicationEnvironment(disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"class");
  registerFileType(JavaFileType.INSTANCE,"java");
  registerFileType(ArchiveFileType.INSTANCE,"jar;zip");

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,JavaClassFileType.INSTANCE,new ClassFileViewProviderFactory());
  addExplicitExtension(BinaryFileStubBuilders.INSTANCE,new ClassFileStubBuilder());

  addExplicitExtension(LanguageASTFactory.INSTANCE,JavaLanguage.INSTANCE,new CoreJavaASTFactory());
  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,new JavaParserDeFinition());
  addExplicitExtension(LanguageConstantExpressionEvaluator.INSTANCE,new PsiExpressionEvaluator());

  registerExtensionPoint(Extensions.getRootArea(),ClsstubBuilderFactory.EP_NAME,ClsstubBuilderFactory.class);
  registerExtensionPoint(Extensions.getRootArea(),PsiAugmentProvider.EP_NAME,PsiAugmentProvider.class);
  registerExtensionPoint(Extensions.getRootArea(),JavaMainMethodProvider.EP_NAME,JavaMainMethodProvider.class);
  addExtension(ClsstubBuilderFactory.EP_NAME,new DefaultClsstubBuilderFactory());

  myApplication.registerService(PsiPackageImplementationHelper.class,new CorePsiPackageImplementationHelper());

  myApplication.registerService(EmptySubstitutor.class,new EmptySubstitutorImpl());
  myApplication.registerService(JavaDirectoryService.class,createJavaDirectoryService());
  myApplication.registerService(JavaVersionService.class,new JavaVersionService());

  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiPackage.class,new PackagePresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiClass.class,new ClasspresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiMethod.class,new MethodPresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiField.class,new FieldPresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiLocalVariable.class,new VariablePresentationProvider());
  addExplicitExtension(ItemPresentationProviders.INSTANCE,PsiParameter.class,new VariablePresentationProvider());
}

public JavaCoreApplicationEnvironment(disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"java");
  registerFileType(JararchiveFileType.INSTANCE,"jar");

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,new ClassFileStubBuilder());

  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,JavaMainMethodProvider.class);

  myApplication.registerService(PsiPackageImplementationHelper.class,PsiJavaPackage.class,new VariablePresentationProvider());
}

public JavaCoreApplicationEnvironment(@NotNull disposable parentdisposable) {
  super(parentdisposable);

  registerFileType(JavaClassFileType.INSTANCE,"jar;zip");
  registerFileType(PlainTextFileType.INSTANCE,"txt;sh;bat;cmd;policy;log;cgi;MF;jad;jam;htaccess");

  addExplicitExtension(LanguageASTFactory.INSTANCE,PlainTextLanguage.INSTANCE,new PlainTextASTFactory());
  addExplicitExtension(LanguageParserDeFinitions.INSTANCE,new PlainTextParserDeFinition());

  addExplicitExtension(FileTypeFileViewProviders.INSTANCE,new PsiExpressionEvaluator());

  addExtension(ContainerProvider.EP_NAME,new JavaContainerProvider());

  myApplication.registerService(PsiPackageImplementationHelper.class,new VariablePresentationProvider());

  registerapplicationservice(JavaCodeFoldingSettings.class,new JavaCodeFoldingSettingsBase());
  addExplicitExtension(LanguageFolding.INSTANCE,new JavaFoldingBuilderBase() {
    @Override
    protected boolean shouldShowExplicitLambdaType(PsiAnonymousClass anonymousClass,PsiNewExpression expression) {
      return false;
    }

    @Override
    protected boolean isBelowRightMargin(Project project,int lineLength) {
      return false;
    }
  });

  registerapplicationExtensionPoint(SuperMethodsSearch.EP_NAME,QueryExecutor.class);
  addExtension(SuperMethodsSearch.EP_NAME,new MethodSuperSearcher());
}

public GrReflectedMethodImpl(GrMethod baseMethod,GrParameter[] parameters,int optionalParams,PsiClasstype categoryType) {
  super(baseMethod.getManager(),baseMethod.getLanguage(),baseMethod.getName(),new GrLightParameterListBuilder(baseMethod.getManager(),baseMethod.getLanguage()),new GrLightModifierList(baseMethod),new LightReferenceListBuilder(baseMethod.getManager(),null),new LightTypeParameterListBuilder(baseMethod.getManager(),baseMethod.getLanguage())
  );

  initParameterList(parameters,optionalParams,categoryType);
  initTypeParameterList(baseMethod);
  initModifiers(baseMethod,categoryType != null);
  initThrowsList(baseMethod);
  setContainingClass(baseMethod.getContainingClass());
  setMethodReturnType(baseMethod.getReturnType());
  setConstructor(baseMethod.isConstructor());

  myBaseMethod = baseMethod;
}

public GrReflectedMethodImpl(GrMethod baseMethod,categoryType != null);
  initThrowsList(baseMethod);
  setContainingClass(baseMethod.getContainingClass());
  setMethodReturnType(baseMethod.getReturnType());
  setConstructor(baseMethod.isConstructor());

  myBaseMethod = baseMethod;
}

public GrLightMethodBuilder(PsiManager manager,String name) {
  super(manager,GroovyLanguage.INSTANCE);
  myName = name;
  myModifierList = new GrLightModifierList(this);
  myParameterList = new GrLightParameterListBuilder(manager,GroovyLanguage.INSTANCE);
  myTypeParameterList = new LightTypeParameterListBuilder(manager,GroovyLanguage.INSTANCE);
  myThrowsList = new LightReferenceListBuilder(manager,GroovyLanguage.INSTANCE,PsiReferenceList.Role.THROWS_LIST);
}

public GrLightMethodBuilder(PsiManager manager,GroovyFileType.GROOVY_LANGUAGE);
  myName = name;
  myParameterList = new GrLightParameterListBuilder(manager,GroovyFileType.GROOVY_LANGUAGE);
  myModifierList = new GrLightModifierList(this);
  myConstructor = false;
  myThrowsList = new LightReferenceListBuilder(manager,GroovyFileType.GROOVY_LANGUAGE,PsiReferenceList.Role.THROWS_LIST);
}

@NotNull
@Override
public PsiReferenceList getThrowsList()
{
    LightReferenceListBuilder builder = new LightReferenceListBuilder(getManager(),PsiReferenceList.Role.THROWS_LIST);
    builder.addReference(JavaClassNames.JAVA_LANG_THROWABLE);
    return builder;
}

@Override
@NotNull
public LightReferenceListBuilder getThrowsList() {
  return myThrowsList;
}

public GrLightMethodBuilder addException(PsiClasstype type) {
  ((LightReferenceListBuilder)myThrowsList).addReference(type);
  return this;
}

@NotNull
@Override
public PsiReferenceList getExtendsList()
{
    return new LightReferenceListBuilder(getManager(),PsiReferenceList.Role.EXTENDS_LIST);
}

@NotNull
@SuppressWarnings("unchecked")
public <T> T getrequiredStubOrPsiChildByIndex(@NotNull TokenSet set,int index)
{
    T element = getStubOrPsiChildByIndex(set,index);
    if(element == null)
    {
        throw new IllegalArgumentException("Element by set: " + set + " and index:" + index + " is not found. Tree:\n " + new
                PsiTreeDebugBuilder().psiToString(this,false,false));
    }
    return element;
}

protected String unexpectedPsiAssertion() {
  final PsiTreeDebugBuilder builder = new PsiTreeDebugBuilder();
  return "Unexpected PSI structure: " + builder.psiToString(this) + "--\ninside: " + builder.psiToString(getContainingFile());
}

protected String unexpectedPsiAssertion() {
  final PsiTreeDebugBuilder builder = new PsiTreeDebugBuilder();
  return "Unexpected PSI structure: " + builder.psiToString(this) + "--\ninside: " + builder.psiToString(getContainingFile());
}

@Nullable
@requiredReadAction
public String buildArgumentTypeRefs()
{
    CSharpReferenceExpression element = myPointer.getElement();
    if(element == null)
    {
        return null;
    }

    StringBuilder builder = new StringBuilder();

    CSharpCallArgumentListOwner parent = PsiTreeUtil.getParentOfType(element,CSharpCallArgumentListOwner.class);

    if(parent == null)
    {
        LOGGER.error("Can't find parent by 'CSharpCallArgumentListOwner'. Element: " + new PsiTreeDebugBuilder().psiToString(element));
        return null;
    }

    CSharpCallArgument[] callArguments = parent.getCallArguments();

    for(int i = 0; i < callArguments.length; i++)
    {
        if(i != 0)
        {
            builder.append(",");
        }

        CSharpCallArgument callArgument = callArguments[i];

        DotNetExpression argumentExpression = callArgument.getArgumentExpression();
        if(argumentExpression != null)
        {
            DotNetTypeRef typeRef = argumentExpression.toTypeRef(false);
            builder.append(CSharpTypeRefPresentationUtil.buildShortText(typeRef,element));
        }
        else
        {
            builder.append("object");
        }
    }
    return builder.toString();
}