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