Java 类org.eclipse.jface.viewers.TableViewer 实例源码

private void createTableViewer() {
    ArrayEditor arrayEditor = ((ArrayEditor) cellEditor);

    tableViewer = new TableViewer(table);
    tableViewer.setUseHashlookup(true);
    tableViewer.setColumnProperties(arrayEditor.columnNames);

    // Assign the cell editors to the viewer
    CellEditor[] editors = arrayEditor.getColumnEditors(table);
    tableViewer.setCellEditors(editors);

    // Set the cell modifier for the viewer
    tableViewer.setCellModifier(new ArrayEditorCellModifier(this, tableViewer));

    // Set the label provider for the viewer
    tableViewer.setLabelProvider(new ArrayEditorLabelProvider(cellEditor.getStyle()));

    // Set the content provider
    tableViewer.setContentProvider(new ArrayEditorContentProvider());
}

private Text addTextBoxInTable(TableViewer tableViewer, TableItem tableItem, String textBoxName, 
        String valueTextPane, String editorName, int columnIndex, Listener listener) {
    final Composite buttonPane = new Composite(tableViewer.getTable(), SWT.NONE);
    buttonPane.setLayout(new FillLayout());
    final Text text = new Text(buttonPane, SWT.NONE);
    text.addListener(SWT.Modify, listener);
    text.setData(FilterConstants.ROW_INDEX, tableViewer.getTable().indexOf(tableItem));
    tableItem.setData(textBoxName, text);
    tableItem.setData(valueTextPane, buttonPane);
    //text.addModifyListener(FilterHelper.INSTANCE.getTextModifyListener());

    final TableEditor editor = new TableEditor(tableViewer.getTable());
    editor.grabHorizontal = true;
    editor.grabVertical = true;
    editor.setEditor(buttonPane, tableItem, columnIndex);
    editor.layout();
    text.setData(editorName, editor);
    return text;
}

@Override
public void createControl ( final Composite parent )
{
    // stores must not be disposed!
    this.stores = Activator.getDefault ().getStoresSet ();

    this.tableViewer = new TableViewer ( parent );
    setControl ( this.tableViewer.getControl () );
    this.tableViewer.setContentProvider ( new ObservableSetContentProvider () );
    this.tableViewer.setLabelProvider ( new ConnectionLabelProvider () );
    this.tableViewer.setInput ( this.stores );

    this.tableViewer.addSelectionChangedListener ( new ISelectionChangedListener () {

        @Override
        public void selectionChanged ( final SelectionChangedEvent event )
        {
            update ();
        }
    } );

    update ();
}

@Override
public void run() {
    ViewDataPreferencesVO viewDataPreferencesVO = debugDataViewer.getViewDataPreferences();
    delimiter = viewDataPreferencesVO.getDelimiter();
    quoteCharactor = viewDataPreferencesVO.getQuoteCharactor();
    headerEnabled = viewDataPreferencesVO.getIncludeHeaders();
    TableViewer tableViewer = debugDataViewer.getTableViewer();
    List<RowData> eachRowData = getListOfRowData(tableViewer);
    List<String[]> exportedfileDataList = new ArrayList<String[]>();
    TableColumn[] columns = tableViewer.getTable().getColumns();
    if (headerEnabled != null) {
        addHeadersInList(tableViewer, exportedfileDataList, columns);
    }
    addRowsDataInList(tableViewer, eachRowData, exportedfileDataList);
    FileDialog fileDialog = new FileDialog(Display.getDefault().getActiveShell(), SWT.SAVE);
    String filePath = getPathOfFileDialog(fileDialog);
    writeDataInFile(exportedfileDataList, filePath);
}

@Override
protected Control createDialogArea(Composite parent)
{
    Composite dialogArea = (Composite) super.createDialogArea(parent);
    Composite composite = new Composite(dialogArea, SWT.NONE);
    createMessageArea(composite);
    listViewer = new TableViewer(composite, SWT.TOP | SWT.BORDER);

    GridData data = new GridData(GridData.FILL_BOTH);
    data.widthHint = 400;
    data.heightHint = 400;
    listViewer.getTable().setLayoutData(data);
    listViewer.setLabelProvider(WorkbenchLabelProvider.getDecoratingWorkbenchLabelProvider());
    listViewer.setContentProvider(new JarProjectContentProvider(null));
    listViewer.setComparator(new ViewerComparator());
    listViewer.setInput(ResourcesPlugin.getWorkspace());
    applyDialogFont(composite);

    listViewer.setSelection(new StructuredSelection(initialSelection));
    GridLayoutFactory.fillDefaults().generateLayout(composite);
    return dialogArea;
}

private void loadProperties(TableViewer tv) {

        if (runtimePropertyMap != null && !runtimePropertyMap.isEmpty()) {
            for (String key : runtimePropertyMap.keySet()) {
                RuntimeProperties p = new RuntimeProperties();
                if (validateBeforeLoad(key, runtimePropertyMap.get(key))) {
                    p.setPropertyName(key);
                    p.setPropertyValue(runtimePropertyMap.get(key));
                    propertyList.add(p);
                }
            }
            tv.refresh();

        } //$NON-NLS-1$

    }

private boolean isExistInTable(TableViewer tableViewer, String text){
  boolean isDataExist = false;
  Table table = tableViewer.getTable();
  TableItem[] tableItems = table.getItems();
  for(int i=0;i<tableItems.length;i++){
    TableItem tableItem = tableItems[i];
    for(int j=1;j <= table.getColumnCount()-1;j++){
        if(StringUtils.containsIgnoreCase(tableItem.getText(j), text)){
            label.setVisible(false);
            isDataExist = true;
            return isDataExist;
        }else{
            label.setVisible(true);
            label.setText(labelText);
            isDataExist =  false;
        }

    }
  }
return isDataExist;
 }

private void loadProperties(TableViewer tv) {

        if (secondaryColumnsMap != null && !secondaryColumnsMap.isEmpty()) {
            for (String key : secondaryColumnsMap.keySet()) {
                SecondaryColumnKeysInformation p = new SecondaryColumnKeysInformation();
                if (validateBeforeLoad(key, secondaryColumnsMap.get(key))) {
                    p.setColumnName(key);
                    p.setSortOrder(secondaryColumnsMap.get(key));
                    propertyList.add(p);
                    tv.refresh();
                    if(!sourceFieldsList.contains(key)){
                        tv.getTable().getItem(propertyList.size()-1).setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_RED));
                    }else{
                        tv.getTable().getItem(propertyList.size()-1).setForeground(Display.getCurrent().getSystemColor(SWT.COLOR_BLACK));
                    }
                }
            }
            tv.refresh();

        } //$NON-NLS-1$

    }

private void loadProperties(TableViewer tv) {

        if (fieldNameList != null && !fieldNameList.isEmpty()) {
            for (String key : fieldNameList) {
                FilterProperties filter = new FilterProperties();
                if (validateBeforeLoad(key)) {
                    filter.setPropertyname(key);
                    propertyList.add(filter);

                }
            }

            tv.refresh();
        } else {

            logger.debug("LodProperties :: Empty Map");
        }
    }

private void operationInputTableAddButton(
         MappingSheetRow mappingSheetRow,
         TableViewer tableViewer) {
    FilterProperties filterProperties = new FilterProperties();
    filterProperties.setPropertyname("");
    if (!mappingSheetRow.getInputFields().contains(filterProperties)) {
        mappingSheetRow.getInputFields().add(filterProperties);

        tableViewer.refresh();
        int i = mappingSheetRow.getInputFields().size() == 0 ? mappingSheetRow.getInputFields().size()
                : mappingSheetRow.getInputFields().size() - 1;
        tableViewer.editElement(tableViewer.getElementAt(i), 0);
    }
}

/**
 * Create a new {@link TableViewer} with {@link DataModel} elements.
 * 
 * @param site The {@link IWorkbenchPartSite} used to register the table's context menu.
 * @param table The {@link Table}.
 * @param dataModelClass The {@link DataModel} element {@link Class}.
 * @param dataModelElementType The {@link DataModel} {@link IElementType}.
 * @param input The {@link TableViewer} input.
 * @param inputElementType The input {@link IElementType}.
 * @return A new {@link TableViewer}.
 */
public static TableViewer createDataModelTableViewer(IWorkbenchPartSite site, Table table, Class<?> dataModelClass,
        final IElementType dataModelElementType, Object input, IElementType inputElementType) {

    TableViewer tableViewer = createTableViewer(table, dataModelClass, dataModelElementType, input,
            inputElementType, new DataModelElementBinding());

    List<BaseAction> tableActions = dataModelElementType.getActions();
    if (tableActions != null) {
        for (BaseAction action : tableActions) {
            action.setSelectionProvider(tableViewer);
        }

        MenuManager menuManager = new MenuManager("#PopupMenu");
        menuManager.setRemoveAllWhenShown(true);
        menuManager.addMenuListener(new IMenuListener() {

            public void menuAboutToShow(IMenuManager manager) {
                dataModelElementType.fillContextMenu(manager);
            }

        });

        Menu menu = menuManager.createContextMenu(table);
        table.setMenu(menu);
        site.registerContextMenu(menuManager, tableViewer);
    }

    return tableViewer;
}

/**
 * This method is used to set cursor position at last row when any field is 
 * deleted from table-viewer
 * 
 * @param tableViewer
 * @param indexes
 * @param gridList
 */
public  void setCursorOnDeleteRow(TableViewer tableViewer,int[] indexes,List<?> gridList){
       Table table = tableViewer.getTable();
       //highlight after deletion
       if(indexes.length == 1 && gridList.size() > 0){//only one item is deleted
             if(gridList.size() == 1){//list contains only one element
                   table.select(0);// select the first element
                   tableViewer.editElement(tableViewer.getElementAt(0), 0);
             }
             else if(gridList.size() == indexes[0]){//deleted last item 
                   table.select(gridList.size() - 1);//select the last element which now at the end of the list
                   tableViewer.editElement(tableViewer.getElementAt(gridList.size() - 1), 0);
             }
             else if(gridList.size() > indexes[0]){//deleted element from middle of the list
                   table.select( indexes[0] == 0 ? 0 : (indexes[0] - 1) );//select the element from at the previous location
                   tableViewer.editElement(tableViewer.getElementAt(indexes[0] == 0 ? 0 : (indexes[0] - 1)), 0);
             }
       }
       else if(indexes.length >= 2){//multiple items are selected for deletion
             if(indexes[0] == 0){//delete from 0 to ...
                   if(gridList.size() >= 1){//list contains only one element
                         table.select(0);//select the remaining element
                         tableViewer.editElement(tableViewer.getElementAt(0), 0);
                   }
             }
             else{//delete started from element other than 0th element
                   table.select((indexes[0])-1);//select element before the start of selection   
                   tableViewer.editElement(tableViewer.getElementAt((indexes[0])-1), 0);
             }
       }
   }

private static void initTableViewer(TableViewer tableViewer, ElementTypes elementTypes, Object input,
        IElementBinding elementBinding) {

    IViewerType viewerType = new TableViewerType();

    Table table = tableViewer.getTable();
    Class<?> contentProviderInterfaceType = IStructuredContentProvider.class;
    if ((table.getStyle() & SWT.VIRTUAL) != 0) {
        contentProviderInterfaceType = ILazyContentProvider.class;
    }

    registerTableListeners(table);

    initViewer(tableViewer, elementTypes, input, elementBinding, viewerType, contentProviderInterfaceType);
}

private void elementsChanged() {

        TableViewer tableViewer = getTableViewer();
        tableViewer.refresh();

        IElementType elementType = getElementType();
        elementType.packTable(getTable());
        layout(true);

        fireOrchestrationChange();
    }

private TableViewerColumn createTableColumns(TableViewer tableViewer, String columnLabel, int width) {
    TableViewerColumn tableViewerColumn = new TableViewerColumn(tableViewer, SWT.CENTER);
    TableColumn tableColumn = tableViewerColumn.getColumn();
    tableColumn.setWidth(width);
    tableColumn.setText(columnLabel);
    return tableViewerColumn;
}

public MonitorsViewTable ( final Composite parent, final IViewSite viewSite, final int style, final WritableSet monitors, final List<ColumnProperties> columnSettings )
{
    super ( parent, style );

    this.monitors = monitors;

    final FillLayout layout = new FillLayout ();
    setLayout ( layout );

    this.tableViewer = new TableViewer ( this, SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION | SWT.MULTI );
    this.tableRef.set ( this.tableViewer );
    createColumns ( this.tableViewer );
    applyColumSettings ( columnSettings );
    this.tableViewer.getTable ().setHeaderVisible ( true );
    this.tableViewer.getTable ().setLinesVisible ( true );
    this.tableViewer.setUseHashlookup ( true );
    this.tableViewer.setSorter ( new Sorter ( Columns.LAST_FAIL_TIMESTAMP, SWT.DOWN ) );
    this.tableViewer.getTable ().setSortDirection ( SWT.DOWN );

    hookContextMenu ( this.tableViewer.getControl (), this.tableViewer, viewSite );

    viewSite.setSelectionProvider ( this.tableViewer );

    final ObservableSetContentProvider contentProvider = new ObservableSetContentProvider ();
    this.tableViewer.setContentProvider ( contentProvider );
    this.tableViewer.setLabelProvider ( new MonitorTableLabelProvider ( Properties.observeEach ( contentProvider.getKnownElements (), BeanProperties.values ( new String[] { "id", "monitor" } ) ), Settings.getTimeZone () ) ); //$NON-NLS-1$ //$NON-NLS-2$
    this.tableViewer.setInput ( this.monitors );

    contentProvider.getRealizedElements ().addSetChangeListener ( new ISetChangeListener () {
        @Override
        public void handleSetChange ( final SetChangeEvent event )
        {
            if ( !MonitorsViewTable.this.scrollLock )
            {
                MonitorsViewTable.this.tableViewer.getTable ().setTopIndex ( 0 );
            }
        }
    } );
}

private void moveRowDown(TableViewer nameValueTableViewer)
{
    Table table = nameValueTableViewer.getTable();
    int[] indexes = table.getSelectionIndices();
    for (int i = indexes.length - 1; i > -1; i--) {

        if (indexes[i] < mappingSheetRow.getNameValueProperty().size() - 1) {
            Collections.swap(mappingSheetRow.getNameValueProperty(), indexes[i], indexes[i] + 1);
            nameValueTableViewer.refresh();
            applyButton.setEnabled(true);

        }
    }

}

/**
 * Gets the adds-at-the-end listener.
 * 
 * @param tableViewer
 *            the table viewer
 * @param conditionList
 *            the condition list
 * @param dummyList
 *            the dummy list
 * @return the adds the at end listener
 */
public SelectionAdapter getAddAtEndListener(final TableViewer tableViewer, final List<Condition> conditionList, 
        final List<Condition> dummyList) {
    return new SelectionAdapter() {
          @Override
          public void widgetSelected(SelectionEvent e) {
                conditionList.add(conditionList.size(), new Condition());
                dummyList.clear();
                dummyList.addAll(cloneList(conditionList));
                tableViewer.refresh();
          }
    };
}

@Override
public void createPart ( final Composite parent )
{
    super.createPart ( parent );

    this.viewer = new TableViewer ( parent, SWT.FULL_SELECTION );

    final TableLayout tableLayout = new TableLayout ();

    final TableViewerColumn col1 = new TableViewerColumn ( this.viewer, SWT.NONE );
    col1.getColumn ().setText ( Messages.AttributesPart_NameLabel );
    tableLayout.addColumnData ( new ColumnWeightData ( 50 ) );

    final TableViewerColumn col2 = new TableViewerColumn ( this.viewer, SWT.NONE );
    col2.getColumn ().setText ( Messages.AttributesPart_TypeLabel );
    tableLayout.addColumnData ( new ColumnWeightData ( 20 ) );

    final TableViewerColumn col3 = new TableViewerColumn ( this.viewer, SWT.NONE );
    col3.getColumn ().setText ( Messages.AttributesPart_ValueLabel );
    tableLayout.addColumnData ( new ColumnWeightData ( 50 ) );

    this.viewer.getTable ().setHeaderVisible ( true );
    this.viewer.getTable ().setLayout ( tableLayout );

    ViewerSupport.bind ( this.viewer, this.entries, new IValueProperty[] { PojoProperties.value ( "name" ), PojoProperties.value ( "type" ), PojoProperties.value ( "value" ) } ); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

    this.viewer.setComparator ( new ViewerComparator () );
}

private void addDoubleClickListener(TableViewer availableFieldtableViewer) {
    DragSource  dragSource = new DragSource(availableFieldsTable, DND.DROP_COPY);
    dragSource.setTransfer(new Transfer[] { ObjectTransfer.getInstance() });

    dragSource.addDragListener(new DragSourceAdapter() {
        public void dragSetData(DragSourceEvent event) { // Set the data to be the first selected item's text
            List<Object> list=new ArrayList<Object>();
            for(TableItem tableItem:availableFieldsTable.getSelection()){
                list.add(tableItem.getData());
            }
            event.data=list.toArray(new Object[list.size()]);
        }
    });
}

private void syncTransformFieldsWithSchema() {

    List<FilterProperties> filterProperties = convertSchemaToFilterProperty();
    if(checkIfSchemaIsBlank(filterProperties))
    {
    return;
    }   
    SchemaSyncUtility.INSTANCE.removeOpFields(filterProperties, transformMapping,
            transformMapping.getMappingSheetRows(),component.getComponentName());
    Schema schema = (Schema) component.getProperties().get(Constants.SCHEMA_PROPERTY_NAME);
    List<NameValueProperty> outputFileds= SchemaSyncUtility.INSTANCE.getComponentSchemaAsProperty(schema.getGridRow());
    SchemaSyncUtility.INSTANCE.filterCommonMapFields(outputFileds, transformMapping);
    Map<Integer,FilterProperties> indexValueParameterMap=SchemaSyncUtility.INSTANCE.retainIndexAndValueOfParameterFields
            (transformMapping.getOutputFieldList());
    transformMapping.getOutputFieldList().clear();
    SchemaSyncUtility.INSTANCE.addOperationFieldAndMapPassthroughfieldToOutputField(transformMapping);
    List<FilterProperties> finalSortedList=SchemaSyncUtility.INSTANCE.
            sortOutputFieldToMatchSchemaSequence(filterProperties,transformMapping);
    transformMapping.getOutputFieldList().clear();
    transformMapping.getOutputFieldList().addAll(finalSortedList);
    SchemaSyncUtility.INSTANCE.addParamtereFieldsToSameIndexAsBeforePull(indexValueParameterMap,transformMapping);
    refreshOutputTable();
    for(ExpandItem item:expandBar.getItems())
    {
        TableViewer tableViewer=(TableViewer)item.getData(OUTPUT_TABLE_VIEWER);
        if(tableViewer!=null)
        tableViewer.refresh();
    }
}

public InputFieldEditingSupport(TableViewer  viewer) {
    super(viewer);
    this.viewer = viewer;
    //cellEditor = new TextCellEditor(viewer.getTable(), SWT.MULTI | SWT.WRAP | SWT.BORDER);
    cellEditor = new TextCellEditor(viewer.getTable());

    final Text aaa = (Text)cellEditor.getControl();
}

/**
 * @param transformDialogNew
 * @param transformMapping
 * @param inputFields
 * @param isSingleColumn
 * @param isExpression
 * @param tableViewer
 */
public DragDropTransformOpImp(TransformDialog transformDialogNew,TransformMapping transformMapping,List<FilterProperties> inputFields, 
        boolean isSingleColumn,boolean isExpression,TableViewer tableViewer) 
{
    this.mapAndPassThroughField = transformMapping.getMapAndPassthroughField();
    this.listOfInputFields=inputFields;
    this.isSingleColumn = isSingleColumn;
    this.operationInputfieldtableviewer=tableViewer;
    this.transformDialogNew=transformDialogNew;
    this.outerOutputList=transformMapping.getOutputFieldList();
    this.isExpression=isExpression;
}

@Override
protected Control createDialogArea(Composite parent) {

    // create a composite with standard margins and spacing
    Composite composite = (Composite)super.createDialogArea(parent);
    composite.setLayout(new GridLayout(1, false));

    final CLabel warning = new CLabel(composite, SWT.LEFT);
    warning.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
    warning.setImage(Activator.imageDescriptorFromPlugin(Activator.PLUGIN_ID, "icons/error.png").createImage());
    warning.setText("Expert queue configuration parameters, please use with caution.");

    TableViewer viewer   = new TableViewer(composite, SWT.FULL_SELECTION | SWT.MULTI | SWT.V_SCROLL | SWT.H_SCROLL);
    viewer.setUseHashlookup(true);
    viewer.getTable().setHeaderVisible(true);
    viewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

    createColumns(viewer);
    viewer.setContentProvider(createContentProvider());

    viewer.setInput(props);

    final Button adv = new Button(composite, SWT.PUSH);
    adv.setLayoutData(new GridData(SWT.RIGHT, SWT.CENTER, true, false));
    adv.setText("Advanced...");

    adv.addSelectionListener(new SelectionAdapter() {
        @Override
        public void widgetSelected(SelectionEvent e) {
            PreferenceDialog pref = PreferencesUtil.createPreferenceDialogOn(getShell(), "org.dawnsci.commandserver.ui.activemqPage", null, null);
            if (pref != null) pref.open();
        }
    });

    return composite;
}

private ICellEditorValidator sourceEditorValidator(
        final TableViewer viewer, final String errorMessage,
        final List<LookupMapProperty> propertyList) {
    ICellEditorValidator propertyValidator = new ICellEditorValidator() {
        @Override
        public String isValid(Object value) {
            String currentSelectedFld = viewer.getTable()
                    .getItem(viewer.getTable().getSelectionIndex())
                    .getText();
            String valueToValidate = String.valueOf(value).trim();
            if (StringUtils.isEmpty(valueToValidate)) {
                errorLabel.setText(errorMessage);
                errorLabel.setVisible(true);
                okButton.setEnabled(false);
                return "ERROR";
            } else {
                okButton.setEnabled(true);
            }
            for (LookupMapProperty temp : propertyList) {
                if (!currentSelectedFld.equalsIgnoreCase(valueToValidate)
                        && temp.getSource_Field().equalsIgnoreCase(
                                valueToValidate)) {
                    errorLabel
                            .setText(Messages.SourceFieldAlreadyExists);
                    errorLabel.setVisible(true);
                    okButton.setEnabled(false);
                    return "ERROR";
                } else {
                    errorLabel.setVisible(false);
                    okButton.setEnabled(true);
                    validateDuplicatesInOutputField();
                }
            }
            return null;
        }
    };

    return propertyValidator;
}

/**
 * Gets the field name modify listener.
 * 
 * @param tableViewer
 *            the table viewer
 * @param conditionsList
 *            the conditions list
 * @param fieldsAndTypes
 *            the fields and types
 * @param fieldNames
 *            the field names
 * @param saveButton
 *            the save button
 * @param displayButton
 *            the display button
 * @return the field name modify listener
 */
public ModifyListener getFieldNameModifyListener(final TableViewer tableViewer, final List<Condition> conditionsList,
        final Map<String, String> fieldsAndTypes, final String[] fieldNames, final Button saveButton, final Button displayButton) {
    ModifyListener listener = new ModifyListener() {

        @Override
        public void modifyText(ModifyEvent e) {
            CCombo source = (CCombo) e.getSource();
            int index = (int) source.getData(FilterConstants.ROW_INDEX);
            Condition filterConditions = conditionsList.get(index);
            String fieldName = source.getText();
            filterConditions.setFieldName(fieldName);

            if(StringUtils.isNotBlank(fieldName)){
                String fieldType = fieldsAndTypes.get(fieldName);
                TableItem item = tableViewer.getTable().getItem(index);
                CCombo conditionalCombo = (CCombo) item.getData(FilterConditionsDialog.CONDITIONAL_OPERATORS);
                if(conditionalCombo != null && StringUtils.isNotBlank(fieldType)){
                    conditionalCombo.setText(filterConditions.getConditionalOperator());
                    conditionalCombo.setItems(FilterHelper.INSTANCE.getTypeBasedOperatorMap().get(fieldType));
                    new AutoCompleteField(conditionalCombo, new CComboContentAdapter(), conditionalCombo.getItems());
                }
            }
            validateCombo(source);
            toggleSaveDisplayButton(conditionsList, fieldsAndTypes, fieldNames, saveButton, displayButton);
        }
    };
    return listener;
}

/**
 * @param transformDialogNew
 * @param mappingSheetRows
 * @param outputFieldTableViewer
 * @param mapAndPassThroughField
 * @param outputFieldMap
 * @param listOfOutputFields
 * @param listOfInputFields
 * @param isSingleColumn
 * @param tableViewer
 * @param t
 */
public DragDropTransformOpImp(TransformDialog transformDialogNew,Map<String,List<FilterProperties>> outputFieldMap,
        List<FilterProperties> listOfOutputFields,List<FilterProperties> listOfInputFields, 
        boolean isSingleColumn,TableViewer tableViewer,TableViewer t,List<FilterProperties> outerOutputList) 
{
    this.listOfInputFields = listOfInputFields;
    this.isSingleColumn = isSingleColumn;
    this.operationInputfieldtableviewer=tableViewer;
    this.listOfOutputFields=listOfOutputFields;
    this.operationOutputFieldTableViewer=t;
    this.outputFieldMap=outputFieldMap;
    this.transformDialogNew=transformDialogNew;
    this.outerOutputList=outerOutputList;
}

/**
 * Dispose all columns.
 * 
 * @param tableViewer
 *            the table viewer
 */
public void disposeAllColumns(TableViewer tableViewer){
    TableColumn[] columns = tableViewer.getTable().getColumns();
    TableItem[] items = tableViewer.getTable().getItems();
    for (int i = 0; i < items.length; i++) {
        items[i].dispose();
    }
    for (TableColumn tc : columns) {
        tc.dispose();
    }
}

public TextCellEditingSupport(TableViewer viewer, String fName, int type) {
    super(viewer);
    this.viewer = viewer;
    this.fName = fName;
    this.type = type;
    this.editor = new TextCellEditor(viewer.getTable());
}

/**
 * The Function will set Table column values
 * @param tableViewer
 * @param jobDetails
 */
private void setTableColumnValues(TableViewer tableViewer, List<Job> jobDetails){
    jobDetails.sort((job1, job2)-> job2.getUniqueJobId().compareTo(job1.getUniqueJobId()));
    jobDetails.forEach(job -> {
        String timeStamp = getTimeStamp(job.getUniqueJobId());
        TableItem items = new TableItem(table, SWT.None);
        items.setText(0, job.getUniqueJobId());
        items.setText(1, timeStamp);
        String mode = getJobExecutionMode(job.isRemoteMode());
        items.setText(2, mode);
        items.setText(3, job.getJobStatus());
    });
}

private CellLabelProvider getGroupCheckCellProvider(final TableViewer tableViewer, final List<Condition> conditionsList, 
        final Button btnAddGrp) {
    return new CellLabelProvider() {

        @Override
        public void update(ViewerCell cell) {
            final TableItem item = (TableItem) cell.getItem();
            // DO NOT REMOVE THIS CONDITION. The condition is return to
            // prevent multiple updates on single item
            if (item.getData("UPDATED3") == null) {
                item.setData("UPDATED3", TRUE);
            } else {
                return;
            }
            addCheckButtonInTable(tableViewer, item, GROUP_CHECKBOX, GROUP_CHECKBOX_PANE, GROUP_EDITOR, cell.getColumnIndex(), 
                    FilterHelper.INSTANCE.checkButtonListener(tableViewer, conditionsList,btnAddGrp));
            item.addDisposeListener(new DisposeListener() {

                @Override
                public void widgetDisposed(DisposeEvent e) {
                    Button groupButton = (Button) item.getData(GROUP_CHECKBOX);
                    ((TableEditor)groupButton.getData(GROUP_EDITOR)).dispose();
                    groupButton.dispose();

                    Composite composite = (Composite)item.getData(GROUP_CHECKBOX_PANE);
                    composite.dispose();
                }
            });
        }
    };
}

private void joinOutputProperty(TableViewer viewer, String sourceFieldValue) {
    String outputFieldValue = null;
    if (sourceFieldValue == null) {
        sourceFieldValue = "";
        outputFieldValue = "";
    } else {
        outputFieldValue = sourceFieldValue.split("\\.")[1];
    }
    LookupMapProperty property = new LookupMapProperty();

    if (joinOutputList.size() != 0) {
        if (!validateOutputSchema(outputFieldValue, sourceFieldValue))
            return;
        property.setSource_Field(sourceFieldValue);
        property.setOutput_Field(outputFieldValue);
        joinOutputList.add(property);
        viewer.refresh();
        viewer.editElement(property,
                0);
    } else {
        property.setSource_Field(sourceFieldValue);
        property.setOutput_Field(outputFieldValue);
        joinOutputList.add(property);
        viewer.refresh();
        viewer.editElement(property, 0);
    }
}

@Override
protected void okPressed() {


    if(OSValidator.isMac())
    {   
        List<TableViewer> tableViewers = new ArrayList<TableViewer>();
        tableViewers.add(outputTableViewer);
        tableViewers.addAll(java.util.Arrays.asList(inputTableViewer));
        for(TableViewer tableView : tableViewers){
            if(tableView !=null){
        for(CellEditor cellEditor : tableView.getCellEditors()){
            if(cellEditor !=null){
            cellEditor.getControl().setEnabled(false); //Saves the existing value of CellEditor
            cellEditor.getControl().setEnabled(true);
            }
        }
            }
        }
    }
    populateCurrentItemsOfTable();
    if (previousItems.length == 0 && currentItems.length != 0) {
        propertyDialogButtonBar.enableApplyButton(true);
    } else if ((currentItems.length != 0 && previousItems.length != 0)) {
        if (!Arrays.equals(currentItems, previousItems))
            propertyDialogButtonBar.enableApplyButton(true);
    }
    getJoinPropertyGrid();
    super.close();
}

private void forwardTableTraverse(TableViewer debugDataViewer, TableCursor tableCursor){
    TableItem previousSelectedTableItem = null;
    if(debugDataViewer.getData("SELECTED_ROW_INDEX")!=null){
        previousSelectedTableItem = debugDataViewer.getTable().getItem((int) debugDataViewer.getData("SELECTED_ROW_INDEX"));
        findColIndex++;
    }
    Table table = debugDataViewer.getTable();
    TableItem[] tableItems = table.getItems();
    if(findColIndex == prevColSelection && findRowIndex == prevRowSelection){
        findColIndex++;
    }
    if(findRowIndex < 0){
        findRowIndex = 0;
    }
    for(;findRowIndex<tableItems.length;){
        TableItem tableItem = tableItems[findRowIndex];
        for(;findColIndex <= table.getColumnCount();findColIndex++){
            if(StringUtils.containsIgnoreCase(tableItem.getText(findColIndex), findText.getText())){
                if(prevColSelection > 0){
                    previousSelectedTableItem.setBackground(prevColSelection, Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
                }
                label.setVisible(false);
                table.showItem(tableItem);
                table.showColumn(table.getColumn(findColIndex));
                tableCursor.setSelection(findRowIndex, findColIndex);
                tableCursor.setVisible(false);
                tableItem.setBackground(findColIndex, Display.getDefault().getSystemColor(SWT.COLOR_DARK_GRAY));
                debugDataViewer.setData("SELECTED_ROW_INDEX", findRowIndex);
                debugDataViewer.setData("SEELCTED_COLUMN_INDEX", findColIndex);
                prevColSelection = findColIndex;
                return;
            }
        }
        findRowIndex++;
        findColIndex=1;
        if(findRowIndex >= tableItems.length){ findRowIndex = 0;}
    }
}

private TableColumnLayout setTableLayoutToMappingTable(TableViewer tableViewer) {
    TableColumnLayout layout = new TableColumnLayout();
    tableViewer.getControl().getParent().setLayout(layout);

    tableViewer.refresh();
    return layout;
}

@Override
protected Control createContents(Composite parent)
{
    Composite composite = new Composite(parent, SWT.NONE);

    initialize();

    createDescriptionLabel(composite);

    listViewer = new TableViewer(composite, SWT.TOP | SWT.BORDER);

    if( !project.isOpen() )
        listViewer.getControl().setEnabled(false);

    listViewer.setLabelProvider(WorkbenchLabelProvider.getDecoratingWorkbenchLabelProvider());
    listViewer.setContentProvider(new JarProjectContentProvider(project));
    listViewer.setComparator(new ViewerComparator());
    listViewer.setInput(project.getWorkspace());

    String regName = getPreferenceStore().getString(JPFClasspathPlugin.PREF_REGISTRY_NAME);
    if( !regName.isEmpty() )
    {
        IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
        listViewer.setSelection(new StructuredSelection(root.getProject(regName)));
    }
    listViewer.addSelectionChangedListener(new ISelectionChangedListener()
    {
        @Override
        public void selectionChanged(SelectionChangedEvent event)
        {
            modified = true;
        }
    });
    applyDialogFont(composite);

    GridLayoutFactory.fillDefaults().generateLayout(composite);

    return composite;
}

private void setColumnsName (TableViewer tv) {
  for (int i = 0; i < ColumnsConst.COLUMNS.length; i++) {
   TableColumn col = new TableColumn(tv.getTable(), SWT.LEFT );
       col.setText(ColumnsConst.COLUMNS[i]);
       col.setData(new Integer (i));
       col.addSelectionListener(new SelectionAdapter() {
           public void widgetSelected(SelectionEvent event) {
            TableColumn tc  = (TableColumn)event.getSource();
            Integer index = (Integer)tc.getData();
               ((PerformanceStatsViewerSorter) tv.getComparator()).doSort(index);
               tv.refresh();
           }
      });
  }
}

private Point getCellId(Point mouseLocation,TableViewer tableViewer){
    ViewerCell cell = tableViewer.getCell(mouseLocation);
    if(cell==null){
        return null;
    }
    int columnIndex = cell.getColumnIndex();                
    int rowIndex = tableViewer.getTable().indexOf((TableItem)cell.getItem())  ;
    return new Point(rowIndex, columnIndex);
}

private Table createMappingTable(Composite composite_6) {
    mappingTableViewer = new TableViewer(composite_6, SWT.BORDER
            | SWT.FULL_SELECTION | SWT.MULTI);
    Table table = mappingTableViewer.getTable();
    table.setLinesVisible(true);
    table.setHeaderVisible(true);
    GridData gd_table = new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1);
    gd_table.widthHint = 374;
    table.setLayoutData(gd_table);
    mappingTableViewer.setContentProvider(new ArrayContentProvider());
    ColumnViewerToolTipSupport.enableFor(mappingTableViewer);
    return table;
}

private ICellEditorValidator sourceEditorValidator(
        final TableViewer viewer, final String errorMessage,
        final List<LookupMapProperty> propertyList) {
    ICellEditorValidator propertyValidator = new ICellEditorValidator() {
        @Override
        public String isValid(Object value) {
            String currentSelectedFld = viewer.getTable()
                    .getItem(viewer.getTable().getSelectionIndex())
                    .getText();
            String valueToValidate = String.valueOf(value).trim();
            if (StringUtils.isEmpty(valueToValidate)) {
                propertyError.setText(errorMessage);
                propertyError.setVisible(true);
                okButton.setEnabled(false);
                return "ERROR";
            } else {
                okButton.setEnabled(true);
            }
            for (LookupMapProperty temp : propertyList) {
                if (!currentSelectedFld.equalsIgnoreCase(valueToValidate)
                        && temp.getSource_Field().equalsIgnoreCase(
                                valueToValidate)) {
                    propertyError
                            .setText(Messages.SourceFieldAlreadyExists);
                    propertyError.setVisible(true);
                    okButton.setEnabled(false);
                    return "ERROR";
                } else {
                    propertyError.setVisible(false);
                    okButton.setEnabled(true);
                    validateDuplicatesInOutputField();
                }
            }
            return null;
        }
    };
    return propertyValidator;
}