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