public class XXXPropertySheetSorter extends PropertySheetSorter
{
   public void sort(IPropertySheetEntry[] entries)
   {
   }
}

public class XXXPropertySheetPage extends PropertySheetPage
{
   public XXXPropertySheetPage()
   {
      super();
      setSorter(new XXXPropertySheetSorter());
   }
}

protected List computeMergedPropertyDescriptors();
protected Map computePropertyDescriptorsFor(IPropertySource source);

public class XXXPropertySheetEntry extends UndoableModelPropertySheetEntry
{
   public XXXPropertySheetEntry(IOperationHistory operationHistory)
   {
      super(operationHistory);
   }

   /**
    * Overrides the super method to avoid ordering attributes, and so keep the
    * order defined in the ecore model.
    * 
    * @return sorted <code>List</code> of all the <code>IPropertyDescriptor</code>s for the objects 
    */
   protected List computeMergedPropertyDescriptors()
   {
      if (values.length == 0)
         return new ArrayList(0);

      // get all descriptors from each object
      Map[] propertyDescriptorMaps = new Map[values.length];
      for (int i = 0; i < values.length; i++)
      {
         Object object = values[i];
         IPropertySource source = getPropertySource(object);
         if (source == null)
         {
            // if one of the selected items is not a property source
            // then we show no properties
            return new ArrayList(0);
         }
         // get the property descriptors keyed by id
         propertyDescriptorMaps[i] = computePropertyDescriptorsFor(source);
      }

      // intersect
      Map intersection = propertyDescriptorMaps[0];
      for (int i = 1; i < propertyDescriptorMaps.length; i++)
      {
         // get the current ids
         Object[] ids = intersection.keySet().toArray();
         for (int j = 0; j < ids.length; j++)
         {
            Object object = propertyDescriptorMaps[i].get(ids[j]);
            if (object == null ||
            // see if the descriptors (which have the same id) are
                  // compatible
                  !((IPropertyDescriptor) intersection.get(ids[j])).isCompatibleWith((IPropertyDescriptor) object))
               intersection.remove(ids[j]);
         }
      }

      // Sort the descriptors
      List descriptors = new ArrayList(intersection.values());

////////////////////////////////////////////////////////////////////////
      // Commented to avoid alphabetically sorting of properties!
      //       Collections.sort(descriptors, new Comparator() {
      //           Collator coll = Collator.getInstance(Locale.getDefault());
      //
      //           public int compare(Object a, Object b) {
      //               IPropertyDescriptor d1, d2;
      //               String dname1, dname2;
      //               d1 = (IPropertyDescriptor) a;
      //               dname1 = d1.getDisplayName();
      //               d2 = (IPropertyDescriptor) b;
      //               dname2 = d2.getDisplayName();
      //               return coll.compare(dname1, dname2);
      //           }
      //       });
////////////////////////////////////////////////////////////////////////

      return descriptors;
   }

   /**
    * Overrides the super method to avoid ordering attributes, and so keep the
    * order defined in the ecore model.
    * The difference with the super method is that a LinkedHashMap is used instead of a HashMap,
    * in order to keep the properties order.
    * 
    * @param source a property source for which to obtain descriptors
    * @return a table of descriptors keyed on their id
    */
   protected Map computePropertyDescriptorsFor(IPropertySource source)
   {
      IPropertyDescriptor[] descriptors = source.getPropertyDescriptors();
      
////////////////////////////////////////////////////////////////////////
      // Use LinkedHashMap instead of HashMap to preserve order
      Map result = new LinkedHashMap();
////////////////////////////////////////////////////////////////////////
      for (int i = 0; i < descriptors.length; i++)
      {
         result.put(descriptors[i].getId(), descriptors[i]);
      }
      return result;
   }

}

   public void createControls(final Composite parent, TabbedPropertySheetPage aTabbedPropertySheetPage)
   {
      super.createControls(parent, aTabbedPropertySheetPage);
      Composite composite = getWidgetFactory().createFlatFormComposite(parent);
      FormData data = null;

      String tableLabelStr = getTableLabel();
      CLabel tableLabel = null;
      if (tableLabelStr != null && tableLabelStr.length() > 0)
      {
         tableLabel = getWidgetFactory().createCLabel(composite, tableLabelStr);
         data = new FormData();
         data.left = new FormAttachment(0, 0);
         data.top = new FormAttachment(0, 0);
         tableLabel.setLayoutData(data);
      }

////////////////////////////////////////////////////////////////////////
      // Use VadPropertySheetPage to provide custom properties behavior
      page = new VadPropertySheetPage();
      
      // Use VadPropertySheetEntry to provide custom properties behavior
      UndoableModelPropertySheetEntry root = new VadPropertySheetEntry(OperationHistoryFactory.getOperationHistory());
////////////////////////////////////////////////////////////////////////

      root.setPropertySourceProvider(getPropertySourceProvider());
      page.setRootEntry(root);

      page.createControl(composite);
      data = new FormData();
      data.left = new FormAttachment(0, 0);
      data.right = new FormAttachment(100, 0);
      if (tableLabel == null)
      {
         data.top = new FormAttachment(0, 0);
      }
      else
      {
         data.top = new FormAttachment(tableLabel, 0, SWT.BOTTOM);
      }
      data.bottom = new FormAttachment(100, 0);
      data.height = 100;
      data.width = 100;
      page.getControl().setLayoutData(data);

      setActionBars(aTabbedPropertySheetPage.getSite().getActionBars());

   }