Example usage for org.apache.commons.lang ArrayUtils toPrimitive

List of usage examples for org.apache.commons.lang ArrayUtils toPrimitive

Introduction

In this page you can find the example usage for org.apache.commons.lang ArrayUtils toPrimitive.

Prototype

public static boolean[] toPrimitive(Boolean[] array) 

Source Link

Document

Converts an array of object Booleans to primitives.

Usage

From source file:org.s23m.cell.editor.semanticdomain.ui.components.FileReceiver.java

public String getBase64ContentString() {
    final Byte[] bytes = byteList.toArray(new Byte[byteList.size()]);
    return SerializerHolder.getS23MInstanceSerializer(SerializationType.XML)
            .encodeByteArrayInBase64(ArrayUtils.toPrimitive(bytes));
}

From source file:org.smallmind.persistence.orm.hibernate.LongArrayUserType.java

@Override
public Object nullSafeGet(final ResultSet rs, final String[] names, final SessionImplementor sessionImplementor,
        final Object owner) throws HibernateException, SQLException {

    Array array = rs.getArray(names[0]);
    Long[] javaArray = (Long[]) array.getArray();
    return ArrayUtils.toPrimitive(javaArray);
}

From source file:org.talend.commons.ui.swt.extended.table.AbstractExtendedTableViewer.java

/**
 * DOC amaumont Comment method "initListeners".
 *//*  w  ww  .j  av  a  2 s.c o  m*/
protected void initModelListeners() {
    if (getExtendedTableModel() != null) {

        getExtendedTableModel().addBeforeOperationListListener(1, new IListenableListListener() {

            public void handleEvent(ListenableListEvent event) {
                handleBeforeListenableListOperationEvent(event);
            }

        });

        getExtendedTableModel().addAfterOperationListListener(1, new IListenableListListener() {

            public void handleEvent(ListenableListEvent event) {
                handleAfterListenableListOperationEvent(event);
            }

        });

        getExtendedTableModel().addAfterOperationListListener(100, new IListenableListListener<B>() {

            public void handleEvent(ListenableListEvent<B> event) {
                if (tableViewerCreator.getTable() != null && !tableViewerCreator.getTable().isDisposed()) {
                    // tableViewerCreator.getTable().forceFocus();

                    if (event.type == TYPE.ADDED) {
                        if (event.index != null) {
                            tableViewerCreator.getSelectionHelper().setSelection(event.index,
                                    event.index + event.addedObjects.size() - 1);
                        } else if (event.indicesTarget != null) {
                            int[] selection = ArrayUtils
                                    .toPrimitive(event.indicesTarget.toArray(new Integer[0]));
                            tableViewerCreator.getSelectionHelper().setSelection(selection);

                        }
                    } else if (event.type == TYPE.REMOVED) {
                        if (event.index != null
                                || event.indicesOrigin != null && event.indicesOrigin.size() > 0) {
                            int index = 0;
                            if (event.index != null) {
                                index = event.index;
                            } else {
                                index = event.indicesOrigin.get(event.indicesOrigin.size() - 1);
                            }
                            int itemCount = tableViewerCreator.getTable().getItemCount();
                            if (index >= itemCount) {
                                index = itemCount - 1;
                            }
                            tableViewerCreator.getSelectionHelper().setSelection(index, index);
                        } else {
                            tableViewerCreator.getTable().deselectAll();
                        }

                    } else if (event.type == TYPE.SWAPED) {
                        if (event.indicesTarget != null) {
                            int[] selection = ArrayUtils
                                    .toPrimitive(event.indicesTarget.toArray(new Integer[0]));
                            tableViewerCreator.getSelectionHelper().setSelection(selection);
                        }
                    }
                }

            }

        });
    }

}

From source file:org.talend.dataquality.record.linkage.ui.composite.chart.BlockingKeyDataChart.java

private Object createDataset() {
    // MOD scorreia 2011-02-10 code simplified in order to avoid unnecessary aggregation (it is now done in the
    // histogram dataset automatically)
    // final double minValue = 0; // lower value of the x-axis of the chart
    double maxValue = 0; // higher value of the x-axis of the chart
    List<Double> blockSizeValueList = new ArrayList<Double>();
    // add each block size (number of rows of the block) to the list
    Iterator<String> iterator = prviewData.keySet().iterator();
    while (iterator.hasNext()) {
        String key = iterator.next();
        Integer blockSize = prviewData.get(key).size();
        assert blockSize != null : "no row found for block " + key; //$NON-NLS-1$
        if (blockSize == null) { // should not happen
            blockSize = 0;/*from   ww w  .ja  v a 2 s .co  m*/
        }
        blockSizeValueList.add(blockSize.doubleValue());
        // evaluate the maximum number of rows
        if (maxValue < blockSize) {
            maxValue = blockSize;
        }
    }

    Double[] valueArray = new Double[blockSizeValueList.size()];
    blockSizeValueList.toArray(valueArray);

    return TOPChartUtil.getInstance().createHistogramDataset(ArrayUtils.toPrimitive(valueArray), maxValue,
            BINS);
}

From source file:org.talend.designer.dbmap.managers.UIManager.java

/**
 * Select a table view.// ww w  .  ja va2s . c  o  m
 * 
 * @param dataMapTableView
 * @param useNewCommand
 * @param selectAllEntries TODO
 */
public void selectDataMapTableView(final DataMapTableView dataMapTableView, boolean useNewCommand,
        boolean selectAllEntries) {

    TabFolderEditors tabFolderEditors = mapperUI.getTabFolderEditors();
    // tabFolderEditors.setSelection(TabFolderEditors.INDEX_TAB_METADATA_EDITOR);
    MetadataTableEditorView metadataTableEditorView = null;
    MetadataTableEditorView otherMetadataTableEditorView = null;
    final Zone currentZone = dataMapTableView.getZone();

    List<? extends IDataMapTable> tables = null;

    DataMapTableView previousSelectedTableView = null;
    DataMapTableView newSelectedTableView = null;

    if (currentZone == Zone.INPUTS) {
        metadataTableEditorView = tabFolderEditors.getInputMetaEditor();
        otherMetadataTableEditorView = tabFolderEditors.getOutputMetaEditor();
        tables = mapperManager.getInputTables();
        previousSelectedTableView = this.currentSelectedInputTableView;
        setCurrentSelectedInputTableView((InputDataMapTableView) dataMapTableView);
        newSelectedTableView = dataMapTableView;
    } else if (currentZone == Zone.OUTPUTS) {
        metadataTableEditorView = tabFolderEditors.getOutputMetaEditor();
        otherMetadataTableEditorView = tabFolderEditors.getInputMetaEditor();
        tables = mapperManager.getOutputTables();
        previousSelectedTableView = this.currentSelectedOutputTableView;
        newSelectedTableView = dataMapTableView;
        setCurrentSelectedOutputTableView((OutputDataMapTableView) dataMapTableView);
    }

    updateToolbarButtonsStates(currentZone);

    final AbstractInOutTable abstractDataMapTable = (AbstractInOutTable) mapperManager
            .retrieveIDataMapTable(dataMapTableView);
    MetadataTableEditor currentMetadataTableEditor = metadataTableEditorView.getMetadataTableEditor();
    final TableViewerCreator dataMapTVCreator = dataMapTableView.getTableViewerCreatorForColumns();
    final TableViewer dataMapTableViewer = dataMapTableView.getTableViewerCreatorForColumns().getTableViewer();
    if (currentMetadataTableEditor == null
            || currentMetadataTableEditor != null && newSelectedTableView != previousSelectedTableView) {

        if (useNewCommand) {
            DataMapTableViewSelectedCommand command = new DataMapTableViewSelectedCommand(this,
                    previousSelectedTableView, dataMapTableView);
            mapperManager.executeCommand(command);
        }

        currentMetadataTableEditor = new MetadataTableEditor(abstractDataMapTable.getMetadataTable(),
                abstractDataMapTable.getTitle());

        currentMetadataTableEditor.setModifiedBeanListenable(metadataTableEditorView.getTableViewerCreator());

        final MetadataTableEditorView metadataTableEditorViewFinal = metadataTableEditorView;
        final TableViewerCreator metadataTVCreator = metadataTableEditorViewFinal.getTableViewerCreator();
        final MetadataTableEditor metadataTableEditor = currentMetadataTableEditor;

        modifySelectionChangedListener(currentZone, metadataTableEditorViewFinal, metadataTVCreator,
                metadataTableEditor, dataMapTableView, previousSelectedTableView);

        // init actions listeners for list which contains metadata
        metadataTableEditor.addAfterOperationListListener(new IListenableListListener() {

            /**
             * DOC acer Comment method "handleEvent".
             * 
             * @param event
             */
            @Override
            public void handleEvent(ListenableListEvent event) {

                DataMapTableView view = mapperManager.retrieveIDataMapTableView(abstractDataMapTable);
                if (event.type == TYPE.ADDED) {
                    // metadataEditorTableViewer.refresh();
                    List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;

                    lastCreatedInOutColumnEntries.clear();
                    if (event.index != null) {
                        int index = event.index;
                        for (IMetadataColumn metadataColumn : metadataColumns) {
                            lastCreatedInOutColumnEntries.add(
                                    mapperManager.addNewColumnEntry(dataMapTableView, metadataColumn, index++));
                        }
                    } else if (event.indicesTarget != null) {
                        List<Integer> indicesTarget = event.indicesTarget;
                        int lstSize = indicesTarget.size();
                        for (int i = 0; i < lstSize; i++) {
                            Integer indice = indicesTarget.get(i);
                            IMetadataColumn metadataColumn = metadataColumns.get(i);
                            lastCreatedInOutColumnEntries.add(
                                    mapperManager.addNewColumnEntry(dataMapTableView, metadataColumn, indice));
                        }

                    } else {
                        throw new IllegalStateException(Messages.getString("UIManager.1")); //$NON-NLS-1$
                    }
                    refreshBackground(false, false);
                    if (event.index != null) {
                        dataMapTableView.changeSize(view.getPreferredSize(true, false, false), true, true);
                        dataMapTableViewer.refresh();
                        dataMapTVCreator.getSelectionHelper().setSelection(event.index);
                    } else if (event.indicesTarget != null) {
                        dataMapTableViewer.refresh();
                        dataMapTableView.changeSize(view.getPreferredSize(false, true, false), true, true);
                        int[] selection = ArrayUtils
                                .toPrimitive((Integer[]) event.indicesTarget.toArray(new Integer[0]));
                        dataMapTVCreator.getSelectionHelper().setSelection(selection);
                    }
                    mapperManager.getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
                }

                if (event.type == TYPE.REMOVED) {
                    // metadataEditorTableViewer.refresh();
                    List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
                    for (IMetadataColumn metadataColumn : metadataColumns) {
                        ITableEntry metadataTableEntry = mapperManager
                                .retrieveTableEntry(new TableEntryLocation(abstractDataMapTable.getName(),
                                        metadataColumn.getLabel()));
                        mapperManager.removeTableEntry(metadataTableEntry);
                    }
                    dataMapTableViewer.refresh();
                    dataMapTableView.resizeAtExpandedSize();
                    resizeTablesZoneViewAtComputedSize(dataMapTableView.getZone());
                    moveScrollBarZoneAtSelectedTable(dataMapTableView.getZone());
                    refreshBackground(true, false);
                    mapperManager.getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
                }

                if (event.type == TYPE.SWAPED) {
                    List<Integer> listIndexTarget = event.indicesTarget;
                    abstractDataMapTable.swapColumnElements(event.indicesOrigin, listIndexTarget);
                    // dataMapTableViewer.refresh();
                    refreshBackground(true, false);
                }

            }

        });
        metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                .setActiveFireSelectionChanged(false);
        metadataTableEditorView.setMetadataTableEditor(metadataTableEditor);
        metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                .setActiveFireSelectionChanged(true);
        metadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();

        dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(false);
        metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                .setSelection(dataMapTableViewer.getTable().getSelectionIndices());
        dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(true);

        // disable highlight for other DataMapTableView and highlight selected DataMapTableView
        for (IDataMapTable table : tables) {
            DataMapTableView otherDataMapTableView = mapperManager.retrieveIDataMapTableView(table);
            otherDataMapTableView
                    .setBackground(dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW));
        }
        dataMapTableView.setBackground(dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_YELLOW));
    }

    if (selectAllEntries) {
        dataMapTVCreator.getTable().selectAll();
        selectAllLinks(dataMapTableView);
        metadataTableEditorView.getTableViewerCreator().getTable().selectAll();
        metadataTableEditorView.getToolBar().updateEnabledStateOfButtons();
        if (currentZone == Zone.OUTPUTS) {
            dataMapTableView.getTableViewerCreatorForWhereFilters().getTable().selectAll();
            dataMapTableView.getTableViewerCreatorForOtherFilters().getTable().selectAll();
        }
    }

    if (otherMetadataTableEditorView != null) {
        otherMetadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();
    }

}

From source file:org.talend.designer.dbmap.ui.dnd.CompleteDropTargetListener.java

@Override
public void drop(DropTargetEvent event) {

    super.drop(event);

    retrieveInsertionIndicator().setVisible(false);

    UIManager uiManager = getUiManager();

    DraggedData draggedData = TableEntriesTransfer.getInstance().getDraggedData();
    DropContextAnalyzer analyzer = analyzeDropTarget(event, draggedData);

    // System.out.println("\n>>drop");
    // System.out.println(event);
    Point cursorPosition = new Point(event.x, event.y);
    // int startInsertAtThisIndex = getItemIndexWhereInsertFromPosition(cursorPosition);
    int startInsertAtThisIndex = TableUtils.getItemIndexWhereInsertFromPosition(draggableTable, cursorPosition);
    IDbLanguage currentLanguage = getMapperManager().getCurrentLanguage();
    DataMapTableView dataMapTableViewTarget = getMapperManager().retrieveDataMapTableView(draggableTable);
    Zone zoneTarget = dataMapTableViewTarget.getZone();

    uiManager.selectDataMapTableView(dataMapTableViewTarget, true, false);
    MetadataTableEditorView metadataEditorView = getUiManager()
            .getMetadataEditorView(dataMapTableViewTarget.getZone());
    List<TransferableEntry> transferableEntryList = draggedData.getTransferableEntryList();
    int currentIndex = startInsertAtThisIndex;
    uiManager.clearLastCreatedInOutColumnEntries();

    draggableTable.deselectAll();//from  w w  w. j a v a  2s . co m

    ITableEntry currentEntryTarget = getEntryFromPosition(cursorPosition);

    ArrayList<String> columnsBeingAdded = new ArrayList<String>();
    ArrayList<Integer> columnIndicesToSelect = new ArrayList<Integer>();
    ArrayList<ITableEntry> sourceEntriesOfEntriesBeingAdded = new ArrayList<ITableEntry>();
    ArrayList<IMetadataColumn> metadataColumnsBeingAdded = new ArrayList<IMetadataColumn>();

    boolean targetTableIsFiltersTable = analyzer.targetTableIsFiltersTable();
    boolean atLeastOneEntryInserted = false;

    boolean insertionEntryMode = analyzer.isInsertionEntryMode();
    boolean mapEachSourceToNextTargets = analyzer.isMapOneToOneMode();

    TableViewerCreator tableViewerCreatorTarget = null;
    if (targetTableIsFiltersTable) {
        if (analyzer.targetTableIsWhereFiltersTable()) {
            tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForWhereFilters();
        } else {
            tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForOtherFilters();
        }
    } else {
        tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForColumns();
    }

    // MapperDropCommand dropCommand = new MapperDropCommand();

    // MetadataEditorEvent metadataEditorEvent = new MetadataEditorEvent(MetadataEditorEvent.TYPE.ADD);
    ITableEntry lastEntryTarget = null;
    for (TransferableEntry transferableEntry : transferableEntryList) {
        ITableEntry tableEntrySource = transferableEntry.getTableEntrySource();
        IMetadataColumn metadataColumnDragged = transferableEntry.getMetadataColumn();
        Zone zoneSourceEntry = (Zone) transferableEntry.getZoneSourceEntry();

        TableEntryLocation tableEntryLocationTarget = new TableEntryLocation(
                dataMapTableViewTarget.getDataMapTable().getName(), tableEntrySource.getName());

        if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.INPUTS
                && tableEntrySource.getParentName().equals(tableEntryLocationTarget.tableName)) {

            continue;

        } else if (currentEntryTarget != null && !insertionEntryMode) {

            modifyExistingEntry(uiManager, analyzer, currentLanguage, currentEntryTarget, columnIndicesToSelect,
                    tableViewerCreatorTarget, lastEntryTarget, tableEntrySource, zoneSourceEntry);

        } else {
            String columnName = transferableEntry.getTableEntrySource().getName();
            tableEntryLocationTarget = getMapperManager().findUniqueLocation(tableEntryLocationTarget,
                    dataMapTableViewTarget.getDataMapTable());
            columnName = tableEntryLocationTarget.columnName;
            if (currentEntryTarget == null && analyzer.isMapOneToOneMode()) {
                currentIndex = tableViewerCreatorTarget.getInputList().size();
                columnIndicesToSelect.add(currentIndex);
            }
            if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.OUTPUTS) {
                insertNewInOutEntryFromInputEntry(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded,
                        // metadataEditorEvent,
                        tableEntrySource, metadataColumnDragged, columnName);
                atLeastOneEntryInserted = true;

            } else if (zoneSourceEntry == Zone.OUTPUTS && zoneTarget == Zone.OUTPUTS) {

                insertOutpuEntryCopyToOtherOutput(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded,
                        // metadataEditorEvent,
                        tableEntrySource, metadataColumnDragged, columnName);
                atLeastOneEntryInserted = true;

            } else {
                // throw new IllegalStateException("Drop case not found !");
            }
            columnsBeingAdded.add(columnName);

        }

        lastEntryTarget = currentEntryTarget;
        if (mapEachSourceToNextTargets && currentEntryTarget != null) {
            currentEntryTarget = getNextEntryTarget(currentEntryTarget, tableViewerCreatorTarget);
        }

    } // for TransferableEntry transferableEntry : transferableEntryList

    if (!atLeastOneEntryInserted) {
        tableViewerCreatorTarget.getTableViewer().refresh();
    } else {
        updateExpressionsOfInsertedEntries(currentLanguage, metadataEditorView, currentIndex,
                sourceEntriesOfEntriesBeingAdded, targetTableIsFiltersTable, tableViewerCreatorTarget
                // , metadataEditorEvent
                , metadataColumnsBeingAdded);

        for (int i = currentIndex; i < currentIndex + sourceEntriesOfEntriesBeingAdded.size(); i++) {
            columnIndicesToSelect.add(i);
        }

    }
    dataMapTableViewTarget.resizeAtExpandedSize();

    uiManager.unselectAllEntriesOfAllTables();

    uiManager.refreshBackground(true, false);
    if (metadataEditorView != null && !targetTableIsFiltersTable) {
        metadataEditorView.getTableViewerCreator().getTableViewer().refresh();
    }

    int[] selection = ArrayUtils.toPrimitive(columnIndicesToSelect.toArray(new Integer[0]));
    tableViewerCreatorTarget.getSelectionHelper().setSelection(selection);
    ISelection iselection = tableViewerCreatorTarget.getTableViewer().getSelection();
    List<ITableEntry> selectedEntries = uiManager.extractSelectedTableEntries(iselection);

    uiManager.unselectAllOutputMetaDataEntries();
    uiManager.unselectAllInputMetaDataEntries();

    uiManager.parseAllExpressionsForAllTables();
    getMapperManager().getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);

    getUiManager().refreshSqlExpression();

    uiManager.selectLinks(dataMapTableViewTarget, selectedEntries, targetTableIsFiltersTable, true);
    tableViewerCreatorTarget.getTable().setFocus();

    uiManager.setDragging(false);
}

From source file:org.talend.designer.mapper.managers.UIManager.java

/**
 * Select a table view.// w  ww . j  a v a 2s.c  o m
 * 
 * @param dataMapTableView
 * @param useNewCommand
 * @param selectAllEntries TODO
 */
public void selectDataMapTableView(final DataMapTableView dataMapTableView, boolean useNewCommand,
        boolean selectAllEntries) {
    // reject table readonly
    IDataMapTable dataMapTable = dataMapTableView.getDataMapTable();
    if (dataMapTable instanceof OutputTable && ((OutputTable) dataMapTable).isErrorRejectTable()) {
        OutputTable table = (OutputTable) dataMapTable;
        if (table.getMetadataTable() != null) {
            for (IMetadataColumn column : table.getMetadataTable().getListColumns()) {
                if (mapperManager.ERROR_REJECT_MESSAGE.equals(column.getLabel())
                        || mapperManager.ERROR_REJECT_STACK_TRACE.equals(column.getLabel())) {
                    column.setCustom(true);
                }
            }
        }
        CustomTableManager.addCustomManagementToTable(getOutputMetaEditorView(), true);
    }

    TabFolderEditors tabFolderEditors = mapperUI.getTabFolderEditors();
    // tabFolderEditors.setSelection(TabFolderEditors.INDEX_TAB_METADATA_EDITOR);
    MetadataTableEditorView metadataTableEditorView = null;
    MetadataTableEditorView otherMetadataTableEditorView = null;
    final Zone currentZone = dataMapTableView.getZone();

    List<? extends AbstractDataMapTable> tables = null;

    DataMapTableView previousSelectedTableView = null;

    if (currentZone == Zone.INPUTS) {
        metadataTableEditorView = tabFolderEditors.getInputMetaEditorView();
        otherMetadataTableEditorView = tabFolderEditors.getOutputMetaEditorView();
        tables = mapperManager.getInputTables();
        previousSelectedTableView = this.currentSelectedInputTableView;
        this.currentSelectedInputTableView = (InputDataMapTableView) dataMapTableView;
        metadataTableEditorView
                .setReadOnly(this.currentSelectedInputTableView.getInputTable().hasReadOnlyMetadataColumns()
                        || mapperManager.componentIsReadOnly());
    } else if (currentZone == Zone.OUTPUTS) {
        metadataTableEditorView = tabFolderEditors.getOutputMetaEditorView();
        otherMetadataTableEditorView = tabFolderEditors.getInputMetaEditorView();
        tables = mapperManager.getOutputTables();
        previousSelectedTableView = this.currentSelectedOutputTableView;
        this.currentSelectedOutputTableView = (OutputDataMapTableView) dataMapTableView;
        metadataTableEditorView
                .setReadOnly(this.currentSelectedOutputTableView.getOutputTable().hasReadOnlyMetadataColumns()
                        || mapperManager.componentIsReadOnly());
    } else {
        this.currentSelectedVarsTableView = (VarsDataMapTableView) dataMapTableView;
    }

    if (currentZone != Zone.VARS) {

        updateToolbarButtonsStates(currentZone);

        final AbstractInOutTable abstractDataMapTable = (AbstractInOutTable) mapperManager
                .retrieveAbstractDataMapTable(dataMapTableView);
        MetadataTableEditor currentMetadataTableEditor = metadataTableEditorView.getMetadataTableEditor();
        final TableViewerCreator dataMapTVCreator = dataMapTableView.getTableViewerCreatorForColumns();
        final TableViewer dataMapTableViewer = dataMapTableView.getTableViewerCreatorForColumns()
                .getTableViewer();
        if (currentMetadataTableEditor == null
                || currentMetadataTableEditor != null && oldSelectedView != dataMapTableView) {
            oldSelectedView = dataMapTableView;
            if (useNewCommand) {
                DataMapTableViewSelectedCommand command = new DataMapTableViewSelectedCommand(this,
                        previousSelectedTableView, dataMapTableView);
                mapperManager.executeCommand(command);
            }

            currentMetadataTableEditor = new MetadataTableEditor(abstractDataMapTable.getMetadataTable(),
                    abstractDataMapTable.getName());

            currentMetadataTableEditor
                    .setModifiedBeanListenable(metadataTableEditorView.getTableViewerCreator());

            final MetadataTableEditorView metadataTableEditorViewFinal = metadataTableEditorView;
            final TableViewerCreator metadataTVCreator = metadataTableEditorViewFinal.getTableViewerCreator();
            final MetadataTableEditor metadataTableEditor = currentMetadataTableEditor;

            modifySelectionChangedListener(currentZone, metadataTableEditorViewFinal, metadataTVCreator,
                    metadataTableEditor, dataMapTableView, previousSelectedTableView);

            // init actions listeners for list which contains metadata
            metadataTableEditor.addAfterOperationListListener(new IListenableListListener() {

                /**
                 * DOC acer Comment method "handleEvent".
                 * 
                 * @param event
                 */
                public void handleEvent(ListenableListEvent event) {
                    DataMapTableView view = mapperManager
                            .retrieveAbstractDataMapTableView(abstractDataMapTable);
                    List<DataMapTableView> relatedOutputsTableView = getRelatedOutputsTableView(
                            dataMapTableView);

                    if (event.type == TYPE.ADDED) {
                        // metadataEditorTableViewer.refresh();
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;

                        lastCreatedInOutColumnEntries.clear();
                        if (event.index != null) {
                            int index = event.index;
                            for (IMetadataColumn metadataColumn : metadataColumns) {
                                lastCreatedInOutColumnEntries.add(mapperManager
                                        .addNewColumnEntry(dataMapTableView, metadataColumn, index));
                                // handle related table view
                                for (DataMapTableView tableView : relatedOutputsTableView) {
                                    // changed for bug TDI-26551 in July 2,2013 by fwang, should use original
                                    // expression for related table.
                                    IMetadataColumn relatedMetadata = metadataColumn;
                                    if (!oldMappingMap.isEmpty()) {
                                        IDataMapTable retrieveAbstractDataMapTable = mapperManager
                                                .retrieveAbstractDataMapTable(tableView);
                                        relatedMetadata = metadataColumn.clone();
                                        String label = relatedMetadata.getLabel();
                                        String expression = oldMappingMap
                                                .get(retrieveAbstractDataMapTable.getName() + "_" + label);
                                        relatedMetadata.setExpression(expression == null ? "" : expression);
                                    }

                                    mapperManager.addNewColumnEntry(tableView, relatedMetadata, index);
                                }
                                index = index + 1;

                            }
                        } else if (event.indicesTarget != null) {
                            List<Integer> indicesTarget = event.indicesTarget;
                            int lstSize = indicesTarget.size();
                            for (int i = 0; i < lstSize; i++) {
                                Integer indice = indicesTarget.get(i);
                                IMetadataColumn metadataColumn = metadataColumns.get(i);
                                lastCreatedInOutColumnEntries.add(mapperManager
                                        .addNewColumnEntry(dataMapTableView, metadataColumn, indice));

                                // handle related table view
                                for (DataMapTableView tableView : relatedOutputsTableView) {
                                    mapperManager.addNewColumnEntry(tableView, metadataColumn, indice);
                                }
                            }

                        } else {
                            throw new IllegalStateException(Messages.getString("UIManager.1")); //$NON-NLS-1$
                        }
                        refreshBackground(false, false);
                        if (event.index != null) {
                            dataMapTableViewer.refresh();
                            dataMapTVCreator.getSelectionHelper().setSelection(event.index);
                            if (dataMapTableView.canBeResizedAtPreferedSize()) {
                                dataMapTableView.changeSize(view.getPreferredSize(true, false, false), true,
                                        true);
                            }
                            // resize ralated table
                            for (DataMapTableView tableView : relatedOutputsTableView) {
                                if (tableView.canBeResizedAtPreferedSize()) {
                                    tableView.changeSize(tableView.getPreferredSize(true, false, false), true,
                                            true);
                                }
                            }

                        } else if (event.indicesTarget != null) {
                            dataMapTableViewer.refresh();
                            dataMapTableView.changeSize(view.getPreferredSize(false, true, false), true, true);
                            int[] selection = ArrayUtils
                                    .toPrimitive((Integer[]) event.indicesTarget.toArray(new Integer[0]));
                            dataMapTVCreator.getSelectionHelper().setSelection(selection);

                            for (DataMapTableView tableView : relatedOutputsTableView) {
                                tableView.changeSize(tableView.getPreferredSize(false, true, false), true,
                                        true);
                            }
                        }
                    }

                    if (event.type == TYPE.REMOVED) {
                        // metadataEditorTableViewer.refresh();
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
                        for (IMetadataColumn metadataColumn : metadataColumns) {
                            ITableEntry metadataTableEntry = mapperManager
                                    .retrieveTableEntry(new TableEntryLocation(abstractDataMapTable.getName(),
                                            metadataColumn.getLabel()));
                            mapperManager.removeTableEntry(metadataTableEntry);

                            for (DataMapTableView tableView : relatedOutputsTableView) {
                                IDataMapTable retrieveAbstractDataMapTable = mapperManager
                                        .retrieveAbstractDataMapTable(tableView);
                                metadataTableEntry = mapperManager.retrieveTableEntry(new TableEntryLocation(
                                        retrieveAbstractDataMapTable.getName(), metadataColumn.getLabel()));
                                mapperManager.removeTableEntry(metadataTableEntry);
                                if (tableView.canBeResizedAtPreferedSize()) {
                                    tableView.resizeAtExpandedSize();
                                }
                            }
                        }

                        dataMapTableViewer.refresh();
                        if (dataMapTableView.canBeResizedAtPreferedSize()) {
                            dataMapTableView.resizeAtExpandedSize();
                        }
                        resizeTablesZoneViewAtComputedSize(dataMapTableView.getZone());
                        moveScrollBarZoneAtSelectedTable(dataMapTableView.getZone());
                        refreshBackground(true, false);
                    }

                    if (event.type == TYPE.SWAPED) {
                        List<Integer> listIndexTarget = event.indicesTarget;
                        abstractDataMapTable.swapColumnElements(event.indicesOrigin, listIndexTarget);
                        // handle related table view
                        for (DataMapTableView tableView : relatedOutputsTableView) {
                            AbstractDataMapTable relatedTable = (AbstractDataMapTable) tableView
                                    .getDataMapTable();
                            relatedTable.swapColumnElements(event.indicesOrigin, listIndexTarget);
                        }

                        // dataMapTableViewer.refresh();
                        refreshBackground(true, false);
                    }

                }

            });
            metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                    .setActiveFireSelectionChanged(false);
            metadataTableEditorView.setMetadataTableEditor(metadataTableEditor);
            metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                    .setActiveFireSelectionChanged(true);
            metadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();

            dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(false);
            metadataTableEditorView.getTableViewerCreator().getSelectionHelper()
                    .setSelection(dataMapTableViewer.getTable().getSelectionIndices());
            dataMapTVCreator.getSelectionHelper().setActiveFireSelectionChanged(true);

            // disable highlight for other DataMapTableView and highlight selected DataMapTableView
            for (IDataMapTable table : tables) {
                DataMapTableView otherDataMapTableView = mapperManager.retrieveAbstractDataMapTableView(table);
                otherDataMapTableView.setBackground(
                        dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_WIDGET_LIGHT_SHADOW));
            }
            dataMapTableView.setBackground(dataMapTableView.getDisplay().getSystemColor(SWT.COLOR_YELLOW));
        }

        if (selectAllEntries) {
            dataMapTVCreator.getTable().selectAll();
            selectAllLinks(dataMapTableView);
            if (currentZone != Zone.VARS) {
                metadataTableEditorView.getTableViewerCreator().getTable().selectAll();
                metadataTableEditorView.getToolBar().updateEnabledStateOfButtons();
            }
            if (currentZone == Zone.OUTPUTS) {
                dataMapTableView.getTableViewerCreatorForFilters().getTable().selectAll();
            }
        }

        boolean isMainSchemaRepository = false;
        if (abstractDataMapTable instanceof OutputTable) {
            OutputTable outputTable = (OutputTable) abstractDataMapTable;
            if (outputTable.getIsJoinTableOf() != null || !"".equals(outputTable.getIsJoinTableOf())) {
                final OutputTable outputTableByName = mapperManager
                        .getOutputTableByName(outputTable.getIsJoinTableOf());
                if (outputTableByName != null && outputTableByName.getId() != null) {
                    isMainSchemaRepository = true;
                }
            }
        }

        dataMapTableView.enableDiaplayViewer(abstractDataMapTable.isRepository() || isMainSchemaRepository);
    }

    if (selectAllEntries && currentZone == Zone.VARS) {
        selectAllLinks(dataMapTableView);
        mapperManager.getUiManager().getVarsTablesView().get(0).getTableViewerCreatorForColumns().getTable()
                .selectAll();
    }

    if (otherMetadataTableEditorView != null) {
        otherMetadataTableEditorView.getExtendedToolbar().updateEnabledStateOfButtons();
    }

}

From source file:org.talend.designer.mapper.ui.dnd.CompleteDropTargetTableListener.java

@Override
public void drop(DropTargetEvent event) {

    super.drop(event);

    retrieveInsertionIndicator().setVisible(false);

    UIManager uiManager = getUiManager();

    DraggedData draggedData = TableEntriesTransfer.getInstance().getDraggedData();
    DropContextAnalyzer analyzer = analyzeDropTarget(event, draggedData);

    // System.out.println("\n>>drop");
    // System.out.println(event);
    Point cursorPosition = new Point(event.x, event.y);
    // int startInsertAtThisIndex = getItemIndexWhereInsertFromPosition(cursorPosition);
    int startInsertAtThisIndex = TableUtils.getItemIndexWhereInsertFromPosition(draggableTargetControl,
            cursorPosition);//  ww w  .  j  av  a  2  s  .  co m
    ILanguage currentLanguage = LanguageProvider.getCurrentLanguage();
    DataMapTableView dataMapTableViewTarget = getMapperManager()
            .retrieveDataMapTableView(draggableTargetControl);
    Zone zoneTarget = dataMapTableViewTarget.getZone();

    uiManager.selectDataMapTableView(dataMapTableViewTarget, true, false);
    MetadataTableEditorView metadataEditorView = getUiManager()
            .getMetadataEditorView(dataMapTableViewTarget.getZone());
    List<TransferableEntry> transferableEntryList = draggedData.getTransferableEntryList();
    int currentIndex = startInsertAtThisIndex;
    uiManager.clearLastCreatedInOutColumnEntries();

    draggableTargetControl.deselectAll();

    ITableEntry currentEntryTarget = getEntryFromPosition(cursorPosition);

    ArrayList<String> columnsBeingAdded = new ArrayList<String>();
    ArrayList<Integer> columnIndicesToSelect = new ArrayList<Integer>();
    ArrayList<ITableEntry> sourceEntriesOfEntriesBeingAdded = new ArrayList<ITableEntry>();
    ArrayList<IMetadataColumn> metadataColumnsBeingAdded = new ArrayList<IMetadataColumn>();

    boolean targetTableIsFiltersTable = analyzer.targetTableIsFiltersTable();
    boolean targetTableIsGlobalMapTable = analyzer.targetTableIsGlobalMapTable();
    boolean atLeastOneEntryInserted = false;

    boolean insertionEntryMode = analyzer.isInsertionEntryMode();
    boolean mapEachSourceToNextTargets = analyzer.isMapOneToOneMode();

    TableViewerCreator tableViewerCreatorTarget = null;

    if (!analyzer.targetIsExpressionFilterText()) {
        if (targetTableIsFiltersTable) {
            tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForFilters();
        } else if (targetTableIsGlobalMapTable) {
            tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForGlobalMap();
        } else {
            tableViewerCreatorTarget = dataMapTableViewTarget.getTableViewerCreatorForColumns();
        }
    }

    uiManager.applyActivatedCellEditors(tableViewerCreatorTarget);

    // MapperDropCommand dropCommand = new MapperDropCommand();

    // MetadataEditorEvent metadataEditorEvent = new MetadataEditorEvent(MetadataEditorEvent.TYPE.ADD);
    ITableEntry lastEntryTarget = null;
    for (TransferableEntry transferableEntry : transferableEntryList) {
        ITableEntry tableEntrySource = transferableEntry.getTableEntrySource();
        IMetadataColumn metadataColumnDragged = transferableEntry.getMetadataColumn();
        Zone zoneSourceEntry = (Zone) transferableEntry.getZoneSourceEntry();

        TableEntryLocation tableEntryLocationTarget = new TableEntryLocation(
                dataMapTableViewTarget.getDataMapTable().getName(), tableEntrySource.getName());

        if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.INPUTS
                && tableEntrySource.getParentName().equals(tableEntryLocationTarget.tableName)) {

            continue;

        } else if (currentEntryTarget != null && !insertionEntryMode) {

            // set the default operator.
            if (currentEntryTarget instanceof InputColumnTableEntry) {
                ((InputColumnTableEntry) currentEntryTarget).setOperator(Operator.EQUALS.getLiteral());
            }

            boolean overwrite = (lastEntryTarget != currentEntryTarget && analyzer.isOverwriteExpression());
            modifyExistingExpression(currentLanguage, currentEntryTarget, tableEntrySource, overwrite,
                    zoneSourceEntry);
            uiManager.parseExpression(currentEntryTarget.getExpression(), currentEntryTarget, false, true,
                    true);

            int indexOfEntry = tableViewerCreatorTarget.getInputList().indexOf(currentEntryTarget);
            columnIndicesToSelect.add(indexOfEntry);

        } else {
            String columnName = transferableEntry.getTableEntrySource().getName();
            tableEntryLocationTarget = getMapperManager().findUniqueLocation(tableEntryLocationTarget,
                    dataMapTableViewTarget.getDataMapTable());
            columnName = tableEntryLocationTarget.columnName;
            if (currentEntryTarget == null && analyzer.isMapOneToOneMode()) {
                currentIndex = tableViewerCreatorTarget.getInputList().size();
                columnIndicesToSelect.add(currentIndex);
            }
            if (zoneSourceEntry == Zone.INPUTS && zoneTarget == Zone.VARS
                    || zoneSourceEntry == Zone.VARS && zoneTarget == Zone.VARS) {
                columnIndicesToSelect.add(currentIndex);
                currentIndex = insertNewVarEntry(currentLanguage, dataMapTableViewTarget, currentIndex,
                        tableEntrySource, columnName);
                atLeastOneEntryInserted = true;

            } else if (zoneSourceEntry == Zone.VARS && zoneTarget == Zone.OUTPUTS) {
                insertNewOutputEntryFromVarEntry(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded,
                        // metadataEditorEvent,
                        tableEntrySource, columnName);
                atLeastOneEntryInserted = true;

            } else if (zoneSourceEntry == Zone.INPUTS && targetTableIsGlobalMapTable) {
                insertNewGlobalMapEntryFromInputEntry(currentLanguage, dataMapTableViewTarget, currentIndex,
                        tableEntrySource);
                atLeastOneEntryInserted = true;

            } else if (zoneSourceEntry == Zone.INPUTS && zoneTarget != Zone.VARS) {
                insertNewInOutEntryFromInputEntry(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded,
                        // metadataEditorEvent,
                        tableEntrySource, metadataColumnDragged, columnName);
                atLeastOneEntryInserted = true;

            } else if (zoneSourceEntry == Zone.OUTPUTS && zoneTarget == Zone.VARS) {
                // nothing
            } else if (zoneSourceEntry == Zone.OUTPUTS && zoneTarget == Zone.OUTPUTS) {

                insertOutpuEntryCopyToOtherOutput(sourceEntriesOfEntriesBeingAdded, metadataColumnsBeingAdded,
                        // metadataEditorEvent,
                        tableEntrySource, metadataColumnDragged, columnName);
                atLeastOneEntryInserted = true;

            } else {
                // throw new IllegalStateException("Drop case not found !");
            }
            columnsBeingAdded.add(columnName);

        }

        lastEntryTarget = currentEntryTarget;
        if (mapEachSourceToNextTargets && currentEntryTarget != null) {
            currentEntryTarget = getNextEntryTarget(currentEntryTarget, tableViewerCreatorTarget);
        }

    } // for TransferableEntry transferableEntry : transferableEntryList

    if (!atLeastOneEntryInserted) {
        tableViewerCreatorTarget.getTableViewer().refresh();
    } else {
        updateExpressionsOfInsertedEntries(currentLanguage, metadataEditorView, currentIndex,
                sourceEntriesOfEntriesBeingAdded, targetTableIsFiltersTable, tableViewerCreatorTarget
                // , metadataEditorEvent
                , metadataColumnsBeingAdded);

        for (int i = currentIndex; i < currentIndex + sourceEntriesOfEntriesBeingAdded.size(); i++) {
            columnIndicesToSelect.add(i);
        }
    }

    if (zoneTarget == Zone.VARS) {
        dataMapTableViewTarget.resizeAtExpandedSize();
    }

    if (targetTableIsGlobalMapTable) {
        dataMapTableViewTarget.updateGridDataHeightForTableGlobalMap();
        dataMapTableViewTarget.resizeAtExpandedSize();
    }

    uiManager.unselectAllEntriesOfAllTables();

    uiManager.refreshBackground(true, false);
    if (metadataEditorView != null && !targetTableIsFiltersTable) {
        metadataEditorView.getTableViewerCreator().getTableViewer().refresh();
    }

    int[] selection = ArrayUtils.toPrimitive(columnIndicesToSelect.toArray(new Integer[0]));
    tableViewerCreatorTarget.getSelectionHelper().setSelection(selection);
    ISelection iselection = tableViewerCreatorTarget.getTableViewer().getSelection();
    List<ITableEntry> selectedEntries = uiManager.extractSelectedTableEntries(iselection);
    tableViewerCreatorTarget.getTable().deselectAll();

    uiManager.unselectAllOutputMetaDataEntries();
    uiManager.unselectAllInputMetaDataEntries();

    uiManager.parseAllExpressionsForAllTables();
    getMapperManager().getProblemsManager().checkProblemsForAllEntriesOfAllTables(true);
    getMapperManager().getProblemsManager().checkLookupExpressionProblem();

    uiManager.selectLinks(dataMapTableViewTarget, selectedEntries, true, false);
    dataMapTableViewTarget.checkChangementsAfterEntryModifiedOrAdded(false);
    tableViewerCreatorTarget.getTable().setFocus();

    uiManager.setDragging(false);
}

From source file:org.tinygroup.jdbctemplatedslsession.SimpleDslSession.java

public int[] batchInsert(Insert insert, List<Map<String, Object>> params, int batchSize,
        boolean autoGeneratedKeys) {
    final List<Integer> records = new ArrayList<Integer>();
    final InsertBatchOperate insertBatchOperate = newInsertBatch(insert, autoGeneratedKeys);
    if (params.size() > batchSize) {
        batchProcess(batchSize, params, new BatchOperateCallback() {
            public int[] callback(List<Map<String, Object>> params) {
                int[] affectNums = insertBatchOperate.batchProcess(params);
                Collections.addAll(records, ArrayUtils.toObject(affectNums));
                return affectNums;
            }/*  ww w  .  j  a  v  a 2  s.c  o m*/

            public int[] callbackList(List<List<Object>> params) {
                return null;
            }

            public int[] callback(Map<String, Object>[] params) {
                return null;
            }
        });
        return ArrayUtils.toPrimitive(records.toArray(new Integer[0]));
    }
    return insertBatchOperate.batchProcess(params);
}

From source file:org.tinygroup.jdbctemplatedslsession.SimpleDslSession.java

private int[] executeBatch(final String sql, List<List<Object>> params, int batchSize) {

    final List<Integer> records = new ArrayList<Integer>();
    if (params.size() > batchSize) {
        executeBatchProcess(batchSize, params, new BatchOperateCallback() {

            public int[] callbackList(List<List<Object>> params) {
                int[] affectedNums = jdbcTemplate.batchUpdate(sql,
                        new BatchPreparedStatementSetterImpl(params, null));
                Collections.addAll(records, ArrayUtils.toObject(affectedNums));
                return affectedNums;
            }//from  w  w  w  . ja  va2s  .  c o  m

            public int[] callback(List<Map<String, Object>> params) {
                return null;
            }

            public int[] callback(Map<String, Object>[] params) {
                return null;
            }
        });
        return ArrayUtils.toPrimitive(records.toArray(new Integer[0]));
    }
    return jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetterImpl(params, null));

}