com.intellij.ide.structureView.StructureViewModel Java Examples

@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  if (!(psiFile instanceof HaxeFile)) {
    return null;
  }
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new HaxeStructureViewModel(psiFile, editor);
    }

    @Override
    public boolean isRootNodeShown() {
      return false;
    }
  };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile)
{
	if(psiFile instanceof CSharpFileImpl)
	{
		return new TreeBasedStructureViewBuilder()
		{
			@Nonnull
			@Override
			public StructureViewModel createStructureViewModel(@Nullable Editor editor)
			{
				return new CSharpStructureViewModel(psiFile, editor);
			}
		};
	}
	else
	{
		return null;
	}
}
 

@Nullable
@Override
@RequiredReadAction
public PsiElement getParent(@Nonnull PsiElement psiElement) {
  if (psiElement.getLanguage() == getLanguage()) {
    PsiFile containingFile = psiElement.getContainingFile();
    if (containingFile == null) {
      return null;
    }

    StructureViewModel model = buildStructureViewModel(containingFile, null);
    if (model != null) {
      PsiElement parentInModel = findParentInModel(model.getRoot(), psiElement);
      if(acceptParentFromModel(parentInModel)) {
        return parentInModel;
      }
    }
  }
  return super.getParent(psiElement);
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new ProtoStructureViewModel((ProtoPsiFileRoot) psiFile, editor);
        }

        @Override
        public boolean isRootNodeShown() {
            return false;
        }
    };
}
 

@Override
@RequiredReadAction
public PsiElement getLeafElement(@Nonnull DataContext dataContext) {
  if (UISettings.getInstance().getShowMembersInNavigationBar()) {
    PsiFile psiFile = dataContext.getData(CommonDataKeys.PSI_FILE);
    Editor editor = dataContext.getData(CommonDataKeys.EDITOR);
    if (psiFile == null || editor == null) return null;
    PsiElement psiElement = psiFile.findElementAt(editor.getCaretModel().getOffset());
    if (psiElement != null && psiElement.getLanguage() == getLanguage()) {
      StructureViewModel model = buildStructureViewModel(psiFile, editor);
      if (model != null) {
        Object currentEditorElement = model.getCurrentEditorElement();
        if (currentEditorElement instanceof PsiElement) {
          return ((PsiElement)currentEditorElement).getOriginalElement();
        }
      }
    }
  }
  return null;
}
 

@Nullable
public static FileStructurePopup createPopup(@Nonnull Project project, @Nonnull FileEditor fileEditor) {
  PsiDocumentManager.getInstance(project).commitAllDocuments();
  StructureViewBuilder builder = fileEditor.getStructureViewBuilder();
  if (builder == null) return null;
  StructureView structureView;
  StructureViewModel treeModel;
  if (builder instanceof TreeBasedStructureViewBuilder) {
    structureView = null;
    treeModel = ((TreeBasedStructureViewBuilder)builder).createStructureViewModel(EditorUtil.getEditorEx(fileEditor));
  }
  else {
    structureView = builder.createStructureView(fileEditor, project);
    treeModel = createStructureViewModel(project, fileEditor, structureView);
  }
  if (treeModel instanceof PlaceHolder) {
    //noinspection unchecked
    ((PlaceHolder)treeModel).setPlace(TreeStructureUtil.PLACE);
  }
  FileStructurePopup popup = new FileStructurePopup(project, fileEditor, treeModel);
  if (structureView != null) Disposer.register(popup, structureView);
  return popup;
}
 

@Nullable
protected TreeBasedStructureViewBuilder createMainBuilder(@Nonnull PsiFile psi) {
  //noinspection deprecation
  StructureViewComposite.StructureViewDescriptor descriptor = createMainView(null, psi);
  if (descriptor == null) return null;
  return new TreeBasedStructureViewBuilder() {
    @Nonnull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      Disposer.register(descriptor.structureModel, descriptor.structureView);
      return descriptor.structureModel;
    }

    @Nonnull
    @Override
    public StructureView createStructureView(FileEditor fileEditor, @Nonnull Project project) {
      return descriptor.structureView;
    }
  };
}
 

@Nonnull
public static TemplateLanguageStructureViewBuilder create(@Nonnull PsiFile psiFile, @Nullable PairFunction<? super PsiFile, ? super Editor, ? extends StructureViewModel> modelFactory) {
  return new TemplateLanguageStructureViewBuilder(psiFile) {
    @Override
    protected TreeBasedStructureViewBuilder createMainBuilder(@Nonnull PsiFile psi) {
      return modelFactory == null ? null : new TreeBasedStructureViewBuilder() {
        @Override
        public boolean isRootNodeShown() {
          return false;
        }

        @Nonnull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
          return modelFactory.fun(psi, editor);
        }
      };
    }
  };
}
 

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
 @Override
 public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
     return new TreeBasedStructureViewBuilder() {
@NotNull
@Override
public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
	VirtualFile grammarFile = psiFile.getVirtualFile();
	if ( grammarFile==null || !grammarFile.getName().endsWith(".g4") ) {
		return new StructureViewModelBase(psiFile, new DummyViewTreeElement(psiFile));
	}
             return new ANTLRv4StructureViewModel((ANTLRv4FileRoot)psiFile);
}
     };
 }
 

private static StructureView createStructureView(
    LayoutSpecModel model, FileEditor selectedEditor, PsiFile selectedFile, Project project) {
  final StructureViewModel viewModel = ComponentTreeModel.create(selectedFile, model);
  final StructureView view =
      StructureViewFactory.getInstance(project)
          .createStructureView(selectedEditor, viewModel, project, true);
  Disposer.register(view, viewModel);
  return view;
}
 

@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new ThriftStructureViewModel(psiFile);
    }

    @Override
    public boolean isRootNodeShown() {
      return false;
    }
  };
}
 

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();
    }
  }
}
 

@Override
@Nonnull
public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
  List<StructureViewComposite.StructureViewDescriptor> viewDescriptors = new ArrayList<>();
  PsiFile psiFile = ObjectUtils.notNull(PsiManager.getInstance(myProject).findFile(myVirtualFile));
  for (Language language : getLanguages(psiFile)) {
    StructureViewBuilder builder = getBuilder(psiFile, language);
    if (!(builder instanceof TreeBasedStructureViewBuilder)) continue;
    StructureViewModel model = ((TreeBasedStructureViewBuilder)builder).createStructureViewModel(editor);
    String title = language.getDisplayName();
    Image icon = ObjectUtils.notNull(LanguageUtil.getLanguageFileType(language), UnknownFileType.INSTANCE).getIcon();
    viewDescriptors.add(new StructureViewComposite.StructureViewDescriptor(title, model, icon));
  }
  return new StructureViewCompositeModel(psiFile, editor, viewDescriptors);
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new BuckStructureViewModel(psiFile);
    }
  };
}
 

@Nonnull
public static StructureViewModel createStructureViewModel(@Nonnull Project project, @Nonnull FileEditor fileEditor, @Nonnull StructureView structureView) {
  StructureViewModel treeModel;
  VirtualFile virtualFile = fileEditor.getFile();
  if (structureView instanceof StructureViewComposite && virtualFile != null) {
    StructureViewComposite.StructureViewDescriptor[] views = ((StructureViewComposite)structureView).getStructureViews();
    PsiFile psiFile = ObjectUtils.notNull(PsiManager.getInstance(project).findFile(virtualFile));
    treeModel = new StructureViewCompositeModel(psiFile, EditorUtil.getEditorEx(fileEditor), Arrays.asList(views));
    Disposer.register(structureView, treeModel);
  }
  else {
    treeModel = structureView.getTreeModel();
  }
  return treeModel;
}
 

@Override
@RequiredReadAction
public boolean processChildren(Object object, Object rootElement, Processor<Object> processor) {
  if (UISettings.getInstance().getShowMembersInNavigationBar()) {
    if (object instanceof PsiElement) {
      if (((PsiElement)object).getLanguage() == getLanguage()) {
        StructureViewModel model = buildStructureViewModel(((PsiElement)object).getContainingFile(), null);
        if (model != null) {
          return processStructureViewChildren(model.getRoot(), object, processor);
        }
      }
    }
  }
  return super.processChildren(object, rootElement, processor);
}
 

public FileStructureDialog(StructureViewModel structureViewModel,
                           @Nullable Editor editor,
                           Project project,
                           Navigatable navigatable,
                           @Nonnull final Disposable auxDisposable,
                           final boolean applySortAndFilter) {
  super(project, true);
  myProject = project;
  myEditor = editor;
  myNavigatable = navigatable;
  myBaseTreeModel = structureViewModel;
  if (applySortAndFilter) {
    myTreeActionsOwner = new TreeStructureActionsOwner(myBaseTreeModel);
    myTreeModel = new TreeModelWrapper(structureViewModel, myTreeActionsOwner);
  }
  else {
    myTreeActionsOwner = null;
    myTreeModel = structureViewModel;
  }

  PsiFile psiFile = getPsiFile(project);

  final PsiElement psiElement = getCurrentElement(psiFile);

  //myDialog.setUndecorated(true);
  init();

  if (psiElement != null) {
    if (structureViewModel.shouldEnterElement(psiElement)) {
      myCommanderPanel.getBuilder().enterElement(psiElement, PsiUtilBase.getVirtualFile(psiElement));
    }
    else {
      myCommanderPanel.getBuilder().selectElement(psiElement, PsiUtilBase.getVirtualFile(psiElement));
    }
  }

  Disposer.register(myDisposable, auxDisposable);
}
 

@Nullable
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return createStructureViewModel(); // todo, new api Idea 14.1
    }

    public StructureViewModel createStructureViewModel() {
      return new CppStructureViewBuilder(psiFile);
    }
  };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
	return new TreeBasedStructureViewBuilder() {
		@NotNull
		@Override
		public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
			return new LatteStructureViewModel(psiFile);
		}
	};
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new HaskellStructureViewModel(psiFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(@NotNull final PsiFile psiFile) {
  return new TreeBasedStructureViewBuilder() {
    @NotNull
    @Override
    public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
      return new SimpleStructureViewModel(psiFile);
    }
  };
}
 

public StructureViewBuilder getStructureViewBuilder(@NotNull final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {

        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(Editor editor) {
            return new GLSLStructureViewModel(psiFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
	return new TreeBasedStructureViewBuilder() {
		@NotNull
		@Override
		public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
			return new SampleStructureViewModel((SamplePSIFileRoot)psiFile);
		}
	};
}
 

@Test
public void testStructureView() throws Exception {
    VirtualFile file = configure();
    Assert.assertNotNull(file);

    MyTest myTest = new MyTest() {
        public void test(StructureViewComponent component) {
            StructureViewModel tree = component.getTreeModel();
            Assert.assertNotNull(tree);

            StructureViewTreeElement root = tree.getRoot();
            Assert.assertNotNull(root);

            TreeElement[] children = root.getChildren();
            Assert.assertEquals(1, children.length);

            TreeElement firstChild = children[0];
            Assert.assertNotNull(firstChild);

            Assert.assertEquals("a()", firstChild.getPresentation().getPresentableText());

            Assert.assertNotNull(firstChild.getChildren());
            Assert.assertEquals(0, firstChild.getChildren().length);
        }
    };

    doTest(myTest);
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new CsvStructureViewModel(psiFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new WeaveStructureViewModel(psiFile, editor, new WeaveDocumentStructureView((WeaveFile) psiFile));
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(final PsiFile psiFile) {
    final FusionFile fusionFile = (FusionFile) psiFile;
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        @Override
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new FusionStructureViewModel(editor, fusionFile);
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new JSGraphQLEndpointStructureViewModel(psiFile, editor);
        }

        public boolean isRootNodeShown() {
            return false;
        }
    };
}
 

@Nullable
@Override
public StructureViewBuilder getStructureViewBuilder(@NotNull PsiFile psiFile) {
    return new TreeBasedStructureViewBuilder() {
        @NotNull
        public StructureViewModel createStructureViewModel(@Nullable Editor editor) {
            return new GraphQLStructureViewModel(psiFile, editor);
        }

        public boolean isRootNodeShown() {
            return false;
        }
    };
}