org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/repository/RepositoriesViewLabelProvider.java

   1 /*******************************************************************************
   2  * Copyright (c) 2010 SAP AG.
   3  * All rights reserved. This program and the accompanying materials
   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
   7  *
   8  * Contributors:
   9  *    Mathias Kinzler (SAP AG) - initial implementation
  10  *******************************************************************************/
  11 package org.eclipse.egit.ui.internal.repository;
  12
  13 import java.io.File;
  14 import java.io.IOException;
  15 import java.util.HashMap;
  16 import java.util.Map;
  17
  18 import org.eclipse.egit.ui.UIIcons;
  19 import org.eclipse.egit.ui.UIText;
  20 import org.eclipse.jface.resource.CompositeImageDescriptor;
  21 import org.eclipse.jface.viewers.ColumnViewer;
  22 import org.eclipse.jface.viewers.LabelProvider;
  23 import org.eclipse.jgit.lib.Constants;
  24 import org.eclipse.jgit.lib.Ref;
  25 import org.eclipse.jgit.lib.Repository;
  26 import org.eclipse.swt.graphics.Image;
  27 import org.eclipse.swt.graphics.Point;
  28 import org.eclipse.swt.graphics.Rectangle;
  29
  30 /**
  31  * Label Provider for the Git Repositories View
  32  */
  33 public class RepositoriesViewLabelProvider extends LabelProvider {
  34
  35         /**
  36          * A map of regular images to their decorated counterpart.
  37          */
  38         private Map<Image, Image> decoratedImages = new HashMap<Image, Image>();
  39
  40         // private DefaultInformationControl infoControl;
  41
  42         /**
  43          *
  44          * @param viewer
  45          */
  46         public RepositoriesViewLabelProvider(final ColumnViewer viewer) {
  47
  48                 viewer.setLabelProvider(this);
  49                 // we could implement some hover here to display additional information
  50                 // viewer.getTree().addMouseTrackListener(new MouseTrackAdapter() {
  51                 //
  52                 // @Override
  53                 // public void mouseHover(MouseEvent e) {
  54
  55                 // Point eventPoint = new Point(e.x, e.y);
  56                 //
  57                 // TreeItem item = viewer.getTree().getItem(eventPoint);
  58                 // if (item != null) {
  59                 //
  60                 // RepositoryTreeNode node = (RepositoryTreeNode) item
  61                 // .getData();
  62                 // String text = node.getRepository().getDirectory()
  63                 // .getCanonicalPath();
  64                 //
  65                 // final ViewerCell cell = viewer.getCell(eventPoint);
  66                 //
  67                 // if (infoControl != null && infoControl.isVisible()) {
  68                 // infoControl.setVisible(false);
  69                 // }
  70                 //
  71                 // GC testGc = new GC(cell.getControl());
  72                 // final Point textExtent = testGc.textExtent(text);
  73                 // testGc.dispose();
  74                 //
  75                 // if (infoControl == null || !infoControl.isVisible()) {
  76                 //
  77                 // IInformationPresenter ips = new IInformationPresenter() {
  78                 //
  79                 // public String updatePresentation(
  80                 // Display display, String hoverInfo,
  81                 // TextPresentation presentation,
  82                 // int maxWidth, int maxHeight) {
  83                 // return hoverInfo;
  84                 // }
  85                 //
  86                 // };
  87                 //
  88                 // infoControl = new DefaultInformationControl(Display
  89                 // .getCurrent().getActiveShell().getShell(),
  90                 // ips) {
  91                 //
  92                 // @Override
  93                 // public void setInformation(String content) {
  94                 // super.setInformation(content);
  95                 // super.setSize(textExtent.x, textExtent.y);
  96                 // }
  97                 //
  98                 // };
  99                 // }
 100                 //
 101                 // Point dispPoint = viewer.getControl().toDisplay(
 102                 // eventPoint);
 103                 //
 104                 // infoControl.setLocation(dispPoint);
 105                 //
 106                 // // the default info provider works better with \r ...
 107                 // infoControl.setInformation(text);
 108                 //
 109                 // final MouseMoveListener moveListener = new
 110                 // MouseMoveListener() {
 111                 //
 112                 // public void mouseMove(MouseEvent evt) {
 113                 // infoControl.setVisible(false);
 114                 // cell.getControl().removeMouseMoveListener(this);
 115                 //
 116                 // }
 117                 // };
 118                 //
 119                 // cell.getControl().addMouseMoveListener(moveListener);
 120                 //
 121                 // infoControl.setVisible(true);
 122                 //
 123                 // }
 124                 //
 125                 // }
 126                 //
 127                 // });
 128
 129         }
 130
 131         @Override
 132         public Image getImage(Object element) {
 133                 return decorateImage(
 134                                 ((RepositoryTreeNode) element).getType().getIcon(), element);
 135         }
 136
 137         @Override
 138         public String getText(Object element) {
 139
 140                 RepositoryTreeNode node = (RepositoryTreeNode) element;
 141                 switch (node.getType()) {
 142                 case REPO:
 143                         File directory = ((Repository) node.getObject()).getDirectory();
 144                         StringBuilder sb = new StringBuilder();
 145                         sb.append(directory.getParentFile().getName());
 146                         sb.append(" - "); //$NON-NLS-1$
 147                         sb.append(directory.getAbsolutePath());
 148                         return sb.toString();
 149                 case FILE:
 150                         // fall through
 151                 case FOLDER:
 152                         return ((File) node.getObject()).getName();
 153                 case BRANCHES:
 154                         return UIText.RepositoriesView_Branches_Nodetext;
 155                 case LOCALBRANCHES:
 156                         return UIText.RepositoriesViewLabelProvider_LocalBranchesNodetext;
 157                 case REMOTEBRANCHES:
 158                         return UIText.RepositoriesViewLabelProvider_RemoteBrancheNodetext;
 159                 case TAGS:
 160                         return UIText.RepositoriesViewLabelProvider_TagsNodeText;
 161                 case SYMBOLICREFS:
 162                         return UIText.RepositoriesViewLabelProvider_SymbolicRefNodeText;
 163                 case REMOTES:
 164                         return UIText.RepositoriesView_RemotesNodeText;
 165                 case REMOTE:
 166                         // fall through
 167                 case ERROR:
 168                         return (String) node.getObject();
 169                 case REF:
 170                         // fall through
 171                 case TAG:
 172                         // fall through
 173                 case SYMBOLICREF:
 174                         Ref ref = (Ref) node.getObject();
 175                         // shorten the name
 176                         String refName = node.getRepository().shortenRefName(ref.getName());
 177                         if (ref.isSymbolic()) {
 178                                 refName = refName + " - " //$NON-NLS-1$
 179                                                 + ref.getLeaf().getName();
 180                         }
 181                         return refName;
 182                 case WORKINGDIR:
 183                         if (node.getRepository().getConfig().getBoolean(
 184                                         "core", "bare", false)) //$NON-NLS-1$ //$NON-NLS-2$
 185                                 return UIText.RepositoriesView_WorkingDir_treenode
 186                                                 + " - " //$NON-NLS-1$
 187                                                 + UIText.RepositoriesViewLabelProvider_BareRepositoryMessage;
 188                         else
 189                                 return UIText.RepositoriesView_WorkingDir_treenode + " - " //$NON-NLS-1$
 190                                                 + node.getRepository().getWorkDir().getAbsolutePath();
 191                 case PUSH:
 192                         // fall through
 193                 case FETCH:
 194                         return (String) node.getObject();
 195
 196                 }
 197
 198                 return null;
 199         }
 200
 201         @Override
 202         public void dispose() {
 203                 // dispose of our decorated images
 204                 for (Image image : decoratedImages.values()) {
 205                         image.dispose();
 206                 }
 207                 decoratedImages.clear();
 208                 super.dispose();
 209         }
 210
 211         private Image decorateImage(final Image image, Object element) {
 212
 213                 RepositoryTreeNode node = (RepositoryTreeNode) element;
 214                 switch (node.getType()) {
 215
 216                 case TAG:
 217                         // fall through
 218                 case REF:
 219                         // if the branch or tag is checked out,
 220                         // we want to decorate the corresponding
 221                         // node with a little check indicator
 222                         String refName = ((Ref) node.getObject()).getName();
 223
 224                         String branchName;
 225                         String compareString;
 226
 227                         try {
 228                                 branchName = node.getRepository().getFullBranch();
 229                                 if (branchName == null)
 230                                         return image;
 231                                 if (refName.startsWith(Constants.R_HEADS)) {
 232                                         // local branch: HEAD would be on the branch
 233                                         compareString = refName;
 234                                 } else if (refName.startsWith(Constants.R_TAGS)) {
 235                                         // tag: HEAD would be on the commit id to which the tag is
 236                                         // pointing
 237                                         compareString = node.getRepository().mapTag(refName)
 238                                                         .getObjId().getName();
 239                                 } else if (refName.startsWith(Constants.R_REMOTES)) {
 240                                         // remote branch: HEAD would be on the commit id to which
 241                                         // the branch is pointing
 242                                         compareString = node.getRepository().mapCommit(refName)
 243                                                         .getCommitId().getName();
 244                                 } else {
 245                                         // some other symbolic reference
 246                                         return image;
 247                                 }
 248                         } catch (IOException e1) {
 249                                 return image;
 250                         }
 251
 252                         if (compareString.equals(branchName)) {
 253                                 return getDecoratedImage(image);
 254                         }
 255
 256                         return image;
 257
 258                 default:
 259                         return image;
 260                 }
 261         }
 262
 263         private Image getDecoratedImage(final Image image) {
 264                 // check if we have a decorated image yet or not
 265                 Image decoratedImage = decoratedImages.get(image);
 266                 if (decoratedImage == null) {
 267                         // create one
 268                         CompositeImageDescriptor cd = new CompositeImageDescriptor() {
 269
 270                                 @Override
 271                                 protected Point getSize() {
 272                                         Rectangle bounds = image.getBounds();
 273                                         return new Point(bounds.width, bounds.height);
 274                                 }
 275
 276                                 @Override
 277                                 protected void drawCompositeImage(int width, int height) {
 278                                         drawImage(image.getImageData(), 0, 0);
 279                                         drawImage(UIIcons.OVR_CHECKEDOUT.getImageData(), 0, 0);
 280
 281                                 }
 282                         };
 283                         decoratedImage = cd.createImage();
 284                         // store it
 285                         decoratedImages.put(image, decoratedImage);
 286                 }
 287                 return decoratedImage;
 288         }
 289
 290 }