/**
 * Creates the context menu for the given object. Gets the action from the
 * actionRegistry and adds the action to the menu.
 * 
 * @param menu
 *            the menu
 * @param object
 *            the object
 */
public void createContextMenu( TreeViewer sourceViewer, Object object,
		IMenuManager menu )
{
	super.createContextMenu( sourceViewer, object, menu );

	menu.insertBefore( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", //$NON-NLS-1$
			new ShowPropertyAction( object ) );

	menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", new Separator( ) ); //$NON-NLS-1$
	IAction action = new RefreshAction( sourceViewer );
	if (action.isEnabled( ))
	{
		menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", action ); //$NON-NLS-1$
	}
}
 

public static void unstageObjects(TreeViewer stagedTreeViewer, IStructuredSelection selection, IAbapGitStaging model,
		List<Object> expandedNodes) {
	IAbapGitObject abapObject;
	IAbapGitFile file;

	movedObjects.clear();
	for (Object object : selection.toList()) {
		abapObject = null;
		file = null;
		if (object instanceof IAbapGitObject) {
			abapObject = (IAbapGitObject) object;
			if (stagedTreeViewer.getExpandedState(abapObject)) {
				expandedNodes.add(abapObject);
			}
			unstageObject(model, abapObject);
		} else if (object instanceof IAbapGitFile) {
			abapObject = (IAbapGitObject) ((IAbapGitFile) object).eContainer();
			file = (IAbapGitFile) object;
			if (movedObjects.contains(abapObject)) {
				continue;
			}
			expandedNodes.add(abapObject);
			unstageFile(model, abapObject, file);
		}
	}
}
 

@Override
protected void configureViewer(final StructuredViewer viewer) {
    viewer.setLabelProvider(new LabelProvider() {

        @Override
        public String getText(final Object element) {
            final String displayName = ((org.bonitasoft.studio.actors.model.organization.Group) element).getDisplayName();
            if (displayName == null || displayName.isEmpty()) {
                return ((org.bonitasoft.studio.actors.model.organization.Group) element).getName();
            }
            return displayName;
        }
    });

    if (groupList != null && getViewer() != null) {
        getViewer().setInput(groupList);
        ((TreeViewer) getViewer()).expandAll();
    }
}
 

protected TreeViewer createResourceSelectionTree(Composite composite, int types, int span) {
	TreeViewer tree = new TreeViewer(composite, SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER);
	tree.setUseHashlookup(true);
	tree.setContentProvider(getResourceProvider(types));
	tree.setLabelProvider(
		new DecoratingLabelProvider(
			new WorkbenchLabelProvider(), 
			SVNUIPlugin.getPlugin().getWorkbench().getDecoratorManager().getLabelDecorator()));
	tree.setSorter(new ResourceSorter(ResourceSorter.NAME));
	
	GridData data = new GridData(GridData.FILL_BOTH | GridData.GRAB_VERTICAL);
	data.heightHint = LIST_HEIGHT_HINT;
	data.horizontalSpan = span;
	tree.getControl().setLayoutData(data);
	return tree;
}
 

/**
 * Creates tree viewer to manage content
 * 
 * @param parent
 *            parent control
 */
private void createTreeViewer(Composite parent) {
	int style = SWT.H_SCROLL | SWT.V_SCROLL;
	// Create the tree
	Tree widget = new Tree(parent, style);
	// Configure the layout
	GridData data = new GridData(GridData.FILL_BOTH);
	data.heightHint = widget.getItemHeight() * 12;
	widget.setLayoutData(data);

	treeViewer = new TreeViewer(widget);
	namePatternFilter = new QuickOutlineNamePatternFilter();
	treeViewer.addFilter(namePatternFilter);
	treeContentProvider = getContentProvider();
	treeViewer.setContentProvider(treeContentProvider);
	treeLabelProvider = getLabelProvider();
	treeViewer.setLabelProvider(treeLabelProvider);
	treeViewer.setAutoExpandLevel(AbstractTreeViewer.ALL_LEVELS);
	treeViewer.setUseHashlookup(true);
	treeViewer.setInput(getInitialInput());
}
 

protected void performAdded ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        ( (TreeViewer)this.viewer ).add ( this.data, entries );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}
 

public void performRemoved ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        ( (TreeViewer)this.viewer ).remove ( entries );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}
 

public void performUpdated ( final ListEntry[] entries )
{
    if ( this.viewer.getControl ().isDisposed () )
    {
        return;
    }

    if ( this.viewer instanceof TreeViewer )
    {
        for ( final ListEntry entry : entries )
        {
            ( (TreeViewer)this.viewer ).refresh ( entry );
        }
        ( (TreeViewer)this.viewer ).update ( entries, null );
    }
    else if ( this.viewer != null )
    {
        this.viewer.refresh ();
    }
}
 

public static void addDropSupport(TreeViewer tree,
		Consumer<List<Descriptor>> handler) {
	Transfer transfer = ModelTransfer.getInstance();
	DropTarget dropTarget = new DropTarget(tree.getTree(), DND.DROP_COPY
			| DND.DROP_MOVE | DND.DROP_DEFAULT);
	dropTarget.setTransfer(new Transfer[] { transfer });
	dropTarget.addDropListener(new DropTargetAdapter() {
		@Override
		public void drop(DropTargetEvent event) {
			if (!transfer.isSupportedType(event.currentDataType))
				return;
			var list = ModelTransfer.getDescriptors(event.data);
			handler.accept(list);
		}
	});
}
 

protected void createViewer(Composite parent, AbstractBdmFormPage formPage) {
    viewer = new TreeViewer(parent, SWT.SINGLE | SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER | SWT.FULL_SELECTION);
    viewer.getTree().setLayoutData(GridDataFactory.fillDefaults().span(2, 1).grab(true, true).create());
    formPage.getToolkit().adapt(viewer.getTree());
    viewer.getTree().setData(SWTBotConstants.SWTBOT_WIDGET_ID_KEY, BUSINESS_OBJECT_LIST_VIEWER_ID);
    viewer.addFilter(createSearchFilter());
    viewer.addDoubleClickListener(e -> {
        viewer.setExpandedState(selectionObservable.getValue(),
                !viewer.getExpandedState(selectionObservable.getValue()));
    });

    ColumnViewerToolTipSupport.enableFor(viewer);
    TableLayout layout = new TableLayout();
    layout.addColumnData(new ColumnWeightData(1, true));
    viewer.getTree().setLayout(layout);
    viewer.setUseHashlookup(true);
    createBusinessObjectColumn(viewer, formPage);
    viewer.setContentProvider(new BusinessObjectTreeContentProvider());
    viewer.setComparator(new BusinessObjectViewerComparator());
    viewer.setInput(input);
    addDNDSupport(formPage);
    selectionObservable = ViewerProperties.singleSelection(Object.class).observe(viewer);
}
 

public boolean isElementVisible( Viewer viewer, Object element )
{
	if ( isLeafMatch( viewer, element ) )
	{
		return true;
	}

	if ( element instanceof DataSourceType )
	{
		ITreeContentProvider contentProvider = (ITreeContentProvider) ( (TreeViewer) viewer ).getContentProvider( );
		DataSourceType node = (DataSourceType) element;
		Object[] children = contentProvider.getChildren( node );
		// Will return true if any subnode of the element matches the search
		if ( filter( viewer, element, children ).length > 0 )
		{
			return true;
		}
	}
	return false;
}
 

protected void createMappingTree(final Composite listComposite) {
    mappingTree = new TreeViewer(listComposite, SWT.BORDER | SWT.FULL_SELECTION | SWT.SINGLE | SWT.V_SCROLL);
    mappingTree.getTree().setLayoutData(GridDataFactory.fillDefaults().grab(true, true).create());
    mappingTree.setContentProvider(new AdapterFactoryContentProvider(adapterFactory) {

        @Override
        public Object[] getElements(final Object object) {
            if (object instanceof Collection) {
                return ((Collection) object).toArray();
            }
            return super.getElements(object);
        }
    });
    mappingTree.setLabelProvider(new ActorMappingStyledTreeLabelProvider(adapterFactory, deployedOrganization));
    mappingTree.addSelectionChangedListener(this);
    mappingTree.addDoubleClickListener(this);
    mappingTree.addFilter(new ViewerFilter() {

        @Override
        public boolean select(final Viewer viewer, final Object parentElement, final Object element) {
            return (element instanceof String || element instanceof MembershipType)
                    || ((ITreeContentProvider) mappingTree.getContentProvider()).hasChildren(element);
        }
    });
}
 

@Override
protected void addButtonSelected() {
    final org.bonitasoft.studio.actors.model.organization.Group parentGoup = (org.bonitasoft.studio.actors.model.organization.Group) ((IStructuredSelection) getViewer()
            .getSelection()).getFirstElement();
    final org.bonitasoft.studio.actors.model.organization.Group group = OrganizationFactory.eINSTANCE.createGroup();
    group.setName(generateGroupname());
    group.setDisplayName(group.getName());
    if (parentGoup != null) {
        if (parentGoup.getParentPath() == null) {
            group.setParentPath(GroupContentProvider.GROUP_SEPARATOR + parentGoup.getName());
        } else {
            group.setParentPath(parentGoup.getParentPath() + GroupContentProvider.GROUP_SEPARATOR + parentGoup.getName());
        }
    }
    groupList.add(group);
    getViewer().setInput(groupList);
    ((TreeViewer) getViewer()).expandAll();
    getViewer().setSelection(new StructuredSelection(group));
}
 

protected void hijackCallHierarchy(final IViewPart view, final boolean revertToDefaults)
{
	try
	{
		Field f = view.getClass().getDeclaredField("fPagebook"); //$NON-NLS-1$
		f.setAccessible(true);
		PageBook pageBook = (PageBook) f.get(view);

		f = pageBook.getClass().getDeclaredField("currentPage"); //$NON-NLS-1$
		f.setAccessible(true);
		Control control = (Control) f.get(pageBook);
		if (control instanceof Label)
		{
			hookTheme(control, revertToDefaults);
			return;
		}

		Method m = view.getClass().getMethod("getViewer"); //$NON-NLS-1$
		TreeViewer treeViewer = (TreeViewer) m.invoke(view);
		hookTheme(treeViewer, revertToDefaults);

		m = view.getClass().getDeclaredMethod("getLocationViewer"); //$NON-NLS-1$
		if (m != null)
		{
			m.setAccessible(true);
			Viewer viewer = (Viewer) m.invoke(view);
			hookTheme(viewer, revertToDefaults);
		}
	}
	catch (Exception e)
	{
		// ignore
	}
}
 

@SuppressWarnings("unchecked")
private int compareColumn(final Viewer viewer, final Object a, final Object b, final int columnNumber) {
	IBaseLabelProvider baseLabel = ((TreeViewer) viewer).getLabelProvider();
	if (baseLabel instanceof ITableLabelProvider) {
		ITableLabelProvider tableProvider = (ITableLabelProvider) baseLabel;
		String e1p = tableProvider.getColumnText(a, columnNumber);
		String e2p = tableProvider.getColumnText(b, columnNumber);
		if (e1p != null && e2p != null) {
			return getComparator().compare(e1p, e2p);
		}
	}
	return 0;
}
 

public CollapseAllAction(TreeViewer viewer) {
	super(ActionMessages.CollapsAllAction_label, JavaPluginImages.DESC_ELCL_COLLAPSEALL);
	setToolTipText(ActionMessages.CollapsAllAction_tooltip);
	setDescription(ActionMessages.CollapsAllAction_description);
	PlatformUI.getWorkbench().getHelpSystem().setHelp(this, IJavaHelpContextIds.COLLAPSE_ALL_ACTION);
	Assert.isNotNull(viewer);
	fViewer= viewer;
}
 

/**
 * Creates the context menu for the given object. Gets the action from the
 * actionRegistry and adds the action to the menu.
 * 
 * @param menu
 *            the menu
 * @param object
 *            the object
 */
public void createContextMenu( TreeViewer sourceViewer, Object object,
		IMenuManager menu )
{

	menu.add( new Separator( ) );

	InsertCubeInLayoutAction insertAction = new InsertCubeInLayoutAction( object );
	if ( insertAction.isEnabled( ) )
	{
		menu.add( insertAction );
	}

	super.createContextMenu( sourceViewer, object, menu );

	if ( ( (CubeHandle) object ).canEdit( ) )
	{
		menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS,
				new EditCubeAction( object,
						Messages.getString( "InsertCubeInLayoutAction.menu.text" ) ) ); //$NON-NLS-1$
	}

	menu.insertBefore( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", //$NON-NLS-1$
			new ShowPropertyAction( object ) );

	menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", new Separator( ) ); //$NON-NLS-1$
	IAction action = new RefreshAction( sourceViewer );
	if ( action.isEnabled( ) )
	{
		menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS
				+ "-refresh", action ); //$NON-NLS-1$
	}
}
 

public void init(TreeViewer viewer, IStructuredSelection selection) {
    boolean canWork = !selection.isEmpty() && selection.size() == 1;
    // if
    // (DesignerPlugin.getDefault().getRepositoryService().getProxyRepositoryFactory().isUserReadOnlyOnCurrentProject())
    // {
    // canWork = false;
    // }
    if (canWork) {
        Object o = selection.getFirstElement();
        RepositoryNode node = (RepositoryNode) o;

        switch (node.getType()) {
        case REPOSITORY_ELEMENT:
            if (node.getParent() == null || node.getParent().getContentType() != CamelRepositoryNodeType.repositoryRoutesType) {
                canWork = false;
            }
            // Avoid showing in route test case
            if (node.getObjectType().getType().equals(TEST_CONTAINER)) {
                canWork = false;
            }
            break;
        default:
            canWork = false;
        }
        RepositoryNode parent = node.getParent();
        if (canWork && parent != null && parent instanceof BinRepositoryNode) {
            canWork = false;
        }
    }
    setEnabled(canWork);
}
 

protected void createTreeViewer(Composite parent, int treeStyle) {
	Tree tree = createTree(parent, treeStyle);
	
	treeViewer = new TreeViewerFilterExt(tree);
	TreeViewerUtil.addTreeViewerMouseAutoScroller(treeViewer);
	
	treeElementsFilter = createTreeFilter();
	treeViewer.addFilter(treeElementsFilter);
	
	treeViewer.setAutoExpandLevel(TreeViewer.ALL_LEVELS);
}
 

/**
 * Gathers the checked states of the given widget and its descendants, following a pre-order
 * traversal of the {@link ITreeContentProvider}.
 *
 * @param collectedObjects a writable list of elements (element type: <code>Object</code> )
 * @param treeViewer to be traversed
 * @param parentElement of which to determine the child nodes
 */
protected static void collectAllRosterEntryElement(
    List<Object> collectedObjects, TreeViewer treeViewer, Object parentElement) {

  ITreeContentProvider treeContentProvider =
      (ITreeContentProvider) treeViewer.getContentProvider();

  Object[] objects = treeContentProvider.getChildren(parentElement);

  for (Object object : objects) {
    collectedObjects.add(object);
    collectAllRosterEntryElement(collectedObjects, treeViewer, object);
  }
}
 

protected void toggleHierarchy() {
	TreeViewer treeViewer= getTreeViewer();

	treeViewer.getTree().setRedraw(false);

	Object[] expandedElements= treeViewer.getExpandedElements();
	TypeHierarchyContentProvider contentProvider= (TypeHierarchyContentProvider) treeViewer.getContentProvider();
	treeViewer.setContentProvider(fOtherContentProvider);

	treeViewer.refresh();
	if (fOtherExpandedElements != null) {
		treeViewer.setExpandedElements(fOtherExpandedElements);
	} else {
		treeViewer.expandAll();
	}

	// reveal selection
	Object selectedElement= getSelectedElement();
	if (selectedElement != null)
		getTreeViewer().reveal(selectedElement);
	else
		selectFirstMatch();

	treeViewer.getTree().setRedraw(true);

	fOtherContentProvider= contentProvider;
	fOtherExpandedElements= expandedElements;

	updateStatusFieldText();
}
 

public void createContextMenu( TreeViewer sourceViewer, Object object,
		IMenuManager menu )
{
	// Add new parameter action
	menu.add( new InsertAction( object,
			Messages.getString( "ParameterGroupNodeProvider.Action.ParameterNew" ), //$NON-NLS-1$
			ReportDesignConstants.SCALAR_PARAMETER_ELEMENT ) );

	super.createContextMenu( sourceViewer, object, menu );
	menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS,
			new EditAction( object,
					Messages.getString( "ParameterGroupNodeProvider.Action.ParameterEdit" ) ) ); //$NON-NLS-1$

}
 

private boolean isChangeSetMode() {
    Viewer viewer = getConfiguration().getPage().getViewer();
    if (viewer instanceof TreeViewer) {
    	TreeItem[] items = ((TreeViewer)viewer).getTree().getItems();
    	for (TreeItem item : items) {
    		if (item.getData() instanceof ChangeSetDiffNode) {
    			return true;
    		}
    	}
    }
    return false;
}
 

private void addDoubleClickListener(TreeViewer viewer) {
	viewer.addDoubleClickListener((event) -> {
		//open the object
		if (event.getSelection() instanceof IStructuredSelection) {
			IStructuredSelection selection = (IStructuredSelection) event.getSelection();
			Object object = selection.getFirstElement();
			this.stagingUtil.openEditor(object, this.project, this.repositoryCredentials);
		}
	});
}
 

public CopyNameAction(TreeViewer treeViewer) {
	super(Messages.AbapGitStaging_action_copy);
	updateSelection((IStructuredSelection) treeViewer.getSelection());
	setToolTipText(Messages.AbapGitStaging_action_copy);
	setActionDefinitionId(ActionFactory.COPY.getCommandId());
	setImageDescriptor(PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_TOOL_COPY));

	this.treeViewer = treeViewer;
}
 

public void createContextMenu( TreeViewer sourceViewer, Object object,
			IMenuManager menu )
	{
		PropertyHandle property = (PropertyHandle) object;
		String name = property.getPropertyDefn( ).getName( );

		EditCubeAction action = null;

		if ( name.equals( ICubeModel.DIMENSIONS_PROP ) )
		{
			action = new EditCubeAction( property,
					Messages.getString( "CubeModel.group.edit" ) );//$NON-NLS-1$

		}
		else if ( name.equals( ICubeModel.MEASURE_GROUPS_PROP ) )
		{
			action = new EditCubeAction( property,
					Messages.getString( "CubeModel.summaryfield.edit" ) );//$NON-NLS-1$
		}

		if ( action != null )
			menu.add( action );
		super.createContextMenu( sourceViewer, object, menu );

//		menu.insertBefore( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", //$NON-NLS-1$
//				new ShowPropertyAction( object ) );
//
//		menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", new Separator( ) ); //$NON-NLS-1$
//		menu.insertAfter( IWorkbenchActionConstants.MB_ADDITIONS + "-refresh", new RefreshAction( sourceViewer ) ); //$NON-NLS-1$
	}
 

protected void assertSelected(TreeViewer aTreeViewer, IOutlineNode... expectedSelection) {
	ISelection selection = aTreeViewer.getSelection();
	assertTrue(selection instanceof IStructuredSelection);
	assertEquals(expectedSelection.length, ((IStructuredSelection) selection).size());
	OUTER: for (Iterator<?> i = ((IStructuredSelection) selection).iterator(); i.hasNext();) {
		Object selectedObject = i.next();
		assertTrue(selectedObject instanceof IOutlineNode);
		for (IOutlineNode expectedSelected : expectedSelection) {
			if (nodeComparer.equals((IOutlineNode) selectedObject, expectedSelected))
				continue OUTER;
		}
		fail("Unexpected selection " + selectedObject.toString());
	}
}
 

public void restoreBackup( TreeViewer treeviewer )
{
	for ( int i = 0; i < leafList.size( ); i++ )
	{
		treeviewer.expandToLevel( leafList.get( i ), 1 );
	}
}
 

/**
 * Constructor
 *
 * @param parent
 *            the parent composite
 * @param dataProviderId
 *            the data provider extension point ID.
 * @since 3.0
 */
public AbstractSegmentsStatisticsViewer(Composite parent, @Nullable String dataProviderId) {
    super(parent, false);
    setLabelProvider(new SegmentStoreStatisticsLabelProvider());
    fTablePopupMenuManager = new MenuManager();
    fTablePopupMenuManager.setRemoveAllWhenShown(true);
    fTablePopupMenuManager.addMenuListener(manager -> {
        TreeViewer viewer = getTreeViewer();
        ISelection selection = viewer.getSelection();
        if (selection instanceof IStructuredSelection) {
            IStructuredSelection sel = (IStructuredSelection) selection;
            if (manager != null) {
                appendToTablePopupMenu(manager, sel);
            }
        }
    });
    Menu tablePopup = fTablePopupMenuManager.createContextMenu(getTreeViewer().getTree());
    Tree tree = getTreeViewer().getTree();
    tree.setMenu(tablePopup);
    tree.addDisposeListener(e -> {
        if (fModule != null) {
            fModule.dispose();
        }
    });

    fProviderId = dataProviderId;
}
 

@Override
public void inputChanged(final Viewer viewer, final Object oldInput, final Object newInput) {
	if (viewer instanceof TreeViewer) {
		this.treeViewerRef = Optional.of((TreeViewer) viewer);
	} else {
		this.treeViewerRef = Optional.absent();
	}
	// clear projects cache when input changes
	this.locationProjectsCache.clear();
}