composites/ItemTemplateTitleComposite.java

   1 package org.argeo.slc.akb.ui.composites;
   2
   3 import java.util.HashMap;
   4 import java.util.List;
   5 import java.util.Map;
   6
   7 import javax.jcr.Node;
   8 import javax.jcr.Property;
   9 import javax.jcr.RepositoryException;
  10
  11 import org.argeo.eclipse.ui.utils.CommandUtils;
  12 import org.argeo.jcr.JcrUtils;
  13 import org.argeo.slc.akb.AkbException;
  14 import org.argeo.slc.akb.AkbNames;
  15 import org.argeo.slc.akb.AkbService;
  16 import org.argeo.slc.akb.ui.AkbUiUtils;
  17 import org.argeo.slc.akb.ui.commands.OpenAkbNodeEditor;
  18 import org.argeo.slc.akb.utils.AkbJcrUtils;
  19 import org.eclipse.jface.dialogs.MessageDialog;
  20 import org.eclipse.swt.SWT;
  21 import org.eclipse.swt.events.ModifyEvent;
  22 import org.eclipse.swt.events.ModifyListener;
  23 import org.eclipse.swt.events.SelectionAdapter;
  24 import org.eclipse.swt.events.SelectionEvent;
  25 import org.eclipse.swt.layout.GridData;
  26 import org.eclipse.swt.layout.GridLayout;
  27 import org.eclipse.swt.widgets.Combo;
  28 import org.eclipse.swt.widgets.Composite;
  29 import org.eclipse.swt.widgets.Label;
  30 import org.eclipse.swt.widgets.Link;
  31 import org.eclipse.swt.widgets.Text;
  32 import org.eclipse.ui.forms.AbstractFormPart;
  33 import org.eclipse.ui.forms.IManagedForm;
  34 import org.eclipse.ui.forms.widgets.FormToolkit;
  35
  36 public class ItemTemplateTitleComposite extends Composite {
  37         // private final static Log log =
  38         // LogFactory.getLog(MixTitleComposite.class);
  39
  40         private final AkbService akbService;
  41         private final Node envNode;
  42         private final Node itemNode;
  43         private final FormToolkit toolkit;
  44         private final IManagedForm form;
  45         // Don't forget to unregister on dispose
  46         private AbstractFormPart formPart;
  47
  48         // To enable set focus
  49         private Text titleTxt;
  50         private Combo aliasCmb;
  51
  52         private List<Node> definedAliases;
  53
  54         /**
  55          *
  56          * @param parent
  57          * @param style
  58          * @param toolkit
  59          * @param form
  60          * @param envNode
  61          * @param itemNode
  62          * @param akbService
  63          */
  64         public ItemTemplateTitleComposite(Composite parent, int style,
  65                         FormToolkit toolkit, IManagedForm form, Node envNode,
  66                         Node itemNode, AkbService akbService) {
  67                 super(parent, style);
  68                 this.envNode = envNode;
  69                 this.itemNode = itemNode;
  70                 this.toolkit = toolkit;
  71                 this.form = form;
  72                 this.akbService = akbService;
  73                 populate();
  74                 toolkit.adapt(this);
  75         }
  76
  77         private void populate() {
  78                 // Initialization
  79                 Composite parent = this;
  80
  81                 parent.setLayout(new GridLayout(5, false));
  82
  83                 // first line: Item name
  84                 toolkit.createLabel(parent, "Name");
  85                 titleTxt = toolkit.createText(parent, "", SWT.BORDER);
  86                 GridData gd = new GridData(SWT.FILL, SWT.TOP, true, false, 4, 1);
  87                 titleTxt.setLayoutData(gd);
  88
  89                 // Second line: alias management
  90                 toolkit.createLabel(parent, "Alias");
  91                 aliasCmb = new Combo(parent, SWT.READ_ONLY);
  92                 toolkit.adapt(aliasCmb, false, false);
  93                 gd = new GridData(SWT.FILL, SWT.TOP, true, false, 3, 1);
  94                 aliasCmb.setLayoutData(gd);
  95
  96                 final Link openAliasLk = new Link(parent, SWT.NONE);
  97                 toolkit.adapt(openAliasLk, false, false);
  98                 openAliasLk.setText("<a>Edit Alias</a>");
  99                 openAliasLk.addSelectionListener(new SelectionAdapter() {
 100                         @Override
 101                         public void widgetSelected(final SelectionEvent event) {
 102                                 int index = aliasCmb.getSelectionIndex();
 103                                 if (index != -1) {
 104                                         Node currAlias = definedAliases.get(index);
 105                                         String id = AkbJcrUtils.getIdentifierQuietly(currAlias);
 106                                         Map<String, String> params = new HashMap<String, String>();
 107                                         params.put(OpenAkbNodeEditor.PARAM_NODE_JCR_ID, id);
 108                                         params.put(OpenAkbNodeEditor.PARAM_CURR_ENV_JCR_ID,
 109                                                         AkbJcrUtils.getIdentifierQuietly(envNode));
 110
 111                                         CommandUtils.callCommand(OpenAkbNodeEditor.ID, params);
 112                                 } else
 113                                         MessageDialog.openError(getShell(), "Error",
 114                                                         "No selected alias");
 115                         }
 116                 });
 117
 118                 // 3rd line: description
 119                 Label lbl = toolkit.createLabel(parent, "Description");
 120                 lbl.setLayoutData(new GridData(SWT.LEFT, SWT.TOP, false, false));
 121                 final Text descTxt = toolkit.createText(parent, "", SWT.BORDER
 122                                 | SWT.MULTI | SWT.WRAP);
 123                 gd = new GridData(SWT.FILL, SWT.FILL, true, true, 4, 1);
 124                 descTxt.setLayoutData(gd);
 125
 126                 // Part Management
 127                 final AbstractFormPart part = new AbstractFormPart() {
 128                         public void refresh() {
 129                                 super.refresh();
 130                                 // update display value
 131                                 AkbUiUtils.refreshFormTextWidget(titleTxt, itemNode,
 132                                                 Property.JCR_TITLE);
 133                                 AkbUiUtils.refreshFormTextWidget(descTxt, itemNode,
 134                                                 Property.JCR_DESCRIPTION);
 135
 136                                 refreshTypeCmbValues();
 137                                 aliasCmb.select(getCurrAliasIndex());
 138                                 aliasCmb.setEnabled(AkbJcrUtils.isNodeCheckedOutByMe(itemNode));
 139                         }
 140                 };
 141
 142                 // Listeners
 143                 AkbUiUtils.addTextModifyListener(titleTxt, itemNode,
 144                                 Property.JCR_TITLE, part);
 145                 AkbUiUtils.addTextModifyListener(descTxt, itemNode,
 146                                 Property.JCR_DESCRIPTION, part);
 147
 148                 aliasCmb.addModifyListener(new ModifyListener() {
 149                         @Override
 150                         public void modifyText(ModifyEvent event) {
 151                                 try {
 152                                         int oldIndex = getCurrAliasIndex();
 153                                         int selIndex = aliasCmb.getSelectionIndex();
 154
 155                                         // insure something has really been modified
 156                                         if (selIndex < 0 || oldIndex == selIndex)
 157                                                 return;
 158
 159                                         // set new alias
 160                                         Node newAlias = definedAliases.get(selIndex);
 161
 162                                         // Only relies on the alias
 163                                         itemNode.setProperty(AkbNames.AKB_USED_CONNECTOR,
 164                                                         newAlias.getPath());
 165                                         part.markDirty();
 166                                 } catch (RepositoryException e) {
 167                                         throw new AkbException(
 168                                                         "Error while updating connector alias", e);
 169                                 }
 170                         }
 171                 });
 172
 173                 form.addPart(part);
 174         }
 175
 176         private void refreshTypeCmbValues() {
 177                 List<Node> newAliases;
 178                 try {
 179                         newAliases = JcrUtils.nodeIteratorToList(akbService
 180                                         .getDefinedAliases(
 181                                                         AkbJcrUtils.getCurrentTemplate(itemNode),
 182                                                         AkbJcrUtils.getAliasTypeForNode(itemNode)));
 183                 } catch (RepositoryException e) {
 184                         throw new AkbException("Unable to get defined aliases for node "
 185                                         + itemNode, e);
 186                 }
 187                 boolean hasChanged = false;
 188                 // manually ckeck if something has changed
 189                 if (definedAliases == null
 190                                 || newAliases.size() != definedAliases.size())
 191                         hasChanged = true;
 192                 else {
 193
 194                         for (int i = 0; i < newAliases.size(); i++) {
 195                                 if (!newAliases.get(i).equals(definedAliases.get(i))) {
 196                                         hasChanged = true;
 197                                         break;
 198                                 }
 199                         }
 200                 }
 201
 202                 if (hasChanged) {
 203                         definedAliases = newAliases;
 204                         final String[] names = new String[definedAliases.size()];
 205                         int i = 0;
 206                         for (Node node : definedAliases)
 207                                 names[i++] = AkbJcrUtils.get(node, Property.JCR_TITLE);
 208                         aliasCmb.setItems(names);
 209                 }
 210         }
 211
 212         /**
 213          * Returns the index in definedAliases list of the CURRENT defined alias as
 214          * set in the item node <CODE>AkbNames.AKB_USED_CONNECTOR</CODE> if defined,
 215          * -1 otherwise
 216          */
 217         private int getCurrAliasIndex() {
 218                 try {
 219                         if (itemNode.hasProperty(AkbNames.AKB_USED_CONNECTOR)) {
 220                                 String aliasPath = itemNode.getProperty(
 221                                                 AkbNames.AKB_USED_CONNECTOR).getString();
 222                                 Node alias = itemNode.getSession().getNode(aliasPath);
 223                                 return aliasCmb.indexOf(alias.getProperty(Property.JCR_TITLE).getString());
 224                         } else
 225                                 return -1;
 226                 } catch (RepositoryException re) {
 227                         throw new AkbException("Unable to retrieve current Alias", re);
 228                 }
 229         }
 230
 231         @Override
 232         public boolean setFocus() {
 233                 return titleTxt.setFocus();
 234         }
 235
 236         protected void disposePart(AbstractFormPart part) {
 237                 if (part != null) {
 238                         form.removePart(part);
 239                         part.dispose();
 240                 }
 241         }
 242
 243         @Override
 244         public void dispose() {
 245                 disposePart(formPart);
 246                 super.dispose();
 247         }
 248 }