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