1 files changed, 182 insertions, 0 deletions
diff --git a/src/plugins/android/src/com/motorola/studio/android/wizards/elements/sorting/TableItemSortStringSetActionListener.java b/src/plugins/android/src/com/motorola/studio/android/wizards/elements/sorting/TableItemSortStringSetActionListener.java
new file mode 100644
index 0000000..c04b23f
--- /dev/null
+++ b/src/plugins/android/src/com/motorola/studio/android/wizards/elements/sorting/TableItemSortStringSetActionListener.java
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.motorola.studio.android.wizards.elements.sorting;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.events.SelectionListener;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.TableItem;
+
+import com.motorola.studio.android.wizards.elements.sorting.TableItemStringComparator.SortDirection;
+
+/**
+ * This selection listener sorts the columns of a {@link Table}. It assumes
+ * the columns being sorted are {@link String}s.
+ */
+public class TableItemSortStringSetActionListener implements SelectionListener
+{
+
+    /* (non-Javadoc)
+     * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)
+     */
+    public void widgetDefaultSelected(SelectionEvent e)
+    {
+        // sort the table
+        sortTable(e);
+    }
+
+    /* (non-Javadoc)
+     * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
+     */
+    public void widgetSelected(SelectionEvent e)
+    {
+        // sort the table
+        sortTable(e);
+    }
+
+    /**
+     * Execute the {@link Table} sorting.
+     * 
+     * @param e Event object of the sort.
+     */
+    private void sortTable(SelectionEvent e)
+    {
+        // get column to be sorted
+        TableColumn column = (TableColumn) e.widget;
+        // get table belonging to to sorted column
+        Table table = column.getParent();
+
+        // get selected items because the sort messes with them, so they will be restored later
+        TableItem[] selectedItems = table.getSelection();
+        // create a list of new selected items - items which will be selected after the sorting
+        List<TableItem> selectedItemsAfterSorting = new ArrayList<TableItem>();
+
+        // get the sort direction from the table
+        int sortDirection = table.getSortDirection();
+        // determine the new sorting direction according to the old one
+        sortDirection = sortDirection == SWT.UP ? SWT.DOWN : SWT.UP;
+
+        // get Table items
+        TableItem[] items = table.getItems();
+        if ((items != null) && (items.length > 0))
+        {
+            // sort the items - assume you always sort them by String
+            Arrays.sort(items, new TableItemStringComparator(table.indexOf(column),
+                    sortDirection == SWT.UP ? SortDirection.ASCENDING : SortDirection.DESCENDING));
+
+            // rearrange the table according to the sorted items - the iteration is in the new sorted order
+            TableItem newItem = null;
+            TableItem item = null;
+            for (int rowIndex = 0; rowIndex < items.length; rowIndex++)
+            {
+                // get current item - to be removed
+                item = items[rowIndex];
+                // create a new table item to be inserted in the table
+                newItem = new TableItem(table, SWT.NONE, rowIndex);
+                // set the text for this new item based on the item in the order
+                newItem.setText(getTableItemData(item));
+                // in case the current item is a selected one, put the new one in the selection list
+                if (isElementInArray(item, selectedItems))
+                {
+                    selectedItemsAfterSorting.add(newItem);
+                }
+                // remove the current item
+                item.dispose();
+            }
+        }
+        // set the new selection items
+        TableItem[] selectedItemsAfterSortingArray =
+                new TableItem[selectedItemsAfterSorting.size()];
+        for (int rowIndex = 0; rowIndex < selectedItemsAfterSortingArray.length; rowIndex++)
+        {
+            selectedItemsAfterSortingArray[rowIndex] = selectedItemsAfterSorting.get(rowIndex);
+        }
+        table.setSelection(selectedItemsAfterSortingArray);
+
+        // set the new sorting direction and sorted column
+        table.setSortDirection(sortDirection);
+        table.setSortColumn((column));
+        table.setRedraw(true);
+    }
+
+    /**
+     * Verify whether an element belongs to an array.
+     * 
+     * @param <E> Any type of object or primitive
+     * @param element Element to be verified whether it is in a certain array.
+     * @param array Array which the element will be verified to be within.
+     * 
+     * @return Returns <code>true</code> in case the element is in the array, <code>false</code>
+     * otherwise.
+     */
+    private <E> boolean isElementInArray(E element, E[] array)
+    {
+        boolean hasElement = false;
+
+        // first all items must not be null and the list not empty
+        if ((element != null) && (array != null) && (array.length > 0))
+        {
+            // verify whether the element is in the array
+            for (E arrayItem : array)
+            {
+                // the element was found, set the flag and quit the loop
+                if (arrayItem.equals(element))
+                {
+                    hasElement = true;
+                    break;
+                }
+            }
+        }
+
+        return hasElement;
+    }
+
+    /**
+     * Get an array of string holding the data of a {@link TableItem}.
+     * 
+     * @param tableItem Table item in which data will be retrieved.
+     * 
+     * @return Array of data from the Table Item.
+     */
+    private String[] getTableItemData(TableItem tableItem)
+    {
+        String[] itemArray = new String[0];
+        // get the related table
+        Table table = tableItem.getParent();
+        if (table != null)
+        {
+            // get the number of columns in the table
+            int columnCount = table.getColumnCount();
+            if (columnCount > 0)
+            {
+                // set a string of data to be returned, based on the number of columns
+                itemArray = new String[columnCount];
+                // for each column item put in the array to be returned
+                for (int columnIndex = 0; columnIndex < columnCount; columnIndex++)
+                {
+                    itemArray[columnIndex] = tableItem.getText(columnIndex);
+                }
+            }
+        }
+        return itemArray;
+    }
+}