Examples with EImage org.pentaho.di.core.gui.PrimitiveGCInterface.EImage used on opensource projects

Example 1 with EImage

use of org.pentaho.di.core.gui.PrimitiveGCInterface.EImage in project pentaho-kettle by pentaho.

the class JobPainter method drawJobEntryCopy.

protected void drawJobEntryCopy(JobEntryCopy jobEntryCopy) {
    if (!jobEntryCopy.isDrawn()) {
        return;
    }
    int alpha = gc.getAlpha();
    Point pt = jobEntryCopy.getLocation();
    if (pt == null) {
        pt = new Point(50, 50);
    }
    Point screen = real2screen(pt.x, pt.y);
    int x = screen.x;
    int y = screen.y;
    String name = jobEntryCopy.getName();
    if (jobEntryCopy.isSelected()) {
        gc.setLineWidth(3);
    } else {
        gc.setLineWidth(1);
    }
    gc.setBackground(EColor.BACKGROUND);
    gc.fillRoundRectangle(x - 1, y - 1, iconsize + 1, iconsize + 1, 7, 7);
    gc.drawJobEntryIcon(x, y, jobEntryCopy, magnification);
    if (!shadow) {
        areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_ICON, x, y, iconsize, iconsize, offset, subject, jobEntryCopy));
    }
    gc.setForeground(jobEntryCopy.isMissing() ? EColor.RED : EColor.CRYSTAL);
    gc.drawRoundRectangle(x - 1, y - 1, iconsize + 1, iconsize + 1, 7, 7);
    gc.setForeground(EColor.CRYSTAL);
    Point textsize = new Point(gc.textExtent("" + name).x, gc.textExtent("" + name).y);
    gc.setBackground(EColor.BACKGROUND);
    gc.setLineWidth(1);
    int xpos = x + (iconsize / 2) - (textsize.x / 2);
    int ypos = y + iconsize + 5;
    gc.setForeground(EColor.BLACK);
    gc.drawText(name, xpos, ypos, true);
    if (activeJobEntries != null && activeJobEntries.contains(jobEntryCopy)) {
        gc.setForeground(EColor.BLUE);
        int iconX = (x + iconsize) - (MINI_ICON_SIZE / 2);
        int iconY = y - (MINI_ICON_SIZE / 2);
        gc.drawImage(EImage.BUSY, iconX, iconY, magnification);
        areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_BUSY, iconX, iconY, MINI_ICON_SIZE, MINI_ICON_SIZE, offset, subject, jobEntryCopy));
    } else {
        gc.setForeground(EColor.BLACK);
    }
    JobEntryResult jobEntryResult = findJobEntryResult(jobEntryCopy);
    if (jobEntryResult != null) {
        Result result = jobEntryResult.getResult();
        int iconX = (x + iconsize) - (MINI_ICON_SIZE / 2);
        int iconY = y - (MINI_ICON_SIZE / 2);
        // 
        if (jobEntryResult.isCheckpoint()) {
            gc.drawImage(EImage.CHECKPOINT, iconX, iconY, magnification);
            areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_RESULT_CHECKPOINT, iconX, iconY, MINI_ICON_SIZE, MINI_ICON_SIZE, offset, jobEntryCopy, jobEntryResult));
        } else {
            if (result.getResult()) {
                gc.drawImage(EImage.TRUE, iconX, iconY, magnification);
                areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_RESULT_SUCCESS, iconX, iconY, MINI_ICON_SIZE, MINI_ICON_SIZE, offset, jobEntryCopy, jobEntryResult));
            } else {
                gc.drawImage(EImage.FALSE, iconX, iconY, magnification);
                areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_RESULT_FAILURE, iconX, iconY, MINI_ICON_SIZE, MINI_ICON_SIZE, offset, jobEntryCopy, jobEntryResult));
            }
        }
    }
    // 
    if (mouseOverEntries.contains(jobEntryCopy)) {
        gc.setTransform(translationX, translationY, 0, BasePainter.FACTOR_1_TO_1);
        EImage[] miniIcons = new EImage[] { EImage.INPUT, EImage.EDIT, EImage.CONTEXT_MENU, EImage.OUTPUT };
        // First drawn the mini-icons balloon below the job entry
        // 
        int totalHeight = 0;
        int totalIconsWidth = 0;
        int totalWidth = 2 * MINI_ICON_MARGIN;
        for (EImage miniIcon : miniIcons) {
            Point bounds = gc.getImageBounds(miniIcon);
            totalWidth += bounds.x + MINI_ICON_MARGIN;
            totalIconsWidth += bounds.x + MINI_ICON_MARGIN;
            if (bounds.y > totalHeight) {
                totalHeight = bounds.y;
            }
        }
        totalHeight += 2 * MINI_ICON_MARGIN;
        gc.setFont(EFont.SMALL);
        String trimmedName = jobEntryCopy.getName().length() < 30 ? jobEntryCopy.getName() : jobEntryCopy.getName().substring(0, 30);
        Point nameExtent = gc.textExtent(trimmedName);
        nameExtent.y += 2 * MINI_ICON_MARGIN;
        nameExtent.x += 3 * MINI_ICON_MARGIN;
        totalHeight += nameExtent.y;
        if (nameExtent.x > totalWidth) {
            totalWidth = nameExtent.x;
        }
        int areaX = translateToCurrentScale(x) + translateToCurrentScale(iconsize) / 2 - totalWidth / 2 + MINI_ICON_SKEW;
        int areaY = translateToCurrentScale(y) + translateToCurrentScale(iconsize) + MINI_ICON_DISTANCE + BasePainter.CONTENT_MENU_INDENT;
        gc.setForeground(EColor.CRYSTAL);
        gc.setBackground(EColor.CRYSTAL);
        gc.setLineWidth(1);
        gc.fillRoundRectangle(areaX, areaY, totalWidth, totalHeight, BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.setBackground(EColor.WHITE);
        gc.fillRoundRectangle(areaX, areaY + nameExtent.y, totalWidth, (totalHeight - nameExtent.y), BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.fillRectangle(areaX, areaY + nameExtent.y, totalWidth, (totalHeight - nameExtent.y) / 2);
        gc.drawRoundRectangle(areaX, areaY, totalWidth, totalHeight, BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.setForeground(EColor.WHITE);
        gc.drawText(trimmedName, areaX + (totalWidth - nameExtent.x) / 2 + MINI_ICON_MARGIN, areaY + MINI_ICON_MARGIN, true);
        gc.setForeground(EColor.CRYSTAL);
        gc.setBackground(EColor.CRYSTAL);
        gc.setFont(EFont.GRAPH);
        areaOwners.add(new AreaOwner(AreaType.MINI_ICONS_BALLOON, translateTo1To1(areaX), translateTo1To1(areaY), translateTo1To1(totalWidth), translateTo1To1(totalHeight), offset, jobMeta, jobEntryCopy));
        gc.fillPolygon(new int[] { areaX + totalWidth / 2 - MINI_ICON_TRIANGLE_BASE / 2 + 1, areaY + 2, areaX + totalWidth / 2 + MINI_ICON_TRIANGLE_BASE / 2, areaY + 2, areaX + totalWidth / 2 - MINI_ICON_SKEW, areaY - MINI_ICON_DISTANCE - 3 });
        gc.setBackground(EColor.WHITE);
        // Put on the icons...
        // 
        int xIcon = areaX + (totalWidth - totalIconsWidth) / 2 + MINI_ICON_MARGIN;
        int yIcon = areaY + 5 + nameExtent.y;
        for (int i = 0; i < miniIcons.length; i++) {
            EImage miniIcon = miniIcons[i];
            Point bounds = gc.getImageBounds(miniIcon);
            boolean enabled = false;
            switch(i) {
                case // INPUT
                0:
                    enabled = !jobEntryCopy.isStart();
                    areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_MINI_ICON_INPUT, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, jobMeta, jobEntryCopy));
                    break;
                case // EDIT
                1:
                    enabled = true;
                    areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_MINI_ICON_EDIT, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, jobMeta, jobEntryCopy));
                    break;
                case // Job entry context menu
                2:
                    enabled = true;
                    areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_MINI_ICON_CONTEXT, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, jobMeta, jobEntryCopy));
                    break;
                case // OUTPUT
                3:
                    enabled = true;
                    areaOwners.add(new AreaOwner(AreaType.JOB_ENTRY_MINI_ICON_OUTPUT, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, jobMeta, jobEntryCopy));
                    break;
                default:
                    break;
            }
            if (enabled) {
                gc.setAlpha(255);
            } else {
                gc.setAlpha(100);
            }
            gc.drawImage(miniIcon, xIcon, yIcon, BasePainter.FACTOR_1_TO_1);
            xIcon += bounds.x + 5;
        }
        gc.setTransform(translationX, translationY, 0, magnification);
    }
    // Restore the previous alpha value
    // 
    gc.setAlpha(alpha);
}

Example 2 with EImage

use of org.pentaho.di.core.gui.PrimitiveGCInterface.EImage in project pentaho-kettle by pentaho.

the class JobPainter method drawJobElements.

private void drawJobElements() {
    if (!shadow && gridSize > 1) {
        drawGrid();
    }
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.JobPainterStart.id, this);
    } catch (KettleException e) {
        LogChannel.GENERAL.logError("Error in JobPainterStart extension point", e);
    }
    // First draw the notes...
    gc.setFont(EFont.NOTE);
    for (int i = 0; i < jobMeta.nrNotes(); i++) {
        NotePadMeta ni = jobMeta.getNote(i);
        drawNote(ni);
    }
    gc.setFont(EFont.GRAPH);
    // ... and then the rest on top of it...
    for (int i = 0; i < jobMeta.nrJobHops(); i++) {
        JobHopMeta hi = jobMeta.getJobHop(i);
        drawJobHop(hi, false);
    }
    EImage arrow;
    if (candidate != null) {
        drawJobHop(candidate, true);
    } else {
        if (startHopEntry != null && endHopLocation != null) {
            Point fr = startHopEntry.getLocation();
            Point to = endHopLocation;
            if (endHopEntry == null) {
                gc.setForeground(EColor.GRAY);
                arrow = EImage.ARROW_DISABLED;
            } else {
                gc.setForeground(EColor.BLUE);
                arrow = EImage.ARROW_DEFAULT;
            }
            Point start = real2screen(fr.x + iconsize / 2, fr.y + iconsize / 2);
            Point end = real2screen(to.x, to.y);
            drawArrow(arrow, start.x, start.y, end.x, end.y, theta, calcArrowLength(), 1.2, null, startHopEntry, endHopEntry == null ? endHopLocation : endHopEntry);
        } else if (endHopEntry != null && endHopLocation != null) {
            Point fr = endHopLocation;
            Point to = endHopEntry.getLocation();
            if (startHopEntry == null) {
                gc.setForeground(EColor.GRAY);
                arrow = EImage.ARROW_DISABLED;
            } else {
                gc.setForeground(EColor.BLUE);
                arrow = EImage.ARROW_DEFAULT;
            }
            Point start = real2screen(fr.x, fr.y);
            Point end = real2screen(to.x + iconsize / 2, to.y + iconsize / 2);
            drawArrow(arrow, start.x, start.y, end.x, end.y + iconsize / 2, theta, calcArrowLength(), 1.2, null, startHopEntry == null ? endHopLocation : startHopEntry, endHopEntry);
        }
    }
    for (int j = 0; j < jobMeta.nrJobEntries(); j++) {
        JobEntryCopy je = jobMeta.getJobEntry(j);
        drawJobEntryCopy(je);
    }
    // 
    if (noInputEntry != null) {
        gc.setLineWidth(2);
        gc.setForeground(EColor.RED);
        Point n = noInputEntry.getLocation();
        gc.drawLine(offset.x + n.x - 5, offset.y + n.y - 5, offset.x + n.x + iconsize + 5, offset.y + n.y + iconsize + 5);
        gc.drawLine(offset.x + n.x - 5, offset.y + n.y + iconsize + 5, offset.x + n.x + iconsize + 5, offset.y + n.y - 5);
    }
    if (drop_candidate != null) {
        gc.setLineStyle(ELineStyle.SOLID);
        gc.setForeground(EColor.BLACK);
        Point screen = real2screen(drop_candidate.x, drop_candidate.y);
        gc.drawRectangle(screen.x, screen.y, iconsize, iconsize);
    }
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.JobPainterEnd.id, this);
    } catch (KettleException e) {
        LogChannel.GENERAL.logError("Error in JobPainterEnd extension point", e);
    }
    if (!shadow) {
        drawRect(selrect);
    }
}

Example 3 with EImage

use of org.pentaho.di.core.gui.PrimitiveGCInterface.EImage in project pentaho-kettle by pentaho.

the class TransPainter method drawLine.

private void drawLine(StepMeta fs, StepMeta ts, TransHopMeta hi, boolean is_candidate) {
    int[] line = getLine(fs, ts);
    EColor col;
    ELineStyle linestyle = ELineStyle.SOLID;
    int activeLinewidth = linewidth;
    EImage arrow;
    if (is_candidate) {
        col = EColor.BLUE;
        arrow = EImage.ARROW_CANDIDATE;
    } else {
        if (hi.isEnabled()) {
            if (fs.isSendingErrorRowsToStep(ts)) {
                col = EColor.RED;
                linestyle = ELineStyle.DASH;
                activeLinewidth = linewidth + 1;
                arrow = EImage.ARROW_ERROR;
            } else {
                col = EColor.HOP_DEFAULT;
                arrow = EImage.ARROW_DEFAULT;
            }
        } else {
            col = EColor.GRAY;
            arrow = EImage.ARROW_DISABLED;
        }
    }
    if (hi.split) {
        activeLinewidth = linewidth + 2;
    }
    // Check to see if the source step is an info step for the target step.
    // 
    StepIOMetaInterface ioMeta = ts.getStepMetaInterface().getStepIOMeta();
    List<StreamInterface> infoStreams = ioMeta.getInfoStreams();
    if (!infoStreams.isEmpty()) {
        // 
        for (StreamInterface stream : infoStreams) {
            if (fs.getName().equalsIgnoreCase(stream.getStepname())) {
                // 
                if (fs.getCopies() > 1) {
                    // This is not a desirable situation, it will always end in error.
                    // As such, it's better not to give feedback on it.
                    // We do this by drawing an error icon over the hop...
                    // 
                    col = EColor.RED;
                    arrow = EImage.ARROW_ERROR;
                }
            }
        }
    }
    gc.setForeground(col);
    gc.setLineStyle(linestyle);
    gc.setLineWidth(activeLinewidth);
    drawArrow(arrow, line, hi, fs, ts);
    if (hi.split) {
        gc.setLineWidth(linewidth);
    }
    gc.setForeground(EColor.BLACK);
    gc.setBackground(EColor.BACKGROUND);
    gc.setLineStyle(ELineStyle.SOLID);
}

Example 4 with EImage

use of org.pentaho.di.core.gui.PrimitiveGCInterface.EImage in project pentaho-kettle by pentaho.

the class TransPainter method drawTrans.

private void drawTrans(Point thumb) {
    if (!shadow && gridSize > 1) {
        drawGrid();
    }
    if (hori != null && vert != null) {
        hori.setThumb(thumb.x);
        vert.setThumb(thumb.y);
    }
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.TransPainterStart.id, this);
    } catch (KettleException e) {
        LogChannel.GENERAL.logError("Error in TransPainterStart extension point", e);
    }
    gc.setFont(EFont.NOTE);
    // First the notes
    for (int i = 0; i < transMeta.nrNotes(); i++) {
        NotePadMeta ni = transMeta.getNote(i);
        drawNote(ni);
    }
    gc.setFont(EFont.GRAPH);
    gc.setBackground(EColor.BACKGROUND);
    for (int i = 0; i < transMeta.nrTransHops(); i++) {
        TransHopMeta hi = transMeta.getTransHop(i);
        drawHop(hi);
    }
    EImage arrow;
    if (candidate != null) {
        drawHop(candidate, true);
    } else {
        if (startHopStep != null && endHopLocation != null) {
            Point fr = startHopStep.getLocation();
            Point to = endHopLocation;
            if (endHopStep == null) {
                gc.setForeground(EColor.GRAY);
                arrow = EImage.ARROW_DISABLED;
            } else {
                gc.setForeground(EColor.BLUE);
                arrow = EImage.ARROW_DEFAULT;
            }
            Point start = real2screen(fr.x + iconsize / 2, fr.y + iconsize / 2);
            Point end = real2screen(to.x, to.y);
            drawArrow(arrow, start.x, start.y, end.x, end.y, theta, calcArrowLength(), 1.2, null, startHopStep, endHopStep == null ? endHopLocation : endHopStep);
        } else if (endHopStep != null && endHopLocation != null) {
            Point fr = endHopLocation;
            Point to = endHopStep.getLocation();
            if (startHopStep == null) {
                gc.setForeground(EColor.GRAY);
                arrow = EImage.ARROW_DISABLED;
            } else {
                gc.setForeground(EColor.BLUE);
                arrow = EImage.ARROW_DEFAULT;
            }
            Point start = real2screen(fr.x, fr.y);
            Point end = real2screen(to.x + iconsize / 2, to.y + iconsize / 2);
            drawArrow(arrow, start.x, start.y, end.x, end.y, theta, calcArrowLength(), 1.2, null, startHopStep == null ? endHopLocation : startHopStep, endHopStep);
        }
    }
    // Draw regular step appearance
    for (int i = 0; i < transMeta.nrSteps(); i++) {
        StepMeta stepMeta = transMeta.getStep(i);
        if (stepMeta.isDrawn()) {
            drawStep(stepMeta);
        }
    }
    if (slowStepIndicatorEnabled) {
        // Highlight possible bottlenecks
        for (int i = 0; i < transMeta.nrSteps(); i++) {
            StepMeta stepMeta = transMeta.getStep(i);
            if (stepMeta.isDrawn()) {
                checkDrawSlowStepIndicator(stepMeta);
            }
        }
    }
    // Draw step status indicators (running vs. done)
    for (int i = 0; i < transMeta.nrSteps(); i++) {
        StepMeta stepMeta = transMeta.getStep(i);
        if (stepMeta.isDrawn()) {
            drawStepStatusIndicator(stepMeta);
        }
    }
    // Draw performance table for selected step(s)
    for (int i = 0; i < transMeta.nrSteps(); i++) {
        StepMeta stepMeta = transMeta.getStep(i);
        if (stepMeta.isDrawn()) {
            drawStepPerformanceTable(stepMeta);
        }
    }
    int selectedStepsCount = 0;
    for (int i = transMeta.nrSteps() - 1; i >= 0; i--) {
        StepMeta stepMeta = transMeta.getStep(i);
        if (stepMeta.isSelected()) {
            selectedStepsCount++;
        }
    }
    TransPainterFlyoutExtension extension = null;
    for (int i = transMeta.nrSteps() - 1; i >= 0; i--) {
        StepMeta stepMeta = transMeta.getStep(i);
        if (stepMeta.isSelected() && stepMeta.isDrawn() && selectedStepsCount == 1) {
            extension = new TransPainterFlyoutExtension(gc, areaOwners, transMeta, stepMeta, translationX, translationY, magnification, area, offset);
            break;
        }
    }
    if (extension == null) {
        // pass null to notify extension that nothing is selected
        extension = new TransPainterFlyoutExtension(gc, areaOwners, transMeta, null, translationX, translationY, magnification, area, offset);
    }
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.TransPainterFlyout.id, extension);
    } catch (Exception e) {
        LogChannel.GENERAL.logError("Error calling extension point(s) for the transformation painter step", e);
    }
    // 
    if (noInputStep != null) {
        gc.setLineWidth(2);
        gc.setForeground(EColor.RED);
        Point n = noInputStep.getLocation();
        gc.drawLine(n.x - 5, n.y - 5, n.x + iconsize + 10, n.y + iconsize + 10);
        gc.drawLine(n.x - 5, n.y + iconsize + 5, n.x + iconsize + 5, n.y - 5);
    }
    if (drop_candidate != null) {
        gc.setLineStyle(ELineStyle.SOLID);
        gc.setForeground(EColor.BLACK);
        Point screen = real2screen(drop_candidate.x, drop_candidate.y);
        gc.drawRectangle(screen.x, screen.y, iconsize, iconsize);
    }
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.TransPainterEnd.id, this);
    } catch (KettleException e) {
        LogChannel.GENERAL.logError("Error in TransPainterEnd extension point", e);
    }
    if (!shadow) {
        drawRect(selrect);
    }
}

Example 5 with EImage

use of org.pentaho.di.core.gui.PrimitiveGCInterface.EImage in project pentaho-kettle by pentaho.

the class TransPainter method drawStep.

private void drawStep(StepMeta stepMeta) {
    if (stepMeta == null) {
        return;
    }
    int alpha = gc.getAlpha();
    StepIOMetaInterface ioMeta = stepMeta.getStepMetaInterface().getStepIOMeta();
    Point pt = stepMeta.getLocation();
    if (pt == null) {
        pt = new Point(50, 50);
    }
    Point screen = real2screen(pt.x, pt.y);
    int x = screen.x;
    int y = screen.y;
    boolean stepError = false;
    if (stepLogMap != null && !stepLogMap.isEmpty()) {
        String log = stepLogMap.get(stepMeta);
        if (!Utils.isEmpty(log)) {
            stepError = true;
        }
    }
    // 
    if (!stepMeta.getRemoteInputSteps().isEmpty()) {
        gc.setLineWidth(1);
        gc.setForeground(EColor.GRAY);
        gc.setBackground(EColor.BACKGROUND);
        gc.setFont(EFont.GRAPH);
        String nrInput = Integer.toString(stepMeta.getRemoteInputSteps().size());
        Point textExtent = gc.textExtent(nrInput);
        // add a tiny listartHopStepttle bit of a margin
        textExtent.x += 2;
        textExtent.y += 2;
        // Draw it an icon above the step icon.
        // Draw it an icon and a half to the left
        // 
        Point point = new Point(x - iconsize - iconsize / 2, y - iconsize);
        gc.drawRectangle(point.x, point.y, textExtent.x, textExtent.y);
        gc.drawText(nrInput, point.x + 1, point.y + 1);
        // Now we draw an arrow from the cube to the step...
        // 
        gc.drawLine(point.x + textExtent.x, point.y + textExtent.y / 2, x - iconsize / 2, point.y + textExtent.y / 2);
        drawArrow(EImage.ARROW_DISABLED, x - iconsize / 2, point.y + textExtent.y / 2, x + iconsize / 3, y, Math.toRadians(15), 15, 1.8, null, null, null);
        // Add to the list of areas...
        if (!shadow) {
            areaOwners.add(new AreaOwner(AreaType.REMOTE_INPUT_STEP, point.x, point.y, textExtent.x, textExtent.y, offset, stepMeta, STRING_REMOTE_INPUT_STEPS));
        }
    }
    // 
    if (!stepMeta.getRemoteOutputSteps().isEmpty()) {
        gc.setLineWidth(1);
        gc.setForeground(EColor.GRAY);
        gc.setBackground(EColor.BACKGROUND);
        gc.setFont(EFont.GRAPH);
        String nrOutput = Integer.toString(stepMeta.getRemoteOutputSteps().size());
        Point textExtent = gc.textExtent(nrOutput);
        // add a tiny little bit of a margin
        textExtent.x += 2;
        textExtent.y += 2;
        // Draw it an icon above the step icon.
        // Draw it an icon and a half to the right
        // 
        Point point = new Point(x + 2 * iconsize + iconsize / 2 - textExtent.x, y - iconsize);
        gc.drawRectangle(point.x, point.y, textExtent.x, textExtent.y);
        gc.drawText(nrOutput, point.x + 1, point.y + 1);
        // Now we draw an arrow from the cube to the step...
        // This time, we start at the left side...
        // 
        gc.drawLine(point.x, point.y + textExtent.y / 2, x + iconsize + iconsize / 2, point.y + textExtent.y / 2);
        drawArrow(EImage.ARROW_DISABLED, x + 2 * iconsize / 3, y, x + iconsize + iconsize / 2, point.y + textExtent.y / 2, Math.toRadians(15), 15, 1.8, null, null, null);
        // Add to the list of areas...
        if (!shadow) {
            areaOwners.add(new AreaOwner(AreaType.REMOTE_OUTPUT_STEP, point.x, point.y, textExtent.x, textExtent.y, offset, stepMeta, STRING_REMOTE_OUTPUT_STEPS));
        }
    }
    // 
    if (stepMeta.isPartitioned()) {
        gc.setLineWidth(1);
        gc.setForeground(EColor.RED);
        gc.setBackground(EColor.BACKGROUND);
        gc.setFont(EFont.GRAPH);
        PartitionSchema partitionSchema = stepMeta.getStepPartitioningMeta().getPartitionSchema();
        if (partitionSchema != null) {
            String nrInput;
            if (partitionSchema.isDynamicallyDefined()) {
                nrInput = "Dx" + partitionSchema.getNumberOfPartitionsPerSlave();
            } else {
                nrInput = "Px" + Integer.toString(partitionSchema.getPartitionIDs().size());
            }
            Point textExtent = gc.textExtent(nrInput);
            // add a tiny little bit of a margin
            textExtent.x += 2;
            textExtent.y += 2;
            // Draw it a 2 icons above the step icon.
            // Draw it an icon and a half to the left
            // 
            Point point = new Point(x - iconsize - iconsize / 2, y - iconsize - iconsize);
            gc.drawRectangle(point.x, point.y, textExtent.x, textExtent.y);
            gc.drawText(nrInput, point.x + 1, point.y + 1);
            // Now we draw an arrow from the cube to the step...
            // 
            gc.drawLine(point.x + textExtent.x, point.y + textExtent.y / 2, x - iconsize / 2, point.y + textExtent.y / 2);
            gc.drawLine(x - iconsize / 2, point.y + textExtent.y / 2, x + iconsize / 3, y);
            // Also draw the name of the partition schema below the box
            // 
            gc.setForeground(EColor.GRAY);
            gc.drawText(Const.NVL(partitionSchema.getName(), "<no partition name>"), point.x, point.y + textExtent.y + 3, true);
            // 
            if (!shadow) {
                areaOwners.add(new AreaOwner(AreaType.STEP_PARTITIONING, point.x, point.y, textExtent.x, textExtent.y, offset, stepMeta, STRING_PARTITIONING_CURRENT_STEP));
            }
        }
    }
    String name = stepMeta.getName();
    if (stepMeta.isSelected()) {
        gc.setLineWidth(linewidth + 2);
    } else {
        gc.setLineWidth(linewidth);
    }
    // Add to the list of areas...
    if (!shadow) {
        areaOwners.add(new AreaOwner(AreaType.STEP_ICON, x, y, iconsize, iconsize, offset, transMeta, stepMeta));
    }
    gc.setBackground(EColor.BACKGROUND);
    gc.fillRoundRectangle(x - 1, y - 1, iconsize + 1, iconsize + 1, 8, 8);
    gc.drawStepIcon(x, y, stepMeta, magnification);
    if (stepError || stepMeta.isMissing()) {
        gc.setForeground(EColor.RED);
    } else {
        gc.setForeground(EColor.CRYSTAL);
    }
    if (stepMeta.isSelected()) {
        gc.setForeground(0, 93, 166);
    }
    gc.drawRoundRectangle(x - 1, y - 1, iconsize + 1, iconsize + 1, 8, 8);
    Point namePosition = getNamePosition(name, screen, iconsize);
    if (stepMeta.isSelected()) {
        int tmpAlpha = gc.getAlpha();
        gc.setAlpha(192);
        gc.setBackground(216, 230, 241);
        gc.fillRoundRectangle(namePosition.x - 8, namePosition.y - 2, gc.textExtent(name).x + 15, 25, BasePainter.CORNER_RADIUS_5 + 15, BasePainter.CORNER_RADIUS_5 + 15);
        gc.setAlpha(tmpAlpha);
    }
    gc.setForeground(EColor.BLACK);
    gc.setFont(EFont.GRAPH);
    gc.drawText(name, namePosition.x, namePosition.y + 2, true);
    boolean partitioned = false;
    StepPartitioningMeta meta = stepMeta.getStepPartitioningMeta();
    if (stepMeta.isPartitioned() && meta != null) {
        partitioned = true;
    }
    String clusterMessage = "";
    if (stepMeta.getClusterSchema() != null) {
        clusterMessage = "C";
        if (stepMeta.getClusterSchema().isDynamic()) {
            clusterMessage += "xN";
        } else {
            clusterMessage += "x" + stepMeta.getClusterSchema().findNrSlaves();
        }
        Point textExtent = gc.textExtent(clusterMessage);
        gc.setBackground(EColor.BACKGROUND);
        gc.setForeground(EColor.BLACK);
        gc.drawText(clusterMessage, x - textExtent.x + 1, y - textExtent.y + 1);
    }
    if (stepMeta.getCopies() != 1 && !partitioned) {
        gc.setBackground(EColor.BACKGROUND);
        gc.setForeground(EColor.BLACK);
        String copies = "x" + stepMeta.getCopiesString();
        Point textExtent = gc.textExtent(copies);
        if (stepMeta.getClusterSchema() != null) {
            Point clusterTextExtent = gc.textExtent(clusterMessage);
            gc.drawText(copies, x - textExtent.x + 1, y - textExtent.y - clusterTextExtent.y + 1, false);
            areaOwners.add(new AreaOwner(AreaType.STEP_COPIES_TEXT, x - textExtent.x + 1, y - textExtent.y - clusterTextExtent.y + 1, textExtent.x, textExtent.y, offset, transMeta, stepMeta));
        } else {
            gc.drawText(copies, x - textExtent.x + 1, y - textExtent.y + 1, false);
            areaOwners.add(new AreaOwner(AreaType.STEP_COPIES_TEXT, x - textExtent.x + 1, y - textExtent.y + 1, textExtent.x, textExtent.y, offset, transMeta, stepMeta));
        }
    }
    // 
    if (stepError) {
        String log = stepLogMap.get(stepMeta);
        // Show an error lines icon in the upper right corner of the step...
        // 
        int xError = (x + iconsize) - (MINI_ICON_SIZE / 2) + 4;
        int yError = y - (MINI_ICON_SIZE / 2) - 1;
        Point ib = gc.getImageBounds(EImage.STEP_ERROR_RED);
        gc.drawImage(EImage.STEP_ERROR_RED, xError, yError, magnification);
        if (!shadow) {
            areaOwners.add(new AreaOwner(AreaType.STEP_ERROR_RED_ICON, pt.x + iconsize - 3, pt.y - 8, ib.x, ib.y, offset, log, STRING_STEP_ERROR_LOG));
        }
    }
    // 
    if (mouseOverSteps.contains(stepMeta)) {
        gc.setTransform(translationX, translationY, 0, BasePainter.FACTOR_1_TO_1);
        StepMetaInterface stepMetaInterface = stepMeta.getStepMetaInterface();
        boolean mdiSupport = stepMetaInterface.getStepMetaInjectionInterface() != null || BeanInjectionInfo.isInjectionSupported(stepMetaInterface.getClass());
        EImage[] miniIcons;
        if (mdiSupport) {
            miniIcons = new EImage[] { EImage.INPUT, EImage.EDIT, EImage.CONTEXT_MENU, EImage.OUTPUT, EImage.INJECT };
        } else {
            miniIcons = new EImage[] { EImage.INPUT, EImage.EDIT, EImage.CONTEXT_MENU, EImage.OUTPUT };
        }
        int totalHeight = 0;
        int totalIconsWidth = 0;
        int totalWidth = 2 * MINI_ICON_MARGIN;
        for (EImage miniIcon : miniIcons) {
            Point bounds = gc.getImageBounds(miniIcon);
            totalWidth += bounds.x + MINI_ICON_MARGIN;
            totalIconsWidth += bounds.x + MINI_ICON_MARGIN;
            if (bounds.y > totalHeight) {
                totalHeight = bounds.y;
            }
        }
        totalHeight += 2 * MINI_ICON_MARGIN;
        gc.setFont(EFont.SMALL);
        String trimmedName = stepMeta.getName().length() < 30 ? stepMeta.getName() : stepMeta.getName().substring(0, 30);
        Point nameExtent = gc.textExtent(trimmedName);
        nameExtent.y += 2 * MINI_ICON_MARGIN;
        nameExtent.x += 3 * MINI_ICON_MARGIN;
        totalHeight += nameExtent.y;
        if (nameExtent.x > totalWidth) {
            totalWidth = nameExtent.x;
        }
        int areaX = translateToCurrentScale(x) + translateToCurrentScale(iconsize) / 2 - totalWidth / 2 + MINI_ICON_SKEW;
        int areaY = translateToCurrentScale(y) + translateToCurrentScale(iconsize) + MINI_ICON_DISTANCE + BasePainter.CONTENT_MENU_INDENT;
        gc.setForeground(EColor.CRYSTAL);
        gc.setBackground(EColor.CRYSTAL);
        gc.setLineWidth(1);
        gc.fillRoundRectangle(areaX, areaY, totalWidth, totalHeight, BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.setBackground(EColor.WHITE);
        gc.fillRoundRectangle(areaX, areaY + nameExtent.y, totalWidth, (totalHeight - nameExtent.y), BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.fillRectangle(areaX, areaY + nameExtent.y, totalWidth, (totalHeight - nameExtent.y) / 2);
        gc.drawRoundRectangle(areaX, areaY, totalWidth, totalHeight, BasePainter.CORNER_RADIUS_5, BasePainter.CORNER_RADIUS_5);
        gc.setForeground(EColor.WHITE);
        gc.drawText(trimmedName, areaX + (totalWidth - nameExtent.x) / 2 + MINI_ICON_MARGIN, areaY + MINI_ICON_MARGIN, true);
        gc.setForeground(EColor.CRYSTAL);
        gc.setBackground(EColor.CRYSTAL);
        gc.setFont(EFont.GRAPH);
        areaOwners.add(new AreaOwner(AreaType.MINI_ICONS_BALLOON, translateTo1To1(areaX), translateTo1To1(areaY), translateTo1To1(totalWidth), translateTo1To1(totalHeight), offset, stepMeta, ioMeta));
        gc.fillPolygon(new int[] { areaX + totalWidth / 2 - MINI_ICON_TRIANGLE_BASE / 2 + 1, areaY + 2, areaX + totalWidth / 2 + MINI_ICON_TRIANGLE_BASE / 2, areaY + 2, areaX + totalWidth / 2 - MINI_ICON_SKEW, areaY - MINI_ICON_DISTANCE - 3 });
        gc.setBackground(EColor.WHITE);
        // Put on the icons...
        // 
        int xIcon = areaX + (totalWidth - totalIconsWidth) / 2 + MINI_ICON_MARGIN;
        int yIcon = areaY + 5 + nameExtent.y;
        for (int i = 0; i < miniIcons.length; i++) {
            EImage miniIcon = miniIcons[i];
            Point bounds = gc.getImageBounds(miniIcon);
            boolean enabled = false;
            switch(i) {
                case // INPUT
                0:
                    enabled = ioMeta.isInputAcceptor() || ioMeta.isInputDynamic();
                    areaOwners.add(new AreaOwner(AreaType.STEP_INPUT_HOP_ICON, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, stepMeta, ioMeta));
                    break;
                case // EDIT
                1:
                    enabled = true;
                    areaOwners.add(new AreaOwner(AreaType.STEP_EDIT_ICON, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, stepMeta, ioMeta));
                    break;
                case // STEP_MENU
                2:
                    enabled = true;
                    areaOwners.add(new AreaOwner(AreaType.STEP_MENU_ICON, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, stepMeta, ioMeta));
                    break;
                case // OUTPUT
                3:
                    enabled = ioMeta.isOutputProducer() || ioMeta.isOutputDynamic();
                    areaOwners.add(new AreaOwner(AreaType.STEP_OUTPUT_HOP_ICON, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, stepMeta, ioMeta));
                    break;
                case // INJECT
                4:
                    enabled = mdiSupport;
                    StepMetaInterface mdiObject = mdiSupport ? stepMetaInterface : null;
                    areaOwners.add(new AreaOwner(AreaType.STEP_INJECT_ICON, translateTo1To1(xIcon), translateTo1To1(yIcon), translateTo1To1(bounds.x), translateTo1To1(bounds.y), offset, stepMeta, mdiObject));
                    break;
                default:
                    break;
            }
            if (enabled) {
                gc.setAlpha(255);
            } else {
                gc.setAlpha(100);
            }
            gc.drawImage(miniIcon, xIcon, yIcon, BasePainter.FACTOR_1_TO_1);
            xIcon += bounds.x + 5;
        }
        // 
        if (showTargetStreamsStep != null) {
            ioMeta = showTargetStreamsStep.getStepMetaInterface().getStepIOMeta();
            List<StreamInterface> targetStreams = ioMeta.getTargetStreams();
            int targetsWidth = 0;
            int targetsHeight = 0;
            for (int i = 0; i < targetStreams.size(); i++) {
                String description = targetStreams.get(i).getDescription();
                Point extent = gc.textExtent(description);
                if (extent.x > targetsWidth) {
                    targetsWidth = extent.x;
                }
                targetsHeight += extent.y + MINI_ICON_MARGIN;
            }
            targetsWidth += MINI_ICON_MARGIN;
            gc.setBackground(EColor.LIGHTGRAY);
            gc.fillRoundRectangle(areaX, areaY + totalHeight + 2, targetsWidth, targetsHeight, 7, 7);
            gc.drawRoundRectangle(areaX, areaY + totalHeight + 2, targetsWidth, targetsHeight, 7, 7);
            int targetY = areaY + totalHeight + MINI_ICON_MARGIN;
            for (int i = 0; i < targetStreams.size(); i++) {
                String description = targetStreams.get(i).getDescription();
                Point extent = gc.textExtent(description);
                gc.drawText(description, areaX + MINI_ICON_MARGIN, targetY, true);
                if (i < targetStreams.size() - 1) {
                    gc.drawLine(areaX + MINI_ICON_MARGIN / 2, targetY + extent.y + 3, areaX + targetsWidth - MINI_ICON_MARGIN / 2, targetY + extent.y + 2);
                }
                areaOwners.add(new AreaOwner(AreaType.STEP_TARGET_HOP_ICON_OPTION, areaX, targetY, targetsWidth, extent.y + MINI_ICON_MARGIN, offset, stepMeta, targetStreams.get(i)));
                targetY += extent.y + MINI_ICON_MARGIN;
            }
            gc.setBackground(EColor.BACKGROUND);
        }
        gc.setTransform(translationX, translationY, 0, magnification);
    }
    TransPainterExtension extension = new TransPainterExtension(gc, shadow, areaOwners, transMeta, stepMeta, null, x, y, 0, 0, 0, 0, offset, iconsize);
    try {
        ExtensionPointHandler.callExtensionPoint(LogChannel.GENERAL, KettleExtensionPoint.TransPainterStep.id, extension);
    } catch (Exception e) {
        LogChannel.GENERAL.logError("Error calling extension point(s) for the transformation painter step", e);
    }
    // Restore the previous alpha value
    // 
    gc.setAlpha(alpha);
}