Public Git Hosting - EMFCompare2.git/blob - plugins/org.eclipse.emf.compare.rcp.ui/src/org/eclipse/emf/compare/rcp/ui/internal/structuremergeviewer/filters/StructureMergeViewerFilter.java

1 /*******************************************************************************

4 * are made available under the terms of the Eclipse Public License v1.0

5 * which accompanies this distribution, and is available at

6 * http://www.eclipse.org/legal/epl-v10.html

8 * Contributors:

9 * Obeo - initial API and implementation

10 *******************************************************************************/

package org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters;

import static com.google.common.base.Predicates.alwaysFalse;

import static com.google.common.base.Predicates.not;

import static com.google.common.base.Predicates.or;

import static com.google.common.collect.Iterables.any;

import static com.google.common.collect.Sets.newLinkedHashSet;

import com.google.common.base.Predicate;

import com.google.common.collect.ImmutableSet;

import com.google.common.collect.Iterables;

import com.google.common.eventbus.EventBus;

24 import java.util.Collection;

25 import java.util.Set;

import org.eclipse.emf.common.notify.Adapter;

import org.eclipse.emf.common.notify.Notifier;

import org.eclipse.emf.compare.Conflict;

import org.eclipse.emf.compare.Match;

import org.eclipse.emf.compare.MatchResource;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.filters.impl.DifferenceFilterChange;

import org.eclipse.emf.compare.rcp.ui.internal.structuremergeviewer.groups.provider.GroupItemProviderAdapter;

import org.eclipse.emf.compare.rcp.ui.structuremergeviewer.filters.IDifferenceFilter;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.edit.tree.TreeNode;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerFilter;

40 /**

41 * This will be used by the structure viewer to filter out its list of differences according to a number of

42 * provided predicates.

43 *

44 * Note that this filter acts as an "OR" predicate between all provided ones, and that filters are

45 * "exclude" filters. Basically, that means if the user selects two filters, any difference that applies for

46 * any of these two filters will be hidden from the view, contrarily to "classic" {@link ViewerFilter}

47 * that act as "AND" predicates for "include" filters, forcing any displayed element to meet the criterion of

48 * all provided filters.

49 *

50 *

51 * @author <a href="mailto:laurent.goubet@obeo.fr">Laurent Goubet</a>

52 * @since 4.0

53 */

54 public class StructureMergeViewerFilter extends ViewerFilter {

56 /** A predicate use by default that always returns false. */

        public static final Predicate<? super EObject> DEFAULT_PREDICATE = alwaysFalse();

59 /** The set of predicates known by this filter. */

        private final Set<Predicate<? super EObject>> predicates;

62 /** The set of selected filters known by this filter. */

63 private final Set<IDifferenceFilter> selectedDifferenceFilters;

65 /** The set of unselected filters known by this filter. */

66 private final Set<IDifferenceFilter> unselectedDifferenceFilters;

68 /** The {@link EventBus} associated with this filter. */

69 private final EventBus eventBus;

71 /**

72 * The predicate used by this StructureMergeViewerFilter.

73 */

        private final Predicate<? super EObject> viewerPredicate = new Predicate<EObject>() {

75 public boolean apply(EObject eObject) {

76 final boolean ret;

                        if (aggregatedPredicate.apply(eObject)) {

                                Collection<EObject> eContents = eObject.eContents();

                                if (!eContents.isEmpty() && eObject instanceof TreeNode) {

                                        EObject data = ((TreeNode)eObject).getData();

                                        if (data instanceof Match || data instanceof Conflict || data instanceof MatchResource) {

                                                ret = any(eContents, viewerPredicate);

83 } else {

84 ret = true;

85 }

86 } else {

87 ret = true;

88 }

89 } else {

90 ret = false;

91 }

92 return ret;

93 }

94 };

96 /**

97 * A predicate that aggregates the selected state predicates of selected filters and the unselected state

98 * predicates of unselected filters.

99 */

        private Predicate<? super EObject> aggregatedPredicate;

101

102 /**

103 * Constructs the difference filter.

104 *

105 * @param eventBus

106 * The {@link EventBus} which will be associated with this filter.

107 */

108 public StructureMergeViewerFilter(EventBus eventBus) {

109 this.eventBus = eventBus;

                this.predicates = newLinkedHashSet();

                this.selectedDifferenceFilters = newLinkedHashSet();

                this.unselectedDifferenceFilters = newLinkedHashSet();

113 this.aggregatedPredicate = DEFAULT_PREDICATE;

114 }

115

116 /**

117 * {@inheritDoc}

118 *

119 * @see org.eclipse.jface.viewers.ViewerFilter#select(org.eclipse.jface.viewers.Viewer, java.lang.Object,

120 * java.lang.Object)

121 */

122 @Override

        public boolean select(Viewer viewer, Object parentElement, Object element) {

                if (predicates.isEmpty()) {

125 return true;

126 }

127

128 final boolean result;

129 if (element instanceof GroupItemProviderAdapter) {

                        Collection<?> children = ((GroupItemProviderAdapter)element).getChildren(element);

                        result = any(Iterables.filter(children, EObject.class), viewerPredicate);

                } else if (element instanceof Adapter) {

                        Notifier notifier = ((Adapter)element).getTarget();

134 if (notifier instanceof EObject) {

135 EObject eObject = (EObject)notifier;

                                result = viewerPredicate.apply(eObject);

137 } else {

138 result = true;

139 }

140 } else {

141 result = true;

142 }

143

144 return result;

145 }

146

147 /**

148 * Add the predicate of the given {@link IDifferenceFilter}.

149 *

150 * @param filter

151 * The given {@link IDifferenceFilter}.

152 */

153 public void addFilter(IDifferenceFilter filter) {

                boolean changed = predicates.remove(filter.getPredicateWhenUnselected());

                changed |= predicates.add(filter.getPredicateWhenSelected());

156

                changed |= selectedDifferenceFilters.add(filter);

                changed |= unselectedDifferenceFilters.remove(filter);

159

160 if (changed) {

161 aggregatedPredicate = computeAggregatedPredicate();

                        eventBus.post(new DifferenceFilterChange(aggregatedPredicate, selectedDifferenceFilters,

163 unselectedDifferenceFilters));

164 }

165 }

166

167 /**

168 * Computes the aggregated predicates composed of selected state predicates of selected filters and

169 * unselected state predicates of unselected filters.

170 *

171 * @return an aggregated predicates composed of selected state predicates of selected filters and

172 * unselected state predicates of unselected filters.

173 */

        private Predicate<? super EObject> computeAggregatedPredicate() {

                return not(or(predicates));

176 }

177

178 /**

179 * Remove the predicate of the given {@link IDifferenceFilter}.

180 *

181 * @param filter

182 * The given {@link IDifferenceFilter}.

183 */

184 public void removeFilter(IDifferenceFilter filter) {

                boolean changed = predicates.add(filter.getPredicateWhenUnselected());

                changed |= predicates.remove(filter.getPredicateWhenSelected());

187

                changed |= unselectedDifferenceFilters.add(filter);

                changed |= selectedDifferenceFilters.remove(filter);

190

191 if (changed) {

192 aggregatedPredicate = computeAggregatedPredicate();

                        eventBus.post(new DifferenceFilterChange(aggregatedPredicate, selectedDifferenceFilters,

194 unselectedDifferenceFilters));

195 }

196 }

197

198 /**

199 * Init this StructureMergeViewerFilter.

200 *

201 * @param selectedFilters

202 * the set of selected filters known by this filter.

203 * @param unselectedFilters

204 * the set of unselected filters known by this filter.

205 */

        public void init(Collection<IDifferenceFilter> selectedFilters,

207 Collection<IDifferenceFilter> unselectedFilters) {

208 boolean changed = false;

209

                if (!predicates.isEmpty()) {

211 predicates.clear();

212 changed = true;

213 }

214

215 for (IDifferenceFilter filter : selectedFilters) {

                        changed |= predicates.add(filter.getPredicateWhenSelected());

                        changed |= selectedDifferenceFilters.add(filter);

218 }

219 for (IDifferenceFilter filter : unselectedFilters) {

                        changed |= predicates.add(filter.getPredicateWhenUnselected());

                        changed |= unselectedDifferenceFilters.add(filter);

222 }

223

224 if (changed) {

225 aggregatedPredicate = computeAggregatedPredicate();

                        eventBus.post(new DifferenceFilterChange(aggregatedPredicate, selectedDifferenceFilters,

227 unselectedDifferenceFilters));

228 }

229 }

230

231 /**

232 * Returns the set of selected filters known by this filter.

233 *

234 * @return the selectedDifferenceFilters the set of selected filters known by this filter.

235 */

        public Set<IDifferenceFilter> getSelectedDifferenceFilters() {

237 return selectedDifferenceFilters;

238 }

239

240 /**

241 * Returns the set of unselected filters known by this viewer.

242 *

243 * @return the unselectedDifferenceFilters the set of unselected filters known by this viewer.

244 */

        public Set<IDifferenceFilter> getUnSelectedDifferenceFilters() {

                return ImmutableSet.copyOf(unselectedDifferenceFilters);

247 }

248

249 /**

250 * Returns the predicate that aggregates the selected state predicates of selected filters and the

251 * unselected state predicates of unselected filters.

252 *

253 * @return the predicate that aggregates the selected state predicates of selected filters and the

254 * unselected state predicates of unselected filters.

255 */

        public Predicate<? super EObject> getAggregatedPredicate() {

257 return aggregatedPredicate;

258 }

259 }