org.netbeans.modules.subversion.Annotator Maven / Gradle / Ivy
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.subversion;
import org.netbeans.modules.subversion.ui.status.StatusAction;
import org.netbeans.modules.subversion.ui.commit.CommitAction;
import org.netbeans.modules.subversion.ui.update.*;
import org.netbeans.modules.subversion.ui.blame.BlameAction;
import org.netbeans.modules.subversion.ui.history.SearchHistoryAction;
import org.openide.util.actions.SystemAction;
import org.openide.util.NbBundle;
import org.openide.util.Lookup;
import org.openide.nodes.Node;
import org.netbeans.modules.subversion.util.SvnUtils;
import org.netbeans.modules.versioning.util.Utils;
import org.netbeans.modules.versioning.spi.VCSContext;
import org.netbeans.modules.versioning.spi.VCSAnnotator;
import org.netbeans.modules.versioning.spi.VersioningSupport;
import javax.swing.*;
import java.util.*;
import java.util.List;
import java.util.regex.Pattern;
import java.text.MessageFormat;
import java.io.File;
import java.awt.*;
import java.util.logging.Level;
import org.netbeans.modules.subversion.ui.properties.SvnPropertiesAction;
import org.netbeans.modules.versioning.util.SystemActionBridge;
import org.netbeans.modules.subversion.client.SvnClientFactory;
import org.netbeans.modules.subversion.options.AnnotationColorProvider;
import org.netbeans.modules.subversion.ui.lock.LockAction;
import org.netbeans.modules.subversion.ui.lock.UnlockAction;
import org.netbeans.modules.subversion.ui.menu.CopyMenu;
import org.netbeans.modules.subversion.ui.menu.DiffMenu;
import org.netbeans.modules.subversion.ui.menu.IgnoreMenu;
import org.netbeans.modules.subversion.ui.menu.PatchesMenu;
import org.netbeans.modules.subversion.ui.menu.UpdateMenu;
import org.netbeans.modules.subversion.ui.menu.WorkingCopyMenu;
import org.netbeans.modules.subversion.ui.properties.VersioningInfoAction;
import org.openide.awt.Actions;
import org.openide.util.ContextAwareAction;
import org.openide.util.ImageUtilities;
import org.openide.util.lookup.Lookups;
/**
* Annotates names for display in Files and Projects view (and possible elsewhere). Uses
* Filesystem support for this feature (to be replaced later in Core by something more generic).
*
* @author Maros Sandor
*/
public class Annotator {
private static final String badgeModified = "org/netbeans/modules/subversion/resources/icons/modified-badge.png"; //NOI18N
private static final String badgeConflicts = "org/netbeans/modules/subversion/resources/icons/conflicts-badge.png"; //NOI18N
private static final String toolTipModified = "![](\"")
" //NOI18N
+ NbBundle.getMessage(Annotator.class, "MSG_Contains_Modified_Locally"); //NOI18N
private static final String toolTipConflict = " " //NOI18N
+ NbBundle.getMessage(Annotator.class, "MSG_Contains_Conflicts"); //NOI18N
private static final int STATUS_TEXT_ANNOTABLE = FileInformation.STATUS_NOTVERSIONED_EXCLUDED |
FileInformation.STATUS_NOTVERSIONED_NEWLOCALLY | FileInformation.STATUS_VERSIONED_UPTODATE |
FileInformation.STATUS_VERSIONED_MODIFIEDLOCALLY | FileInformation.STATUS_VERSIONED_CONFLICT |
FileInformation.STATUS_VERSIONED_REMOVEDLOCALLY | FileInformation.STATUS_VERSIONED_DELETEDLOCALLY |
FileInformation.STATUS_VERSIONED_ADDEDLOCALLY;
private static final Pattern lessThan = Pattern.compile("<"); // NOI18N
public static final String ANNOTATION_REVISION = "revision";
public static final String ANNOTATION_STATUS = "status";
public static final String ANNOTATION_LOCK = "lock";
public static final String ANNOTATION_FOLDER = "folder";
public static final String ANNOTATION_MIME_TYPE = "mime_type";
public static final String ANNOTATION_COMMIT_REVISION = "commit_revision"; //NOI18N
public static final String ANNOTATION_COMMIT_DATE = "date"; //NOI18N
public static final String ANNOTATION_COMMIT_AUTHOR = "author"; //NOI18N
public static final String[] LABELS = new String[] {ANNOTATION_REVISION, ANNOTATION_STATUS, ANNOTATION_LOCK, ANNOTATION_FOLDER, ANNOTATION_MIME_TYPE, ANNOTATION_COMMIT_REVISION,
ANNOTATION_COMMIT_DATE, ANNOTATION_COMMIT_AUTHOR};
public static final String ACTIONS_PATH_PREFIX = "Actions/Subversion/"; // NOI18N
private final FileStatusCache cache;
private MessageFormat format;
private String emptyFormat;
private boolean mimeTypeFlag;
Annotator(Subversion svn) {
this.cache = svn.getStatusCache();
initDefaults();
}
private void initDefaults() {
refresh();
}
public void refresh() {
String string = SvnModuleConfig.getDefault().getAnnotationFormat(); //System.getProperty("netbeans.experimental.svn.ui.statusLabelFormat"); // NOI18N
if (string != null && !string.trim().equals("")) { // NOI18N
mimeTypeFlag = string.indexOf("{mime_type}") > -1;
string = SvnUtils.createAnnotationFormat(string);
if (!SvnUtils.isAnnotationFormatValid(string)) {
Subversion.LOG.log(Level.WARNING, "Bad annotation format, switching to defaults");
string = org.openide.util.NbBundle.getMessage(Annotator.class, "Annotator.defaultFormat"); // NOI18N
mimeTypeFlag = string.contains("{4}");
}
format = new MessageFormat(string);
emptyFormat = format.format(new String[] {"", "", "", "", "", "", "", "", ""} , new StringBuffer(), null).toString().trim();
}
cache.getLabelsCache().setMimeTypeFlag(mimeTypeFlag); // mime labels enabled
}
/**
* Adds rendering attributes to an arbitrary String based on a SVN status. The name is usually a file or folder
* display name and status is usually its SVN status as reported by FileStatusCache.
*
* @param name name to annotate
* @param info status that an object with the given name has
* @param file file this annotation belongs to. It is used to determine sticky tags for textual annotations. Pass
* null if you do not want textual annotations to appear in returned markup
* @return String html-annotated name that can be used in Swing controls that support html rendering. Note: it may
* also return the original name String
*/
public String annotateNameHtml(String name, FileInformation info, File file) {
if(!checkClientAvailable("annotateNameHtml", file == null ? new File[0] : new File[] {file})) {
return name;
}
name = htmlEncode(name);
int status = info.getStatus();
String textAnnotation;
boolean annotationsVisible = VersioningSupport.isTextAnnotationVisible();
if (annotationsVisible && file != null && (status & STATUS_TEXT_ANNOTABLE) != 0) {
if (format != null) {
textAnnotation = formatAnnotation(info, file);
} else {
String lockString = getLockString(info.getStatus());
String lockStringAnnPart = (lockString.isEmpty() ? "" : (lockString + "; "));
String sticky = cache.getLabelsCache().getLabelInfo(file, false).getStickyString();
if (status == FileInformation.STATUS_VERSIONED_UPTODATE && "".equals(sticky)) { //NOI18N
textAnnotation = lockString; // NOI18N
} else if (status == FileInformation.STATUS_VERSIONED_UPTODATE) {
textAnnotation = " [" + lockStringAnnPart + sticky + "]"; // NOI18N
} else if ("".equals(sticky)) { //NOI18N
String statusText = info.getShortStatusText();
if(!statusText.equals("")) {
textAnnotation = " [" + lockStringAnnPart + info.getShortStatusText() + "]"; // NOI18N
} else {
textAnnotation = lockString;
}
} else {
textAnnotation = " [" + info.getShortStatusText() + "; " + lockStringAnnPart + sticky + "]"; // NOI18N
}
}
} else {
textAnnotation = ""; // NOI18N
}
if (textAnnotation.length() > 0) {
textAnnotation = getAnnotationProvider().TEXT_ANNOTATION.getFormat().format(new Object[] { textAnnotation });
}
// aligned with SvnUtils.getComparableStatus
if (0 != (status & FileInformation.STATUS_VERSIONED_CONFLICT_TREE)) {
return getAnnotationProvider().TREECONFLICT_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_CONFLICT)) {
return getAnnotationProvider().CONFLICT_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MERGE)) {
return getAnnotationProvider().MERGEABLE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_DELETEDLOCALLY)) {
return getAnnotationProvider().DELETED_LOCALLY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_REMOVEDLOCALLY)) {
return getAnnotationProvider().REMOVED_LOCALLY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_NEWLOCALLY)) {
return getAnnotationProvider().NEW_LOCALLY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_ADDEDLOCALLY)) {
return getAnnotationProvider().ADDED_LOCALLY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MODIFIEDLOCALLY)) {
return getAnnotationProvider().MODIFIED_LOCALLY_FILE.getFormat().format(new Object [] { name, textAnnotation });
// repository changes - lower annotator priority
} else if (0 != (status & FileInformation.STATUS_VERSIONED_REMOVEDINREPOSITORY)) {
return getAnnotationProvider().REMOVED_IN_REPOSITORY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_NEWINREPOSITORY)) {
return getAnnotationProvider().NEW_IN_REPOSITORY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MODIFIEDINREPOSITORY)) {
return getAnnotationProvider().MODIFIED_IN_REPOSITORY_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_UPTODATE)) {
return getAnnotationProvider().UP_TO_DATE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_EXCLUDED)) {
return getAnnotationProvider().EXCLUDED_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_NOTMANAGED)) {
return name;
} else if (status == FileInformation.STATUS_UNKNOWN) {
return name;
} else {
throw new IllegalArgumentException("Unknown status: " + status); // NOI18N
}
}
/**
* Applies custom format.
*/
private String formatAnnotation(FileInformation info, File file) {
String statusString = ""; // NOI18N
int status = info.getStatus();
if (status != FileInformation.STATUS_VERSIONED_UPTODATE) {
statusString = info.getShortStatusText();
}
String lockString = getLockString(status);
FileStatusCache.FileLabelCache.FileLabelInfo labelInfo;
labelInfo = cache.getLabelsCache().getLabelInfo(file, mimeTypeFlag);
String revisionString = labelInfo.getRevisionString();
String binaryString = labelInfo.getBinaryString();
String stickyString = labelInfo.getStickyString();
String lastRev = labelInfo.getLastRevisionString();
String lastDate = labelInfo.getLastDateString();
String lastAuthor = labelInfo.getLastAuthorString();
Object[] arguments = new Object[] {
revisionString,
statusString,
stickyString,
lockString,
binaryString,
lastRev,
lastDate,
lastAuthor
};
String annotation = format.format(arguments, new StringBuffer(), null).toString().trim();
if(annotation.equals(emptyFormat)) {
return "";
} else {
return " " + annotation;
}
}
private String annotateFolderNameHtml(String name, FileInformation info, File file) {
name = htmlEncode(name);
int status = info.getStatus();
String textAnnotation;
boolean annotationsVisible = VersioningSupport.isTextAnnotationVisible();
if (annotationsVisible && file != null && (status & FileInformation.STATUS_MANAGED) != 0) {
if (format != null) {
textAnnotation = formatAnnotation(info, file);
} else {
String sticky = cache.getLabelsCache().getLabelInfo(file, false).getStickyString();
if (status == FileInformation.STATUS_VERSIONED_UPTODATE && "".equals(sticky)) { //NOI18N
textAnnotation = ""; // NOI18N
} else if (status == FileInformation.STATUS_VERSIONED_UPTODATE) {
textAnnotation = " [" + sticky + "]"; // NOI18N
} else if ("".equals(sticky)) { //NOI18N
String statusText = info.getShortStatusText();
if(!statusText.equals("")) { // NOI18N
textAnnotation = " [" + info.getShortStatusText() + "]"; // NOI18N
} else {
textAnnotation = ""; // NOI18N
}
} else {
textAnnotation = " [" + info.getShortStatusText() + "; " + sticky + "]"; // NOI18N
}
}
} else {
textAnnotation = ""; // NOI18N
}
if (textAnnotation.length() > 0) {
textAnnotation = getAnnotationProvider().TEXT_ANNOTATION.getFormat().format(new Object[] { textAnnotation });
}
if (status == FileInformation.STATUS_UNKNOWN) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_REMOVEDLOCALLY)) {
return name;
} else if (match(status, FileInformation.STATUS_NOTVERSIONED_NEWLOCALLY)) {
return getAnnotationProvider().UP_TO_DATE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (match(status, FileInformation.STATUS_VERSIONED_ADDEDLOCALLY)) {
return getAnnotationProvider().UP_TO_DATE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (match(status, FileInformation.STATUS_VERSIONED_UPTODATE)) {
return getAnnotationProvider().UP_TO_DATE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (match(status, FileInformation.STATUS_NOTVERSIONED_EXCLUDED)) {
return getAnnotationProvider().EXCLUDED_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (match(status, FileInformation.STATUS_VERSIONED_DELETEDLOCALLY)) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_NEWINREPOSITORY)) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_MODIFIEDINREPOSITORY)) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_REMOVEDINREPOSITORY)) {
return name;
} else if (match(status, FileInformation.STATUS_NOTVERSIONED_NOTMANAGED)) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_MERGE)) {
return name;
} else if (match(status, FileInformation.STATUS_VERSIONED_MODIFIEDLOCALLY)) {
return getAnnotationProvider().UP_TO_DATE_FILE.getFormat().format(new Object [] { name, textAnnotation });
} else if (match(status, FileInformation.STATUS_VERSIONED_CONFLICT)) {
return name;
} else {
throw new IllegalArgumentException("Unknown status: " + status); // NOI18N
}
}
private static boolean match(int status, int mask) {
return (status & mask) != 0;
}
private String htmlEncode(String name) {
if (name.indexOf('<') == -1) return name;
return lessThan.matcher(name).replaceAll("<"); // NOI18N
}
public String annotateNameHtml(File file, FileInformation info) {
return annotateNameHtml(file.getName(), info, file);
}
public String annotateNameHtml(String name, VCSContext context, int includeStatus) {
if(!checkClientAvailable("annotateNameHtml", context.getRootFiles().toArray(new File[context.getRootFiles().size()]))) { //NOI18N
return name;
}
FileInformation mostImportantInfo = null;
File mostImportantFile = null;
boolean folderAnnotation = false;
for (File file : context.getRootFiles()) {
if (SvnUtils.isPartOfSubversionMetadata(file)) {
// no need to handle .svn files, eliminates some warnings as 'no repository url found for managed file .svn'
// happens e.g. when annotating a Project folder
continue;
}
FileInformation info = cache.getCachedStatus(file);
if (info == null) {
// status not in cache, plan refresh
File parentFile = file.getParentFile();
Subversion.LOG.log(Level.FINE, "null cached status for: {0} in {1}", new Object[] {file, parentFile});
cache.refreshAsync(file);
info = new FileInformation(FileInformation.STATUS_VERSIONED_UPTODATE, false);
}
int status = info.getStatus();
if ((status & includeStatus) == 0) continue;
if (isMoreImportant(info, mostImportantInfo)) {
mostImportantInfo = info;
mostImportantFile = file;
folderAnnotation = file.isDirectory();
}
}
if (folderAnnotation == false && context.getRootFiles().size() > 1) {
folderAnnotation = !Utils.isFromMultiFileDataObject(context);
}
if (mostImportantInfo == null) return null;
return folderAnnotation ?
annotateFolderNameHtml(name, mostImportantInfo, mostImportantFile) :
annotateNameHtml(name, mostImportantInfo, mostImportantFile);
}
private boolean isMoreImportant(FileInformation a, FileInformation b) {
if (b == null) return true;
if (a == null) return false;
return SvnUtils.getComparableStatus(a.getStatus()) < SvnUtils.getComparableStatus(b.getStatus());
}
String annotateName(String name, Set files) {
return null;
}
/**
* Returns array of versioning actions that may be used to construct a popup menu. These actions
* will act on the supplied context.
*
* @param ctx context similar to {@link org.openide.util.ContextAwareAction#createContextAwareInstance(org.openide.util.Lookup)}
* @param destination
* @return Action[] array of versioning actions that may be used to construct a popup menu. These actions
* will act on currently activated nodes.
*/
public static Action [] getActions(VCSContext ctx, VCSAnnotator.ActionDestination destination) {
List actions = new ArrayList(20);
File[] files = ctx.getRootFiles().toArray(new File[ctx.getRootFiles().size()]);
boolean noneVersioned;
if (EventQueue.isDispatchThread() && !Subversion.getInstance().getStatusCache().ready()) {
noneVersioned = true;
Subversion.LOG.log(Level.INFO, "Cache not yet initialized, showing default actions"); //NOI18N
} else {
noneVersioned = isNothingVersioned(files);
}
if (destination == VCSAnnotator.ActionDestination.MainMenu) {
if (noneVersioned) {
// XXX use Actions.forID
Action a = Utils.getAcceleratedAction("Actions/Subversion/org-netbeans-modules-subversion-ui-checkout-CheckoutAction.instance");
if(a != null) actions.add(a);
a = Utils.getAcceleratedAction("Actions/Subversion/org-netbeans-modules-subversion-ui-project-ImportAction.instance");
if(a instanceof ContextAwareAction) {
a = ((ContextAwareAction)a).createContextAwareInstance(Lookups.fixed((Object[]) files));
}
if(a != null) actions.add(a);
} else {
actions.add(SystemAction.get(StatusAction.class));
actions.add(new DiffMenu(destination, null));
actions.add(SystemAction.get(CommitAction.class));
actions.add(new UpdateMenu(destination, null));
actions.add(SystemAction.get(RevertModificationsAction.class));
actions.add(SystemAction.get(BlameAction.class));
actions.add(SystemAction.get(SearchHistoryAction.class));
actions.add(SystemAction.get(ResolveConflictsAction.class));
actions.add(null);
actions.add(new IgnoreMenu(null, null));
actions.add(new PatchesMenu(destination, null));
actions.add(null);
actions.add(new CopyMenu(destination, null));
Action a = Utils.getAcceleratedAction("Actions/Subversion/org-netbeans-modules-subversion-ui-checkout-CheckoutAction.instance");
if(a != null) actions.add(a);
actions.add(null);
SystemAction unlockAction = SystemAction.get(UnlockAction.class);
if (unlockAction.isEnabled()) {
actions.add(unlockAction);
} else {
actions.add(SystemAction.get(LockAction.class));
}
actions.add(new WorkingCopyMenu(destination, null));
actions.add(SystemAction.get(VersioningInfoAction.class));
actions.add(SystemAction.get(SvnPropertiesAction.class));
}
Utils.setAcceleratorBindings(ACTIONS_PATH_PREFIX, actions.toArray(new Action[0]));
} else {
ResourceBundle loc = NbBundle.getBundle(Annotator.class);
Lookup context = ctx.getElements();
if (noneVersioned) {
Action a = Actions.forID("Subversion", "org.netbeans.modules.subversion.ui.project.ImportAction");
if(a instanceof ContextAwareAction) {
a = ((ContextAwareAction)a).createContextAwareInstance(Lookups.fixed((Object[]) files));
}
if(a != null) actions.add(a);
} else {
Node[] nodes = ctx.getElements().lookupAll(Node.class).toArray(new Node[0]);
actions.add(SystemActionBridge.createAction(SystemAction.get(StatusAction.class), loc.getString("CTL_PopupMenuItem_Status"), context));
actions.add(new DiffMenu(destination, context));
actions.add(SystemActionBridge.createAction(SystemAction.get(CommitAction.class), loc.getString("CTL_PopupMenuItem_Commit"), context));
actions.add(new UpdateMenu(destination, context));
actions.add(SystemActionBridge.createAction(SystemAction.get(RevertModificationsAction.class), loc.getString("CTL_PopupMenuItem_GetClean"), context));
actions.add(SystemActionBridge.createAction(SystemAction.get(BlameAction.class),
((BlameAction)SystemAction.get(BlameAction.class)).visible(nodes)
? loc.getString("CTL_PopupMenuItem_HideAnnotations")
: loc.getString("CTL_PopupMenuItem_ShowAnnotations"), context));
actions.add(SystemActionBridge.createAction(SystemAction.get(SearchHistoryAction.class), loc.getString("CTL_PopupMenuItem_SearchHistory"), context));
actions.add(SystemActionBridge.createAction(SystemAction.get(ResolveConflictsAction.class), loc.getString("CTL_PopupMenuItem_ResolveConflicts"), context));
actions.add(null);
actions.add(new IgnoreMenu(context, nodes));
actions.add(new PatchesMenu(destination, context));
actions.add(null);
actions.add(new CopyMenu(destination, context));
Action a = Actions.forID("Subversion", "org.netbeans.modules.subversion.ui.checkout.CheckoutAction");
if(a != null) actions.add(a);
actions.add(null);
SystemActionBridge unlockAction = SystemActionBridge.createAction(SystemAction.get(UnlockAction.class), loc.getString("CTL_PopupMenuItem_Unlock"), context);
if (unlockAction.isEnabled()) {
actions.add(unlockAction);
} else {
actions.add(SystemActionBridge.createAction(SystemAction.get(LockAction.class), loc.getString("CTL_PopupMenuItem_Lock"), context));
}
actions.add(new WorkingCopyMenu(destination, context));
actions.add(SystemActionBridge.createAction(
SystemAction.get(VersioningInfoAction.class),
loc.getString("CTL_PopupMenuItem_VersioningInfo"), context));
actions.add(SystemActionBridge.createAction(
SystemAction.get(SvnPropertiesAction.class),
loc.getString("CTL_PopupMenuItem_Properties"), context));
}
}
return actions.toArray(new Action[0]);
}
private static boolean isNothingVersioned(File[] files) {
for (File file : files) {
if (SvnUtils.isManaged(file)) return false;
}
return true;
}
public Image annotateIcon(Image icon, VCSContext context, int includeStatus) {
if(!checkClientAvailable("annotateIcon", context.getRootFiles().toArray(new File[context.getRootFiles().size()]))) { //NOI18N
return null;
}
boolean folderAnnotation = false;
for (File file : context.getRootFiles()) {
if (file.isDirectory()) {
folderAnnotation = true;
break;
}
}
if (folderAnnotation == false && context.getRootFiles().size() > 1) {
folderAnnotation = !Utils.isFromMultiFileDataObject(context);
}
if (folderAnnotation == false) {
return annotateFileIcon(context, icon, includeStatus);
} else {
return annotateFolderIcon(context, icon);
}
}
private Image annotateFileIcon(VCSContext context, Image icon, int includeStatus) {
FileInformation mostImportantInfo = null;
List filesToRefresh = new LinkedList();
for (File file : context.getRootFiles()) {
FileInformation info = cache.getCachedStatus(file);
if (info == null) {
File parentFile = file.getParentFile();
Subversion.LOG.log(Level.FINE, "null cached status for: {0} in {1}", new Object[] {file, parentFile});
filesToRefresh.add(file);
info = new FileInformation(FileInformation.STATUS_VERSIONED_UPTODATE, false);
}
int status = info.getStatus();
if ((status & includeStatus) == 0) continue;
if (isMoreImportant(info, mostImportantInfo)) {
mostImportantInfo = info;
}
}
cache.refreshAsync(filesToRefresh);
if(mostImportantInfo == null) return null;
String statusText = null;
int status = mostImportantInfo.getStatus();
if (0 != (status & FileInformation.STATUS_VERSIONED_CONFLICT_TREE)) {
statusText = getAnnotationProvider().TREECONFLICT_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_CONFLICT)) {
statusText = getAnnotationProvider().CONFLICT_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MERGE)) {
statusText = getAnnotationProvider().MERGEABLE_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_DELETEDLOCALLY)) {
statusText = getAnnotationProvider().DELETED_LOCALLY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_REMOVEDLOCALLY)) {
statusText = getAnnotationProvider().REMOVED_LOCALLY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_NEWLOCALLY)) {
statusText = getAnnotationProvider().NEW_LOCALLY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_ADDEDLOCALLY)) {
statusText = getAnnotationProvider().ADDED_LOCALLY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MODIFIEDLOCALLY)) {
statusText = getAnnotationProvider().MODIFIED_LOCALLY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
// repository changes - lower annotator priority
} else if (0 != (status & FileInformation.STATUS_VERSIONED_REMOVEDINREPOSITORY)) {
statusText = getAnnotationProvider().REMOVED_IN_REPOSITORY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_NEWINREPOSITORY)) {
statusText = getAnnotationProvider().NEW_IN_REPOSITORY_FILE.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_MODIFIEDINREPOSITORY)) {
statusText = getAnnotationProvider().MODIFIED_IN_REPOSITORY_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_VERSIONED_UPTODATE)) {
statusText = null;
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_EXCLUDED)) {
statusText = getAnnotationProvider().EXCLUDED_FILE_TOOLTIP.getFormat().format(new Object [] { mostImportantInfo.getStatusText() });
} else if (0 != (status & FileInformation.STATUS_NOTVERSIONED_NOTMANAGED)) {
statusText = null;
} else if (status == FileInformation.STATUS_UNKNOWN) {
statusText = null;
} else {
throw new IllegalArgumentException("Unknown status: " + status); // NOI18N
}
return statusText != null ? ImageUtilities.addToolTipToImage(icon, statusText) : null; // NOI18
}
private Image annotateFolderIcon(VCSContext context, Image icon) {
List filesToRefresh = new LinkedList();
for (Iterator i = context.getRootFiles().iterator(); i.hasNext();) {
File file = (File) i.next();
FileInformation info = cache.getCachedStatus(file);
if (info == null) {
filesToRefresh.add(file);
}
}
cache.refreshAsync(filesToRefresh);
if(cache.ready()) {
if(cache.containsFiles(context.getRootFiles(), FileInformation.STATUS_VERSIONED_CONFLICT, false)) {
return getBadge(badgeConflicts, icon, toolTipConflict);
} else if(cache.containsFiles(context.getRootFiles(), FileInformation.STATUS_LOCAL_CHANGE, false)) {
return getBadge(badgeModified, icon, toolTipModified);
}
}
return icon;
}
private Image getBadge(String badgePath, Image origIcon, String toolTip) {
Image ret = ImageUtilities.assignToolTipToImage(ImageUtilities.loadImage(badgePath, true), toolTip);
ret = ImageUtilities.mergeImages(origIcon, ret, 16, 9);
return ret;
}
private boolean clientInitStarted;
private boolean checkClientAvailable (String methodName, final File[] files) {
boolean available = true;
if (!SvnClientFactory.isInitialized() && EventQueue.isDispatchThread()) {
if (!clientInitStarted) {
clientInitStarted = true;
Subversion.getInstance().getRequestProcessor().post(new Runnable() {
@Override
public void run() {
SvnClientFactory.init();
Subversion.getInstance().refreshAllAnnotations();
}
});
}
Subversion.LOG.log(Level.FINE, " skipping {0} due to not yet initialized client", methodName); //NOI18N
available = false;
} else if(!SvnClientFactory.isClientAvailable()) {
Subversion.LOG.log(Level.FINE, " skipping {0} due to missing client", methodName); //NOI18N
available = false;
}
return available;
}
private AnnotationColorProvider getAnnotationProvider() {
return AnnotationColorProvider.getInstance();
}
private String getLockString (int status) {
String lockString = ""; //NOI18N
if ((status & FileInformation.STATUS_LOCKED) != 0) {
lockString = "K"; //NOI18N
} else if ((status & FileInformation.STATUS_LOCKED_REMOTELY) != 0) {
lockString = "O"; //NOI18N
}
return lockString;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy