bundles/org.simantics.team.ui/src/org/simantics/team/ui/Common.java

   1 package org.simantics.team.ui;
   2
   3 import java.lang.reflect.Method;
   4 import java.util.ArrayList;
   5 import java.util.Collection;
   6 import java.util.HashMap;
   7 import java.util.Iterator;
   8 import java.util.Map;
   9
  10 import org.eclipse.jface.viewers.ColumnLabelProvider;
  11 import org.eclipse.jface.viewers.ITreeContentProvider;
  12 import org.eclipse.jface.viewers.Viewer;
  13 import org.eclipse.jface.viewers.ViewerCell;
  14 import org.eclipse.swt.graphics.Image;
  15 import org.simantics.db.ChangeSet;
  16 import org.simantics.db.ChangeSetIdentifier;
  17 import org.simantics.db.Metadata;
  18 import org.simantics.db.ReadGraph;
  19 import org.simantics.db.Session;
  20 import org.simantics.db.common.CommentMetadata;
  21 import org.simantics.db.common.CommitMetadata;
  22 import org.simantics.db.common.UndoMetadata;
  23 import org.simantics.db.common.request.UniqueRead;
  24 import org.simantics.db.common.utils.Logger;
  25 import org.simantics.db.exception.DatabaseException;
  26 import org.simantics.db.service.ManagementSupport;
  27 import org.simantics.db.service.UndoRedoSupport;
  28 import org.simantics.team.internal.Images;
  29 import org.simantics.utils.ui.SWTUtils;
  30
  31 public class Common {
  32
  33 }
  34 abstract class TreeElement {
  35     abstract boolean hasChildren();
  36     abstract Object[] getChildren();
  37     abstract Image getIdImage();
  38     abstract String getIdText();
  39     final Image getDateImage() {
  40         return null;
  41     }
  42     String getDateText() {
  43         return null;
  44     }
  45     final Image getCommentImage() {
  46         return null;
  47     }
  48     String getCommentText() {
  49         return null;
  50     }
  51 }
  52 class StringElement extends TreeElement {
  53     protected final String name;
  54     protected final String value;
  55     StringElement(String name, String value) {
  56         this.name = name;
  57         this.value = value;
  58     }
  59     @Override
  60     protected Image getIdImage() {
  61         return Images.getInstance().STRING_IMAGE;
  62     }
  63     @Override
  64     protected String getIdText() {
  65         String s = toString();
  66         return s.substring(0, Math.min(40, s.length()));
  67     }
  68     public String toString() {
  69         return name + "=" + value;
  70     }
  71     @Override
  72     boolean hasChildren() {
  73         return false;
  74     }
  75     @Override
  76     Object[] getChildren() {
  77         return new Object[0];
  78     }
  79 }
  80 class CommentStringElement extends StringElement {
  81     CommentStringElement(String name, String value) {
  82         super(name, value);
  83     }
  84     @Override
  85     protected String getIdText() {
  86         return name.substring(0, Math.min(40, name.length()));
  87     }
  88     @Override
  89     protected String getCommentText() {
  90         return value;
  91     }
  92 }
  93 class DisplayElement extends TreeElement {
  94     protected final String name;
  95     protected final String value;
  96     DisplayElement(String name, String value) {
  97         this.name = name;
  98         this.value = value;
  99     }
 100     @Override
 101     public String toString() {
 102         return name + "=" + value;
 103     }
 104     @Override
 105     protected Image getIdImage() {
 106         return Images.getInstance().DISPLAY_IMAGE;
 107     }
 108     @Override
 109     protected String getIdText() {
 110         return name;
 111     }
 112     @Override
 113     boolean hasChildren() {
 114         return false;
 115     }
 116     @Override
 117     Object[] getChildren() {
 118         return new Object[0];
 119     }
 120     String getValue() {
 121         return value;
 122     }
 123 }
 124 class ChangeSetDisplayElement extends DisplayElement {
 125     private final Session session;
 126     private final long csid;
 127     private String lazyValue;
 128     ChangeSetDisplayElement(String name, Session session, long csid) {
 129         super(name, "");
 130         this.session = session;
 131         this.csid = csid;
 132     }
 133     @Override
 134     public String toString() {
 135         return name + "=" + getValue();
 136     }
 137     @Override
 138     String getValue() {
 139         if (null == lazyValue)
 140             lazyValue = fetchChangeSet();
 141         return lazyValue;
 142     }
 143     private String fetchChangeSet() {
 144         try {
 145             Collection<ChangeSet> css = session.sync(new UniqueRead<Collection<ChangeSet>>() {
 146                 @Override
 147                 public Collection<ChangeSet> perform(ReadGraph graph) throws DatabaseException {
 148                     ManagementSupport ms = graph.getService(ManagementSupport.class);
 149                     return ms.fetchChangeSets(graph, csid, csid);
 150                 }
 151             });
 152             if (css.size() != 1)
 153                 return "<no change set (1)>";
 154             return css.iterator().next().toString();
 155         } catch (DatabaseException e) {
 156             Logger.defaultLogError(e);
 157         }
 158         return "<no change set (2)>";
 159     }
 160 }
 161 class ChangeSetElement extends TreeElement implements Command {
 162     private boolean DEBUG = false;
 163     private ChangeSetIdentifier cs;
 164     private Map<String, byte[]> metadata = null;
 165     private Session session;
 166     ChangeSetElement(Session session, long csid) {
 167         this.session = session;
 168         this.cs = getChangeSetIdentifier(csid);
 169     }
 170     ChangeSetElement(Session session, ChangeSetIdentifier cs) {
 171         this.cs = cs;
 172         this.session = session;
 173     }
 174     @SuppressWarnings("unchecked")
 175     static <T> T getMetadata(Session session, Map<String, byte[]> data, Class<? extends Metadata> dataClass) {
 176         if (null == session || null == data || null == dataClass)
 177             return null;
 178         T result = null;
 179         try {
 180             Method m = dataClass.getMethod("deserialise", Session.class, byte[].class);
 181             byte[] bytes = data.get(dataClass.getName());
 182             if (null != bytes) {
 183                 Object value = m.invoke(null, session, bytes);
 184                 result = (T)value;
 185             }
 186         } catch (RuntimeException e) {
 187             Logger.defaultLogError(e);
 188         } catch (Exception e) {
 189             Logger.defaultLogError(e);
 190         }
 191         return result;
 192     }
 193     @Override
 194     public void dumpToSelectedRevision()
 195     throws DatabaseException {
 196         if (null == cs)
 197             return;
 198         ManagementSupport ms = session.getService(ManagementSupport.class);
 199         long csid = cs.getId();
 200         ms.dumpRevision(csid);
 201         if (DEBUG)
 202             System.out.println("DEBUG: Dumped change set=" + csid + ".");
 203     }
 204     @Override
 205     public void undoToSelectedRevision()
 206     throws DatabaseException {
 207         if (null == cs)
 208             return;
 209         UndoRedoSupport us = session.getService(UndoRedoSupport.class);
 210         int n = us.undoTo(session, cs.getId());
 211         if (DEBUG)
 212             System.out.println("DEBUG: Reverted " + n + " change sets.");
 213     }
 214     @Override
 215     public void initUndoListFromSelectedRevision()
 216     throws DatabaseException {
 217         if (null == cs)
 218             return;
 219         UndoRedoSupport us = session.getService(UndoRedoSupport.class);
 220         int n = us.initUndoListFrom(session, cs.getId());
 221         if (DEBUG)
 222             System.out.println("DEBUG: Undo list initialised with " + n + " change sets.");
 223     }
 224     @Override
 225     public ChangeSetIdentifier getChangeSetIdentifier() {
 226         return cs;
 227     }
 228     private ChangeSetIdentifier getChangeSetIdentifier(long id) {
 229         ManagementSupport ms = session.getService(ManagementSupport.class);
 230         Collection<ChangeSetIdentifier> cids;
 231         try {
 232             cids = ms.getChangeSetIdentifiers(id, id);
 233         } catch (DatabaseException e) {
 234             Logger.defaultLogError(e);
 235             return null;
 236         }
 237         Iterator<ChangeSetIdentifier> it = cids.iterator();
 238         while (it.hasNext()) {
 239             ChangeSetIdentifier cid = it.next();
 240             if (cid.getId() == id)
 241                 return cid;
 242         }
 243         return null;
 244     }
 245     private void getMetadata() {
 246         if(metadata != null)
 247             return;
 248         else if (null == cs) {
 249             metadata = new HashMap<String, byte[]>();
 250             return;
 251         }
 252         try {
 253             metadata = cs.getMetadata();
 254             if (null == metadata) {
 255                 ChangeSetIdentifier csid = getChangeSetIdentifier(cs.getId());
 256                 if (null != csid)
 257                     metadata = csid.getMetadata();
 258             }
 259         } catch (Exception e) {
 260             Logger.defaultLogError(e);
 261         }
 262         if (null == metadata)
 263             metadata = new HashMap<String, byte[]>();
 264     }
 265 //    private static final Charset UTF8 = Charset.forName("UTF-8");
 266 //    private String toString(byte[] data) {
 267 //        if (data == null)
 268 //            return "null";
 269 //        CharsetDecoder decoder = UTF8.newDecoder();
 270 //        ByteBuffer bbuf = ByteBuffer.wrap(data);
 271 //        CharBuffer cbuf;
 272 //        String s = null;
 273 //        try {
 274 //            cbuf = decoder.decode(bbuf);
 275 //            s = cbuf.toString();
 276 //        } catch (CharacterCodingException e) {
 277 //            bbuf.rewind();
 278 //            try {
 279 //                cbuf = UTF8
 280 //                .newDecoder()
 281 //                .onMalformedInput(CodingErrorAction.REPLACE)
 282 //                .onUnmappableCharacter(CodingErrorAction.REPLACE)
 283 //                .decode(bbuf);
 284 //                s = cbuf.toString();
 285 //            } catch (CharacterCodingException e1) {
 286 //                return "String conversion error.";
 287 //            }
 288 //        }
 289 //        return s;
 290 //    }
 291     @Override
 292     public String toString() {
 293         if (null == cs)
 294             return "<no change set>";
 295         else
 296             return "change set " + cs.getId();
 297     }
 298     @Override
 299     boolean hasChildren() {
 300         if (null == metadata)
 301             getMetadata();
 302         if (null == cs && metadata.isEmpty())
 303             return false;
 304         else
 305             return true;
 306     }
 307     @Override
 308     Object[] getChildren() {
 309         if (null == metadata)
 310             getMetadata();
 311         if (null == cs && metadata.isEmpty())
 312             return new Object[0];
 313         ArrayList<Object> objects = new ArrayList<Object>();
 314         if (!metadata.isEmpty()) {
 315             objects.add(new CommentStringElement("Metaclass", "Count is " + metadata.size() + "."));
 316
 317             CommitMetadata commitMetadata = getMetadata(session, metadata, CommitMetadata.class);
 318             if (null != commitMetadata) {
 319                 if (commitMetadata.opid != 0 && commitMetadata.opid != cs.getId())
 320                     objects.add(new StringElement("Part of operation", "" + commitMetadata.opid));
 321             }
 322
 323             CommentMetadata commentMetadata = getMetadata(session, metadata, CommentMetadata.class);
 324             if (null != commentMetadata)
 325                 objects.add(new DisplayElement("Comment", commentMetadata.toString()));
 326
 327             UndoMetadata undoMetadata = getMetadata(session, metadata, UndoMetadata.class);
 328             if (null != undoMetadata) {
 329                 String header = undoMetadata.getHeader();
 330                 objects.add(new DisplayElement(header, undoMetadata.toString()));
 331             }
 332         }
 333         if (cs.getId() > 0)
 334             objects.add(new ChangeSetDisplayElement("Change Set", session, cs.getId()));
 335
 336         return objects.toArray();
 337     }
 338     Image getIdImage() {
 339         return Images.getInstance().CHANGE_SET_IMAGE;
 340     }
 341     String getIdText() {
 342         if (null != cs)
 343             return "" + cs.getId();
 344         else
 345             return "<no id>";
 346     }
 347     String getDateText() {
 348         if (null == metadata)
 349             getMetadata();
 350         if (null == cs || metadata.isEmpty())
 351             return "<no date>";
 352         CommitMetadata commitMetadata = getMetadata(session, metadata, CommitMetadata.class);
 353         if (null != commitMetadata)
 354             return commitMetadata.date.toString();
 355         else
 356             return "<no date>";
 357     }
 358     String getCommentText() {
 359         if (null == metadata)
 360             getMetadata();
 361         if (null == cs || metadata.isEmpty())
 362             return "<no comment>";
 363         CommentMetadata commentMetadata = getMetadata(session, metadata, CommentMetadata.class);
 364         if (null != commentMetadata) {
 365             UndoMetadata undoMetadata = getMetadata(session, metadata, UndoMetadata.class);
 366             String t = commentMetadata.toString();
 367             if (null == undoMetadata)
 368                 return t;
 369             else
 370                 return undoMetadata.getHeader() + ": " + t;
 371         }
 372         else
 373             return "<no comment>";
 374     }
 375 }
 376 abstract class AbstractColumnLabelProvider extends ColumnLabelProvider {
 377 }
 378 class IdColumnLabelProvider extends AbstractColumnLabelProvider {
 379     @Override
 380     public void update(ViewerCell cell) {
 381         Object element = cell.getElement();
 382         if (!(element instanceof TreeElement))
 383             cell.setText("");
 384         else {
 385             TreeElement te = (TreeElement)element;
 386             String text = te.getIdText();
 387             if (null != text)
 388                 cell.setText(text);
 389             Image image = te.getIdImage();
 390             if (null!= image)
 391                 cell.setImage(image);
 392         }
 393     }
 394 }
 395 class DateColumnLabelProvider extends AbstractColumnLabelProvider {
 396     @Override
 397     public void update(ViewerCell cell) {
 398         Object element = cell.getElement();
 399         if (!(element instanceof TreeElement))
 400             cell.setText("");
 401         else {
 402             TreeElement te = (TreeElement)element;
 403             String text = te.getDateText();
 404             if (null != text)
 405                 cell.setText(text);
 406             Image image = te.getDateImage();
 407             if (null!= image)
 408                 cell.setImage(image);
 409         }
 410     }
 411 }
 412 class CommentColumnLabelProvider extends AbstractColumnLabelProvider {
 413     @Override
 414     public void update(ViewerCell cell) {
 415         Object element = cell.getElement();
 416         if (!(element instanceof TreeElement))
 417             cell.setText("");
 418         else {
 419             TreeElement te = (TreeElement)element;
 420             String text = te.getCommentText();
 421             if (null != text)
 422                 cell.setText(text);
 423             Image image = te.getCommentImage();
 424             if (null!= image)
 425                 cell.setImage(image);
 426         }
 427     }
 428 }
 429 abstract class ChangeSetProvider implements ITreeContentProvider, ManagementSupport.ChangeSetListener {
 430     static final boolean DEBUG = false;
 431     protected final Session session;
 432     protected final ManagementSupport managementSupport;
 433     private boolean subscribed = false;
 434     protected Viewer viewer;
 435     ChangeSetProvider(Session session) {
 436         this.session = session;
 437         this.managementSupport = session.getService(ManagementSupport.class);
 438         subscribe();
 439     }
 440     abstract public Object[] getElements(Object inputElement);
 441     @Override
 442     public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
 443         this.viewer = viewer;
 444         subscribe();
 445     }
 446     @Override
 447     public void dispose() {
 448         managementSupport.cancel(this);
 449         this.subscribed = false;
 450     }
 451     @Override
 452     public void onChanged(long csid) {
 453         if (null != viewer && this.subscribed)
 454             refresh();
 455     }
 456     @Override
 457     public boolean hasChildren(Object element) {
 458         if (element instanceof  TreeElement)
 459             return ((TreeElement)element).hasChildren();
 460         return false;
 461     }
 462     @Override
 463     public Object getParent(Object element) {
 464         return null;
 465     }
 466     @Override
 467     public Object[] getChildren(Object parentElement) {
 468         if (parentElement instanceof  TreeElement)
 469             return ((TreeElement)parentElement).getChildren();
 470         else
 471             return null;
 472     }
 473     protected void subscribe() {
 474         if (this.subscribed)
 475             return;
 476         managementSupport.subscribe(this);
 477         this.subscribed = true;
 478     }
 479     protected void refresh() {
 480         if (viewer == null)
 481             return;
 482         SWTUtils.asyncExec(viewer.getControl(), new Runnable() {
 483             @Override
 484             public void run() {
 485                 if (!viewer.getControl().isDisposed())
 486                     viewer.refresh();
 487             }
 488         });
 489     }
 490 }