← Back to branch summary

~piastucki/bzr-eclipse/execute-bit

« back to all changes in this revision

Viewing changes to org.vcs.bazaar.eclipse.ui/src/org/vcs/bazaar/eclipse/ui/markers/NewFileMarker.java

  • Committer: Guillermo Gonzalez
  • Date: 2010-02-02 06:40:31 UTC
  • mfrom: (219 trunk)
  • mto: This revision was merged to the branch mainline in revision 223.
  • Revision ID: guillo.gonzo@gmail.com-20100202064031-r0hch2h8bq67y1sx
merge with trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
org.vcs.bazaar.eclipse.ui/src/org/vcs/bazaar/eclipse/ui/markers/NewFileMarker.java
 
1
/**
 
2
 * LICENSE + COPYRIGHT
 
3
 */
 
4
package org.vcs.bazaar.eclipse.ui.markers;
 
5
 
 
6
import java.util.Collection;
 
7
import java.util.HashSet;
 
8
import java.util.Set;
 
9
 
 
10
import org.eclipse.core.resources.IMarker;
 
11
import org.eclipse.core.resources.IResource;
 
12
import org.eclipse.core.resources.ResourcesPlugin;
 
13
import org.eclipse.core.resources.WorkspaceJob;
 
14
import org.eclipse.core.runtime.CoreException;
 
15
import org.eclipse.core.runtime.IProgressMonitor;
 
16
import org.eclipse.core.runtime.IStatus;
 
17
import org.eclipse.core.runtime.Status;
 
18
import org.eclipse.core.runtime.jobs.ISchedulingRule;
 
19
import org.eclipse.core.runtime.jobs.Job;
 
20
import org.vcs.bazaar.eclipse.EclipseBazaarCore;
 
21
import org.vcs.bazaar.eclipse.core.listeners.BzrChangeStateEvent;
 
22
import org.vcs.bazaar.eclipse.core.listeners.IResourceStateListener;
 
23
import org.vcs.bazaar.eclipse.core.model.IBzrResourceStatus;
 
24
import org.vcs.bazaar.eclipse.core.utils.ResourceUtil;
 
25
import org.vcs.bazaar.eclipse.ui.EclipseBazaarUI;
 
26
import org.vcs.bazaar.eclipse.ui.preferences.BazaarPreferenceConstants;
 
27
 
 
28
/**
 
29
 * Mark newly created files as not being under version control.
 
30
 * 
 
31
 * @author johan.walles@gmail.com
 
32
 */
 
33
public class NewFileMarker implements IResourceStateListener {
 
34
        
 
35
        private final static int INTERESTING_CHANGES = BzrChangeStateEvent.BRANCH_STATE_MODIFY 
 
36
                                                                                                | BzrChangeStateEvent.WT_STATE_MODIFY
 
37
                                                                                                | BzrChangeStateEvent.RESOURCE_MODIFY;
 
38
        
 
39
    /**
 
40
     * Create a background job that can be run to mark resources not handled by Bazaar.
 
41
     * @param resources The resources to check.  Those that are unhandled will be marked.
 
42
     * @return The resource checking-and-marking job.
 
43
     */
 
44
    private WorkspaceJob createMarkJob(final Set<IResource> resources) {
 
45
        return new WorkspaceJob("[Bazaar] Creating unhandled files markers") {
 
46
            /**
 
47
             * Finds out which resources are files not under Bazaar's control.
 
48
             * @param allResources The resources to check.
 
49
             * @return A set of files not under Bazaar's control.
 
50
             * @throws CoreException When status fetching fails
 
51
             */
 
52
            private Set<IResource> getUnhandledFiles(Set<IResource> allResources) throws CoreException {
 
53
                Set<IResource> result = new HashSet<IResource>();
 
54
                
 
55
                // Collect all unhandled resources
 
56
                for (IResource resource : allResources) {
 
57
                    if (resource.getType() != IResource.FILE) {
 
58
                        // We're only interested in files
 
59
                        continue;
 
60
                    }
 
61
                    if (resource.isDerived()) {
 
62
                        // Derived resources aren't supposed to be handled by Bazaar
 
63
                        continue;
 
64
                    }
 
65
                    if (resource.isLinked(IResource.CHECK_ANCESTORS)) {
 
66
                        // Linked resources should be handled at their actual location,
 
67
                        // not here
 
68
                        continue;
 
69
                    }
 
70
                    IBzrResourceStatus status =
 
71
                        EclipseBazaarCore.getDefault().getStatusCacheManager().getStatus(resource);
 
72
                    if (status.isUnknown()) {
 
73
                        result.add(resource);
 
74
                    }
 
75
                }
 
76
                
 
77
                return result;
 
78
            }
 
79
            
 
80
            @Override
 
81
            public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
 
82
                monitor.beginTask("[Bazaar] Creating unhandled files markers",
 
83
                                  resources.size() * 2);
 
84
                Set<IResource> unhandledFiles = getUnhandledFiles(resources);
 
85
                if (unhandledFiles.size() == 0) {
 
86
                    return Status.OK_STATUS;
 
87
                }
 
88
                monitor.worked(resources.size());
 
89
                for (IResource unhandled : unhandledFiles) {
 
90
                        // FIXME: use a multi rule for all the projects involded in the state change event.
 
91
                        ISchedulingRule rule = ResourcesPlugin.getWorkspace().getRuleFactory().markerRule(unhandled);
 
92
                        getJobManager().beginRule(rule, monitor);
 
93
                        IMarker marker = null;
 
94
                        IMarker[] markers = unhandled.findMarkers(IMarker.MARKER, true, IResource.DEPTH_ZERO);
 
95
                        for (IMarker aMarker : markers) {
 
96
                                                if(aMarker.getAttribute("bazaar_unhanlded", false)) {
 
97
                                                        marker = aMarker;
 
98
                                                        break;
 
99
                                                }
 
100
                                        }
 
101
                        if(marker == null) {
 
102
                                marker = unhandled.createMarker(EclipseBazaarUI.getPluginId() + ".marker");
 
103
                                marker.setAttribute(IMarker.MESSAGE, "Local addition not under Bazaar control");
 
104
                        marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
 
105
                        marker.setAttribute(IMarker.LOCATION, "");
 
106
                        marker.setAttribute("bazaar_unhanlded", true);
 
107
                        }
 
108
                    monitor.worked(1);
 
109
                    getJobManager().endRule(rule);
 
110
                }
 
111
                return Status.OK_STATUS;
 
112
            }
 
113
 
 
114
        };
 
115
    }
 
116
    
 
117
 
 
118
        private WorkspaceJob createUnMarkJob(final HashSet<IResource> resources) {
 
119
                return new WorkspaceJob("[Bazaar] Cleaning unhandled files markers") {
 
120
                        @Override
 
121
                        public IStatus runInWorkspace(IProgressMonitor monitor) throws CoreException {
 
122
                        for (IResource resource : resources) {
 
123
                                if(!resource.isAccessible() || !ResourceUtil.shouldHandle(resource)) {
 
124
                                        continue;
 
125
                                }
 
126
                                ISchedulingRule rule = ResourcesPlugin.getWorkspace().getRuleFactory().markerRule(resource);
 
127
                                getJobManager().beginRule(rule, monitor);
 
128
                                IMarker[] markers = resource.findMarkers(IMarker.MARKER, true, IResource.DEPTH_ZERO);
 
129
                                for (IMarker aMarker : markers) {
 
130
                                                if(aMarker.getAttribute("bazaar_unhanlded", false)) {
 
131
                                                        aMarker.delete();
 
132
                                                }
 
133
                                        }
 
134
                                monitor.worked(1);
 
135
                                getJobManager().endRule(rule);
 
136
                        }
 
137
                        return Status.OK_STATUS;
 
138
                        }
 
139
                };
 
140
                
 
141
        }
 
142
    
 
143
    public void resourceStateChanged(BzrChangeStateEvent event) {
 
144
        boolean enabled = isEnabled();
 
145
        if (!enabled) {
 
146
                Collection<IResource> resources = event.getResources();
 
147
                if(resources == null || resources.size() == 0) {
 
148
                    return;
 
149
                }
 
150
                WorkspaceJob job = createUnMarkJob(new HashSet<IResource>(resources));
 
151
                job.setPriority(Job.DECORATE);
 
152
                job.setSystem(false);
 
153
                job.schedule(600);
 
154
        } else if((event.getType() & INTERESTING_CHANGES) > 0) {
 
155
                Collection<IResource> resources = event.getResources();
 
156
                if(resources == null || resources.size() == 0) {
 
157
                    return;
 
158
                }
 
159
                WorkspaceJob job = createMarkJob(new HashSet<IResource>(resources));
 
160
                job.setPriority(Job.DECORATE);
 
161
                job.setSystem(false);
 
162
                
 
163
                // FIXME: I'm using 600 here just because that's what used in
 
164
                // AbstractResourceChangeListener.  Is there a better value for this?
 
165
                // johan.walles@gmail.com 2008aug03
 
166
                job.schedule(600);
 
167
        }
 
168
    }
 
169
 
 
170
        private Boolean isEnabled() {
 
171
                return EclipseBazaarUI.getDefault().getPreferenceStore().getBoolean(BazaarPreferenceConstants.NOT_VERSIONED_MARKER);
 
172
        }
 
173
 
 
174
}