archive/net.sourceforge.phpeclipse.quantum.sql/src/com/quantum/wizards/SortFilterPage.java

   1 package com.quantum.wizards;
   2
   3 import java.sql.SQLException;
   4
   5 import com.quantum.ImageStore;
   6 import com.quantum.model.Column;
   7 import com.quantum.model.Entity;
   8 import com.quantum.model.NotConnectedException;
   9 import com.quantum.sql.FilterSort;
  10 import com.quantum.sql.SQLResultSetResults;
  11 import com.quantum.ui.dialog.SQLExceptionDialog;
  12 import com.quantum.util.connection.ConnectionUtil;
  13
  14 import org.eclipse.jface.viewers.CellEditor;
  15 import org.eclipse.jface.viewers.CheckboxCellEditor;
  16 import org.eclipse.jface.viewers.ComboBoxCellEditor;
  17 import org.eclipse.jface.viewers.ICellModifier;
  18 import org.eclipse.jface.viewers.ILabelProviderListener;
  19 import org.eclipse.jface.viewers.IStructuredContentProvider;
  20 import org.eclipse.jface.viewers.ITableLabelProvider;
  21 import org.eclipse.jface.viewers.TableViewer;
  22 import org.eclipse.jface.viewers.TextCellEditor;
  23 import org.eclipse.jface.viewers.Viewer;
  24 import org.eclipse.jface.wizard.WizardPage;
  25 import org.eclipse.swt.SWT;
  26 import org.eclipse.swt.graphics.Image;
  27 import org.eclipse.swt.layout.GridData;
  28 import org.eclipse.swt.layout.GridLayout;
  29 import org.eclipse.swt.widgets.Composite;
  30 import org.eclipse.swt.widgets.Label;
  31 import org.eclipse.swt.widgets.Table;
  32 import org.eclipse.swt.widgets.TableItem;
  33
  34 public class SortFilterPage extends WizardPage implements SQLPage {
  35
  36         class SortFilterTableValues {
  37                 private String colNames = null;
  38                 private boolean isWhere = false;
  39                 private String operators = "";
  40                 private String values = null;
  41                 private boolean isString = false;
  42                 private boolean isOrderBy = false;
  43                 private String sorter = "";
  44
  45                 /**
  46                  * @return Returns the isOrderBy.
  47                  */
  48                 public boolean isOrderBy() {
  49                         return isOrderBy;
  50                 }
  51                 /**
  52                  * @param isOrderBy The isOrderBy to set.
  53                  */
  54                 public void setOrderBy(boolean isOrderBy) {
  55                         this.isOrderBy = isOrderBy;
  56                 }
  57                 /**
  58                  * @return Returns the isString.
  59                  */
  60                 public boolean isString() {
  61                         return isString;
  62                 }
  63                 /**
  64                  * @param isString The isString to set.
  65                  */
  66                 public void setString(boolean isString) {
  67                         this.isString = isString;
  68                 }
  69                 /**
  70                  * @return Returns the isWhere.
  71                  */
  72                 public boolean isWhere() {
  73                         return isWhere;
  74                 }
  75                 /**
  76                  * @param isWhere The isWhere to set.
  77                  */
  78                 public void setWhere(boolean isWhere) {
  79                         this.isWhere = isWhere;
  80                 }
  81                 /**
  82                  * @return Returns the operators.
  83                  */
  84                 public String getOperators() {
  85                         return operators;
  86                 }
  87                 /**
  88                  * @param operators The operators to set.
  89                  */
  90                 public void setOperators(String operators) {
  91                         this.operators = operators;
  92                 }
  93                 /**
  94                  * @return Returns the sorter.
  95                  */
  96                 public String getSorter() {
  97                         return sorter;
  98                 }
  99                 /**
 100                  * @param sorter The sorter to set.
 101                  */
 102                 public void setSorter(String sorter) {
 103                         this.sorter = sorter;
 104                 }
 105                 /**
 106                  * @return Returns the values.
 107                  */
 108                 public String getValues() {
 109                         return values;
 110                 }
 111                 /**
 112                  * @param values The values to set.
 113                  */
 114                 public void setValues(String values) {
 115                         this.values = values;
 116                 }
 117                 /**
 118                  * @return Returns the colNames.
 119                  */
 120                 public String getColNames() {
 121                         return colNames;
 122                 }
 123                 /**
 124                  * @param colNames The colNames to set.
 125                  */
 126                 public void setColNames(String colNames) {
 127                         this.colNames = colNames;
 128                 }
 129         }
 130
 131         class LabelProviderImpl implements ITableLabelProvider {
 132                 public Image getColumnImage(Object element, int columnIndex) {
 133                         if (columnIndex == 0) {
 134                         return ((SortFilterTableValues)element).isWhere() ? imgCheck : imgUncheck;
 135                     } else if (columnIndex == 3) {
 136                         return ((SortFilterTableValues)element).isString() ? imgCheck : imgUncheck;
 137                     } else if (columnIndex == 4) {
 138                             return ((SortFilterTableValues)element).isOrderBy() ? imgCheck : imgUncheck;
 139                     } else {
 140                         return null;
 141                     }
 142                 }
 143                 public String getColumnText(Object element, int columnIndex) {
 144                         String sReturn = "";
 145                         SortFilterTableValues sortFilterRow = (SortFilterTableValues)element;
 146
 147                         switch (columnIndex) {
 148                                 case 0: // isWhere
 149                                         sReturn = sortFilterRow.getColNames();
 150                                     break;
 151                                 case 1: // operators
 152                                     sReturn = sortFilterRow.getOperators();
 153                                     break;
 154                                 case 2: // values
 155                                         sReturn = sortFilterRow.getValues();
 156                                         break;
 157                                 case 3: // isString
 158                                         break;
 159                                 case 4: // isOrderBy
 160                                         sReturn = sortFilterRow.getColNames();
 161                                         break;
 162                                 case 5: // sorter
 163                                         sReturn = sortFilterRow.getSorter();
 164                                         break;
 165                                 default:
 166                                     break;
 167                         }
 168                         return sReturn;
 169                 }
 170                 public void addListener(ILabelProviderListener listener) {}
 171                 public void dispose() {}
 172                 public boolean isLabelProperty(Object element, String property) {
 173                         return false;
 174                 }
 175                 public void removeListener(ILabelProviderListener listener) {}
 176         }
 177
 178     class ContentProviderImpl implements IStructuredContentProvider {
 179                 public Object[] getElements(Object inputElement) {
 180                         return sortFilterValues;
 181                 }
 182
 183                 public void dispose() {}
 184                 public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {}
 185         }
 186
 187     class CellModifierImpl implements ICellModifier {
 188
 189         public boolean canModify(Object element, String property) {
 190                 return true;
 191         }
 192
 193         public Object getValue(Object element, String property) {
 194                 System.out.println("getValue called");
 195
 196                 // Find the index of the column
 197                 int colIndx = comUI.getColumnNamesAsList(colNames).indexOf(property);
 198                 System.out.println("colIndx : " + colIndx);
 199
 200                 Object rResult = null;
 201                 SortFilterTableValues sortFilterVal = (SortFilterTableValues)element;
 202
 203                 switch (colIndx) {
 204                         case 0: // isWhere
 205                             rResult = new Boolean(sortFilterVal.isWhere());
 206                                     break;
 207                                 case 1: // operators
 208                                         String sTemp = sortFilterVal.getOperators();
 209                                         int nIndex = comUI.getColumnNamesAsList(oper).indexOf(sTemp);
 210                                     rResult = new Integer(nIndex);
 211                                     break;
 212                                 case 2: // values
 213                                         rResult = sortFilterVal.getValues();
 214                                         break;
 215                                 case 3: // isString
 216                                         rResult = new Boolean(sortFilterVal.isString());
 217                                         break;
 218                                 case 4: // isOrderBy
 219                                         rResult = new Boolean(sortFilterVal.isOrderBy());
 220                                         break;
 221                                 case 5: // sorter
 222                                         String sTemp2 = sortFilterVal.getSorter();
 223                                         int nIndx = comUI.getColumnNamesAsList(order).indexOf(sTemp2);
 224                                     rResult = new Integer(nIndx);
 225                                         break;
 226                         default:
 227                                 rResult = "";
 228                                 break;
 229                 }
 230
 231                 return rResult;
 232         }
 233
 234         public void modify(Object element, String property, Object value) {
 235                 int colIndx = comUI.getColumnNamesAsList(colNames).indexOf(property);
 236
 237                 TableItem item = (TableItem) element;
 238                 SortFilterTableValues sortFilterVal = (SortFilterTableValues)item.getData();
 239
 240                 switch (colIndx) {
 241                         case 0: // isWhere
 242                                 sortFilterVal.setWhere(((Boolean)value).booleanValue());
 243                             break;
 244                         case 1: // operators
 245                                 int nIdx = ((Integer)value).intValue();
 246                                 if (nIdx != -1)
 247                                         sortFilterVal.setOperators(oper[nIdx]);
 248                                 else
 249                                         sortFilterVal.setOperators("");
 250
 251                             break;
 252                         case 2: // values
 253                                 sortFilterVal.setValues(value.toString());
 254                                 break;
 255                         case 3: // isString
 256                                 sortFilterVal.setString(((Boolean)value).booleanValue());
 257                                 break;
 258                         case 4: // isOrderBy
 259                                 sortFilterVal.setOrderBy(((Boolean)value).booleanValue());
 260                                 break;
 261                                 case 5: // sorter
 262                                         int nId = ((Integer)value).intValue();
 263                                         if (nId != -1)
 264                                                 sortFilterVal.setSorter(order[nId]);
 265                                         else
 266                                                 sortFilterVal.setSorter("");
 267
 268                                         break;
 269                         default:
 270                             break;
 271                 }
 272
 273                 updateView();
 274                     updateQuery();
 275         }
 276     }
 277
 278         private SQLResultSetResults.Row row;
 279         private ConnectionUtil connectionUtil = new ConnectionUtil();
 280         CommonWizardUI comUI;
 281
 282         SortFilterTableValues[] sortFilterValues;
 283         TableViewer tableViewer = null;
 284         static Image imgCheck = null;
 285         static Image imgUncheck = null;
 286         String columnNames[];
 287         Label query;
 288         FilterSort filterSort = new FilterSort();
 289         private SQLResultSetResults results;
 290
 291         static {
 292             imgCheck = ImageStore.getImage(ImageStore.CHECKED);
 293             imgUncheck = ImageStore.getImage(ImageStore.UNCHECKED);
 294         }
 295
 296         // constant declarations
 297         String[] colNames = new String[] { "Where", "Operator", "Values", "Is String", "Order By", "Sorter" };
 298         String[] oper = new String[] { "=", "<>", "<", ">" };
 299         String[] order = new String[] { "", "ASC", "DESC" };
 300
 301         public SortFilterPage(String pageName) {
 302                 super(pageName);
 303         }
 304
 305         public void init(SQLResultSetResults results, SQLResultSetResults.Row row) {
 306                 this.results = results;
 307                 this.row = row;
 308         }
 309
 310         public void createControl(Composite parent) {
 311                 System.out.println("page create control"); //$NON-NLS-1$
 312
 313                 Composite container = new Composite(parent, SWT.NULL);
 314                 container.setLayout(new GridLayout());
 315                 container.setLayoutData(new GridData(GridData.FILL_BOTH | GridData.VERTICAL_ALIGN_BEGINNING));
 316
 317                 comUI = new CommonWizardUI();
 318
 319                 columnNames = this.results.getColumnNames();
 320                 int nLen = columnNames.length;
 321                 sortFilterValues = new SortFilterTableValues[nLen];
 322
 323                 for (int nCtr = 0; nCtr < nLen; nCtr++) {
 324                         sortFilterValues[nCtr] = new SortFilterTableValues();
 325                         sortFilterValues[nCtr].setColNames(columnNames[nCtr]);
 326
 327                         Object data = this.row == null ? null : this.row.get(nCtr+1);
 328                         sortFilterValues[nCtr].setValues(data == null ? "" : data.toString());
 329                 }
 330
 331                 createTable(container);
 332
 333                 query = new Label(container, SWT.WRAP);
 334                 query.setLayoutData(comUI.createGridData(1, GridData.FILL));
 335
 336                 setControl(container);
 337                 setPageComplete(true);
 338         }
 339
 340         public void updateQuery() {
 341                 filterSort.clearFilters();
 342
 343                 int nLen = columnNames.length;
 344                 for (int nCtr = 0; nCtr < nLen; nCtr++) {
 345                         if (sortFilterValues[nCtr].isWhere()) {
 346                                 filterSort.addFilter(columnNames[nCtr], sortFilterValues[nCtr].getOperators(), sortFilterValues[nCtr].getValues(), sortFilterValues[nCtr].isString());
 347                         }
 348                         if (sortFilterValues[nCtr].isOrderBy()) {
 349                                 filterSort.addSort(columnNames[nCtr], sortFilterValues[nCtr].getSorter());
 350                         } else {
 351                                 filterSort.removeSort(columnNames[nCtr]);
 352                         }
 353                 }
 354
 355                 query.setText(filterSort.toString());
 356         }
 357
 358         public boolean performFinish() {
 359                 this.results.setFilterSort(filterSort);
 360                 try {
 361                         this.results.refresh(this.connectionUtil.connect(
 362                                         this.results.getBookmark(), getShell()));
 363                         return true;
 364                 } catch (SQLException e) {
 365                         SQLExceptionDialog.openException(getShell(), this.results.getBookmark(), e);
 366                         return false;
 367                 }
 368         }
 369
 370         private void updateView() {
 371         this.tableViewer.update(sortFilterValues, null);
 372     }
 373
 374         /**
 375          * @param entity
 376          * @param columnName
 377          * @return
 378          * @throws NotConnectedException
 379          * @throws SQLException
 380          */
 381         protected Column getColumn(Entity entity, String columnName)  {
 382                 try {
 383                         return entity == null ? null : entity.getColumn(columnName);
 384                 } catch (NotConnectedException e) {
 385                         return null;
 386                 } catch (SQLException e) {
 387                         return null;
 388                 }
 389         }
 390
 391         private void createTable(Composite composite) {
 392         System.out.println("Creating table...");
 393         Table table = comUI.createTablePage(composite);
 394
 395         comUI.createTableColumn(table, colNames[0], SWT.LEFT, 0, 150); // isWhere
 396         comUI.createTableColumn(table, colNames[1], SWT.CENTER, 1, 70); // operator
 397         comUI.createTableColumn(table, colNames[2], SWT.LEFT, 2, 150); // values
 398         comUI.createTableColumn(table, colNames[3], SWT.LEFT, 3, 70); // isString
 399         comUI.createTableColumn(table, colNames[4], SWT.LEFT, 4, 150); // isOrderBy
 400         comUI.createTableColumn(table, colNames[5], SWT.CENTER, 5, 70); // sorter
 401                 this.tableViewer = new TableViewer(table);
 402                 this.tableViewer.setColumnProperties(colNames);
 403
 404                 CellEditor[] editor = new CellEditor[colNames.length];
 405
 406                 editor[0] = new CheckboxCellEditor(table, SWT.NULL);
 407
 408                 editor[1] = new ComboBoxCellEditor(table, oper, SWT.READ_ONLY);
 409
 410                 editor[2] = new TextCellEditor(table);
 411
 412                 editor[3] = new CheckboxCellEditor(table, SWT.NULL);
 413
 414                 editor[4] = new CheckboxCellEditor(table, SWT.NULL);
 415
 416                 editor[5] = new ComboBoxCellEditor(table, order, SWT.READ_ONLY);
 417
 418                 this.tableViewer.setCellEditors(editor);
 419                 this.tableViewer.setLabelProvider(new LabelProviderImpl());
 420                 this.tableViewer.setContentProvider(new ContentProviderImpl());
 421                 this.tableViewer.setCellModifier(new CellModifierImpl());
 422                 this.tableViewer.setInput(sortFilterValues);
 423     }
 424 }