return backgroundImage;
}
- public int getXPixcelFromX(double x, Rectangle r) {
+ public int getXPixelFromX(double x, Rectangle r) {
return (int) Math.round((r.width) * (x - visibleStartX)
/ (visibleEndX - visibleStartX));
}
- public int getXPixcelFromX(double x) {
+ public int getXPixelFromX(double x) {
Rectangle r = chart.getBounds();
- return getXPixcelFromX(x, r);
+ return getXPixelFromX(x, r);
}
- public int getYPixcelFromY(double maxY, double y, Rectangle r) {
- double pixcelY;
+ public int getYPixelFromY(double maxY, double y, Rectangle r) {
+ double pixelY;
if (visibleStartY == maxY) {
- pixcelY = 0;
+ pixelY = 0;
} else {
- pixcelY = ((double) r.height) * (y - visibleStartY)
+ pixelY = ((double) r.height) * (y - visibleStartY)
/ (maxY - visibleStartY);
}
- return (int) (r.height - pixcelY);
+ return (int) (r.height - pixelY);
}
- public double getXFromXPixcel(int xPixcel, Rectangle r) {
- return (((visibleEndX - visibleStartX) * (double) xPixcel) / (double) r.width)
+ public double getXFromXPixel(int xPixel, Rectangle r) {
+ return (((visibleEndX - visibleStartX) * (double) xPixel) / (double) r.width)
+ visibleStartX;
}
- public double getXFromXPixcel(int xPixcel) {
+ public double getXFromXPixel(int xPixel) {
Rectangle r = chart.getBounds();
- return getXFromXPixcel(xPixcel, r);
+ return getXFromXPixel(xPixel, r);
}
- public double getYFromYPixcel(int yPixcel, Rectangle r) {
- int y = yPixcel + r.height + 1;
+ public double getYFromYPixel(int yPixel, Rectangle r) {
+ int y = yPixel + r.height + 1;
return (((visibleEndY - visibleStartY) * (double) y) / (double) r.height)
+ visibleStartY;
}
- public double getYFromYPixcel(int yPixcel) {
+ public double getYFromYPixel(int yPixel) {
Rectangle r = chart.getBounds();
- return getYFromYPixcel(yPixcel, r);
+ return getYFromYPixel(yPixel, r);
}
public double getValidEndX() {
int markerSize = markers.size();
DAChartPlotMarker marker;
int markerStyle;
- int pixcelStartX;
- int pixcelEndX;
+ int pixelStartX;
+ int pixelEndX;
for (int i = 0; i < markerSize; i++) {
marker = markers.get(i);
gc.setBackground(marker.getBackgroundColor());
gc.setAlpha(marker.getAlpha());
- pixcelStartX = plot.getXPixcelFromX(marker.getVal());
+ pixelStartX = plot.getXPixelFromX(marker.getVal());
markerStyle = DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA;
if (marker instanceof DAChartPlotIntervalMarker) {
- pixcelEndX = plot.getXPixcelFromX(((DAChartPlotIntervalMarker) marker).getEndVal());
+ pixelEndX = plot.getXPixelFromX(((DAChartPlotIntervalMarker) marker).getEndVal());
markerStyle = ((DAChartPlotIntervalMarker) marker).getMarkerStyle();
if (markerStyle != DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_LINE) {
- int width = pixcelEndX - pixcelStartX;
+ int width = pixelEndX - pixelStartX;
if (width <= 1) {
width = marker.getLineWidth();
}
- gc.fillRectangle(pixcelStartX, 0, width, r.height);
+ gc.fillRectangle(pixelStartX, 0, width, r.height);
}
if (markerStyle != DAChartPlotIntervalMarker.INTERVAL_MARKER_STYLE_AREA) {
- gc.drawLine(pixcelStartX, r.y, pixcelStartX, r.height);
- gc.drawLine(pixcelEndX, r.y, pixcelEndX, r.height);
+ gc.drawLine(pixelStartX, r.y, pixelStartX, r.height);
+ gc.drawLine(pixelEndX, r.y, pixelEndX, r.height);
}
} else {
gc.setLineWidth(marker.getLineWidth());
- gc.drawLine(pixcelStartX, r.y, pixcelStartX, r.height);
+ gc.drawLine(pixelStartX, r.y, pixelStartX, r.height);
}
}
gc.setAlpha(oldAlpha);
}
protected int getTooltipStartX(double startVal, int width, int margin) {
- int ret = plot.getXPixcelFromX(startVal);
+ int ret = plot.getXPixelFromX(startVal);
if (ret + width > r.x + r.width) {
ret = ret - width - margin;
} else if (ret < r.x) {
prevVal = series.getSeriesItemList().get(index - 1).getX();
- int pixcelStartX = plot.getXPixcelFromX(val, r);
- int pixcelStartPrevX = plot.getXPixcelFromX(prevVal, r);
+ int pixelStartX = plot.getXPixelFromX(val, r);
+ int pixelStartPrevX = plot.getXPixelFromX(prevVal, r);
- if (pixcelStartPrevX + EVENT_WIDTH >= pixcelStartX) {
+ if (pixelStartPrevX + EVENT_WIDTH >= pixelStartX) {
return true;
}
return false;
}
double maxY = getMaxYToDraw(series, startIndex);
- gc.drawLine(0, plot.getYPixcelFromY(maxY, yVal, r), r.width,
- plot.getYPixcelFromY(maxY, yVal, r));
+ gc.drawLine(0, plot.getYPixelFromY(maxY, yVal, r), r.width,
+ plot.getYPixelFromY(maxY, yVal, r));
}
- gc.drawLine(plot.getXPixcelFromX(xVal), 0, plot.getXPixcelFromX(xVal), r.height);
+ gc.drawLine(plot.getXPixelFromX(xVal), 0, plot.getXPixelFromX(xVal), r.height);
gc.setLineStyle(SWT.LINE_CUSTOM);
// event color
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int pixcelStartY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int pixelStartY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
- int barWidth = plot.getXPixcelFromX(currentX + barWidthTime, r) - pixcelStartX;
+ int barWidth = plot.getXPixelFromX(currentX + barWidthTime, r) - pixelStartX;
if (barWidth < 1) {
barWidth = 1;
}
if (barAlign == DAChartSeries.SERIES_BAR_ALIGN_CENTER) {
- pixcelStartX -= barWidth / 2;
+ pixelStartX -= barWidth / 2;
} else if (barAlign == DAChartSeries.SERIES_BAR_ALIGN_RIGHT) {
- pixcelStartX -= barWidth;
+ pixelStartX -= barWidth;
}
color = seriesItem.getColor();
if (null != color) {
gc.setBackground(color);
- gc.fillRectangle(pixcelStartX, pixcelStartY, barWidth, r.y + r.height
- - pixcelStartY);
+ gc.fillRectangle(pixelStartX, pixelStartY, barWidth, r.y + r.height
+ - pixelStartY);
gc.setBackground(series.getColor());
} else {
DAChartPlot.BoundType boundType = plot.getBoundType();
}
}
}
- gc.fillRectangle(pixcelStartX, pixcelStartY, barWidth, r.y + r.height
- - pixcelStartY);
+ gc.fillRectangle(pixelStartX, pixelStartY, barWidth, r.y + r.height
+ - pixelStartY);
gc.setBackground(series.getColor());
gc.setAlpha(250);
}
seriesItem = seriesItems.get(i);
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(currentX, rect);
- int pixcelStartY = rect.y + MARGIN;
+ int pixelStartX = plot.getXPixelFromX(currentX, rect);
+ int pixelStartY = rect.y + MARGIN;
if (highlightedIndexY == seriesIndex && highlightedIndexX == i) {
// FIXME size
- pixcelStartY -= 8;
+ pixelStartY -= 8;
}
color = seriesItem.getColor();
if (null != color) {
gc.setBackground(color);
- gc.fillRectangle(pixcelStartX, pixcelStartY, MULTI_CHECK_BAR_WIDTH, rect.height
+ gc.fillRectangle(pixelStartX, pixelStartY, MULTI_CHECK_BAR_WIDTH, rect.height
- MARGIN);
gc.setBackground(series.getColor());
} else {
- gc.fillRectangle(pixcelStartX, pixcelStartY, MULTI_CHECK_BAR_WIDTH, rect.height
+ gc.fillRectangle(pixelStartX, pixelStartY, MULTI_CHECK_BAR_WIDTH, rect.height
- MARGIN);
}
if (currentX > plot.getVisibleEndX()) {
double maxY = getMaxYToDraw(series, index);
DAChartSeriesItem seriesItem = seriesItems.get(0);
- int oldPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int oldPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int oldPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int oldPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
if (seriesItemSize == 1) {
- if (oldPixcelX < r.x) {
+ if (oldPixelX < r.x) {
return;
}
Color color = seriesItem.getColor();
color = series.getColor();
}
gc.setForeground(color);
- gc.drawPoint(oldPixcelX, oldPixcelY);
+ gc.drawPoint(oldPixelX, oldPixelY);
return;
}
seriesItem = seriesItems.get(index);
double currentX = seriesItem.getX();
- int newPixcelX = plot.getXPixcelFromX(currentX, r);
- int newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int newPixelX = plot.getXPixelFromX(currentX, r);
+ int newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
/*
- * collect pixcels to draw and then draw them at once.
+ * collect pixels to draw and then draw them at once.
*/
List<Integer> points = new ArrayList<Integer>();
- points.add(newPixcelX);
- points.add(newPixcelY);
+ points.add(newPixelX);
+ points.add(newPixelY);
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
currentX = seriesItem.getX();
- newPixcelX = plot.getXPixcelFromX(currentX, r);
- newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ newPixelX = plot.getXPixelFromX(currentX, r);
+ newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
- points.add(newPixcelX);
- points.add(newPixcelY);
+ points.add(newPixelX);
+ points.add(newPixelY);
if (currentX > plot.getVisibleEndX()) {
break;
// // draw endVal
if (true == bEndVal) {
- int endX = plot.getXPixcelFromX(plot.getValidEndX(), r);
- if (endX > newPixcelX) {
- gc.drawLine(newPixcelX, newPixcelY, endX, newPixcelY);
+ int endX = plot.getXPixelFromX(plot.getValidEndX(), r);
+ if (endX > newPixelX) {
+ gc.drawLine(newPixelX, newPixelY, endX, newPixelY);
}
}
}
double maxY = getMaxYToDraw(series, index);
DAChartSeriesItem seriesItem = seriesItems.get(0);
- int oldPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int oldPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int oldPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int oldPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
int baseY = r.y + r.height;
if (seriesItemSize == 1) {
- if (oldPixcelX < r.x) {
+ if (oldPixelX < r.x) {
return;
}
Color color = seriesItem.getColor();
color = series.getColor();
}
gc.setForeground(color);
- gc.drawLine(oldPixcelX, baseY, oldPixcelX, oldPixcelY);
+ gc.drawLine(oldPixelX, baseY, oldPixelX, oldPixelY);
return;
}
seriesItem = seriesItems.get(index);
double currentX = seriesItem.getX();
- int newPixcelX = plot.getXPixcelFromX(currentX, r);
- int newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int newPixelX = plot.getXPixelFromX(currentX, r);
+ int newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
/*
- * collect pixcels to draw and then draw them at once.
+ * collect pixels to draw and then draw them at once.
*/
List<Integer> points = new ArrayList<Integer>();
- points.add(newPixcelX);
+ points.add(newPixelX);
points.add(baseY);
- points.add(newPixcelX);
- points.add(newPixcelY);
+ points.add(newPixelX);
+ points.add(newPixelY);
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
currentX = seriesItem.getX();
- newPixcelX = plot.getXPixcelFromX(currentX, r);
- newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
- points.add(newPixcelX);
- points.add(newPixcelY);
+ newPixelX = plot.getXPixelFromX(currentX, r);
+ newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
+ points.add(newPixelX);
+ points.add(newPixelY);
if (i == seriesItemSize - 1 || currentX > plot.getVisibleEndX()) {
- points.add(newPixcelX);
+ points.add(newPixelX);
points.add(baseY);
}
if (currentX > plot.getVisibleEndX()) {
// // draw endVal
if (true == bEndVal) {
- int endX = plot.getXPixcelFromX(plot.getValidEndX(), r);
- if (endX > newPixcelX) {
+ int endX = plot.getXPixelFromX(plot.getValidEndX(), r);
+ if (endX > newPixelX) {
gc.setAlpha((int) (255 * 0.4));
- int[] polygon = { newPixcelX, baseY, newPixcelX, newPixcelY, endX, newPixcelY,
+ int[] polygon = { newPixelX, baseY, newPixelX, newPixelY, endX, newPixelY,
endX, baseY };
gc.fillPolygon(polygon);
}
*/
int margin = (int) ((r.height * (MARGIN_PERCENT / 100.0)) / (seriesSize + 1));
int areaHeight = (r.height - margin * (seriesSize + 1)) / seriesSize;
- int pixcelStartY = (margin * (seriesIndex + 1)) + (areaHeight * seriesIndex);
+ int pixelStartY = (margin * (seriesIndex + 1)) + (areaHeight * seriesIndex);
List<DAChartSeriesItem> barSeriesItems = new ArrayList<DAChartSeriesItem>();
/*
gc.setForeground(foreGroundColor);
gc.setBackground(backGroundcolor);
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int pixcelWidth;
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int pixelWidth;
if (endSeriesItem != null) {
- pixcelWidth = plot.getXPixcelFromX(endSeriesItem.getX(), r) - pixcelStartX;
+ pixelWidth = plot.getXPixelFromX(endSeriesItem.getX(), r) - pixelStartX;
} else {
/*
* endSeriesItem is null when end series is not exist. this
* case, draw it as much as getValidEndX.
*/
- pixcelWidth = plot.getXPixcelFromX(plot.getValidEndX(), r) - pixcelStartX;
+ pixelWidth = plot.getXPixelFromX(plot.getValidEndX(), r) - pixelStartX;
}
- if (pixcelWidth == 0) { // If diffence is less than 1 second.
- // draw 1 pixcel force.
- pixcelWidth = 1;
+ if (pixelWidth == 0) { // If diffence is less than 1 second.
+ // draw 1 pixel force.
+ pixelWidth = 1;
}
- gc.fillRectangle(pixcelStartX, pixcelStartY, pixcelWidth, areaHeight);
+ gc.fillRectangle(pixelStartX, pixelStartY, pixelWidth, areaHeight);
/*
* If it's needed, draw diagonal line. diagonal line is composed
gc.setForeground(DIAGONAL_BOX_COLOR);
gc.setBackground(DIAGONAL_BOX_COLOR);
for (int j = 0; j < 16; j++) {
- int boxY = pixcelStartY + (diagonalBoxSize * j);
+ int boxY = pixelStartY + (diagonalBoxSize * j);
// Formula to draw diagonal line like "/"
- for (int k = 3 - (j % 4) - (j / 4); k < pixcelWidth; k = k + 3) {
- int boxX = diagonalBoxSize * k + pixcelStartX;
- if (pixcelStartX <= boxX
- && boxX <= pixcelWidth + pixcelStartX - diagonalBoxSize) {
+ for (int k = 3 - (j % 4) - (j / 4); k < pixelWidth; k = k + 3) {
+ int boxX = diagonalBoxSize * k + pixelStartX;
+ if (pixelStartX <= boxX
+ && boxX <= pixelWidth + pixelStartX - diagonalBoxSize) {
gc.fillRectangle(boxX, boxY, diagonalBoxSize, diagonalBoxSize);
}
}
Color backGroundcolor = barSeriesItem.getColor();
gc.setForeground(foreGroundColor);
gc.setBackground(backGroundcolor);
- int pixcelStartX = plot.getXPixcelFromX(barSeriesItem.getX(), r);
- gc.fillRectangle(pixcelStartX, pixcelStartY, STATE_AREA_BAR_WIDTH, areaHeight);
+ int pixelStartX = plot.getXPixelFromX(barSeriesItem.getX(), r);
+ gc.fillRectangle(pixelStartX, pixelStartY, STATE_AREA_BAR_WIDTH, areaHeight);
}
}
double maxY = getMaxYToDraw(series, index);
DAChartSeriesItem seriesItem = seriesItems.get(0);
- int oldPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int oldPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int oldPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int oldPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
if (seriesItemSize == 1) {
- if (oldPixcelX < r.x) {
+ if (oldPixelX < r.x) {
return;
}
Color color = seriesItem.getColor();
color = series.getColor();
}
gc.setForeground(color);
- gc.drawPoint(oldPixcelX, oldPixcelY);
+ gc.drawPoint(oldPixelX, oldPixelY);
return;
}
seriesItem = seriesItems.get(index);
double currentX = seriesItem.getX();
- int newPixcelX = plot.getXPixcelFromX(currentX, r);
- int newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ int newPixelX = plot.getXPixelFromX(currentX, r);
+ int newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
currentX = seriesItem.getX();
- oldPixcelX = newPixcelX;
- oldPixcelY = newPixcelY;
+ oldPixelX = newPixelX;
+ oldPixelY = newPixelY;
- newPixcelX = plot.getXPixcelFromX(currentX, r);
- newPixcelY = plot.getYPixcelFromY(maxY, seriesItem.getY(), r);
+ newPixelX = plot.getXPixelFromX(currentX, r);
+ newPixelY = plot.getYPixelFromY(maxY, seriesItem.getY(), r);
- gc.drawLine(oldPixcelX, oldPixcelY, newPixcelX, oldPixcelY);
- gc.drawLine(newPixcelX, oldPixcelY, newPixcelX, newPixcelY);
+ gc.drawLine(oldPixelX, oldPixelY, newPixelX, oldPixelY);
+ gc.drawLine(newPixelX, oldPixelY, newPixelX, newPixelY);
if (currentX > plot.getVisibleEndX()) {
return;
}
}
// draw endVal
if (bEndVal) {
- int endX = plot.getXPixcelFromX(plot.getValidEndX(), r);
- if (endX > newPixcelX) {
- gc.drawLine(newPixcelX, newPixcelY, endX, newPixcelY);
+ int endX = plot.getXPixelFromX(plot.getValidEndX(), r);
+ if (endX > newPixelX) {
+ gc.drawLine(newPixelX, newPixelY, endX, newPixelY);
}
}
}
DAChartSeriesItem seriesItem = seriesItems.get(i);
if (seriesItem != null) {
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(currentX, r);
+ int pixelStartX = plot.getXPixelFromX(currentX, r);
Image image = seriesItem.getImage();
int yPosition = (r.height - image.getBounds().height) / 2 - 1;
if (r.height != DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
}
if (i != highlightedImageIndex && i != selectedImageIndex) {
- gc.drawImage(image, pixcelStartX, yPosition);
+ gc.drawImage(image, pixelStartX, yPosition);
gc.setLineWidth(SCREENSHOT_BORDER_LINE_WIDTH);
gc.setForeground(ColorResources.SCREENSHOT_CHART_BORDER_LINE);
- gc.drawRectangle(pixcelStartX, yPosition, image.getBounds().width,
+ gc.drawRectangle(pixelStartX, yPosition, image.getBounds().width,
image.getBounds().height);
}
yPosition = SCREENSHOT_Y_POSITION_MINI;
highlightedYPosition = SCREENSHOT_SELECTED_Y_POSITION_MINI;
}
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
int screenshotWidth = selectedImage.getBounds().width;
int screenshotHeight = selectedImage.getBounds().height;
if (selectedImageIndex == highlightedImageIndex) {
- gc.drawRectangle(pixcelStartX - 1, highlightedYPosition - 1, screenshotWidth + 3,
+ gc.drawRectangle(pixelStartX - 1, highlightedYPosition - 1, screenshotWidth + 3,
screenshotHeight + 3);
} else {
- gc.drawImage(selectedImage, pixcelStartX, yPosition);
- gc.drawRectangle(pixcelStartX - 1, r.y + yPosition - 1, screenshotWidth + 3,
+ gc.drawImage(selectedImage, pixelStartX, yPosition);
+ gc.drawRectangle(pixelStartX - 1, r.y + yPosition - 1, screenshotWidth + 3,
screenshotHeight + 3);
gc.setLineWidth(SCREENSHOT_BORDER_LINE_WIDTH);
gc.setForeground(ColorResources.SCREENSHOT_CHART_BORDER_LINE);
- gc.drawRectangle(pixcelStartX, yPosition, screenshotWidth, screenshotHeight);
+ gc.drawRectangle(pixelStartX, yPosition, screenshotWidth, screenshotHeight);
}
}
highlightedYPosition = SCREENSHOT_SELECTED_Y_POSITION_MINI;
}
double currentX = seriesItems.get(highlightedImageIndex).getX();
- int pixcelStartX = plot.getXPixcelFromX(currentX, r);
+ int pixelStartX = plot.getXPixelFromX(currentX, r);
int screenshotWidth = highlightedImage.getBounds().width;
int screenshotHeight = highlightedImage.getBounds().height;
- gc.drawImage(highlightedImage, pixcelStartX, highlightedYPosition);
+ gc.drawImage(highlightedImage, pixelStartX, highlightedYPosition);
gc.setLineWidth(SCREENSHOT_BORDER_LINE_WIDTH);
gc.setForeground(ColorResources.SCREENSHOT_CHART_BORDER_LINE);
- gc.drawRectangle(pixcelStartX, highlightedYPosition, screenshotWidth, screenshotHeight);
+ gc.drawRectangle(pixelStartX, highlightedYPosition, screenshotWidth, screenshotHeight);
}
}
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
Color itemColor = seriesItem.getColor();
int barHeight = (int) ((r.y + r.height) * EVENT_HEIGHT_MARGIN_RATIO);
if (null != itemColor) {
gc.setBackground(itemColor);
- gc.fillRectangle(pixcelStartX, r.y + barHeight, EVENT_WIDTH, barHeight);
+ gc.fillRectangle(pixelStartX, r.y + barHeight, EVENT_WIDTH, barHeight);
gc.setBackground(color);
} else {
- gc.fillRectangle(pixcelStartX, r.y + barHeight, EVENT_WIDTH, barHeight);
+ gc.fillRectangle(pixelStartX, r.y + barHeight, EVENT_WIDTH, barHeight);
}
if (currentX > plot.getVisibleEndX()) {
break;
double currentStartX = seriesItem.getX();
double currentEndX = seriesItem.getY();
- int pixcelStartX = plot.getXPixcelFromX(currentStartX, r);
- int pixcelEndX = plot.getXPixcelFromX(currentEndX, r);
- int width = pixcelEndX - pixcelStartX;
+ int pixelStartX = plot.getXPixelFromX(currentStartX, r);
+ int pixelEndX = plot.getXPixelFromX(currentEndX, r);
+ int width = pixelEndX - pixelStartX;
if (width < EVENT_WIDTH) {
width = EVENT_WIDTH;
}
if (null != itemColor) {
gc.setBackground(itemColor);
- gc.fillRectangle(pixcelStartX, (r.y + r.height) - barHeight * 2, width, barHeight);
+ gc.fillRectangle(pixelStartX, (r.y + r.height) - barHeight * 2, width, barHeight);
gc.setBackground(color);
} else {
- gc.fillRectangle(pixcelStartX, (r.y + r.height) - barHeight * 2, width, barHeight);
+ gc.fillRectangle(pixelStartX, (r.y + r.height) - barHeight * 2, width, barHeight);
}
if (currentStartX > plot.getVisibleEndX()) {
break;
lastIndex = i;
}
int heightMargin = (int) ((r.y + r.height) * LOAD_HEIGHT_MARGIN_RATIO);
- int backStartX = plot.getXPixcelFromX(seriesItems.get(index).getX(), r);
- int backWidth = plot.getXPixcelFromX(seriesItems.get(lastIndex).getX(), r) - backStartX;
+ int backStartX = plot.getXPixelFromX(seriesItems.get(index).getX(), r);
+ int backWidth = plot.getXPixelFromX(seriesItems.get(lastIndex).getX(), r) - backStartX;
gc.fillRectangle(backStartX, r.y + heightMargin, backWidth, r.y + r.height - heightMargin
* 2);
// gc.setBackground(color);
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
- int barWidth = plot.getXPixcelFromX(currentX + barWidthTime, r) - pixcelStartX;
+ int barWidth = plot.getXPixelFromX(currentX + barWidthTime, r) - pixelStartX;
if (barWidth < 1) {
barWidth = EVENT_WIDTH;
}
gc.setBackground(getColorOfLoad(series, (float) seriesItem.getY() / 100));
- gc.fillRectangle(pixcelStartX, r.y + heightMargin, barWidth, r.y + r.height
+ gc.fillRectangle(pixelStartX, r.y + heightMargin, barWidth, r.y + r.height
- heightMargin * 2);
gc.setBackground(series.getColor());
if (currentX > plot.getVisibleEndX()) {
double currentX = seriesItem.getX();
double arrowPosition = seriesItem.getY();
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
int barHeight = (int) ((r.y + r.height) * EVENT_HEIGHT_MARGIN_RATIO);
int barPosY = r.y + r.height - barHeight * 2;
- gc.fillRectangle(pixcelStartX, barPosY, EVENT_WIDTH, barHeight);
+ gc.fillRectangle(pixelStartX, barPosY, EVENT_WIDTH, barHeight);
if (DAChartSeriesItem.SERIES_ARROW_NONE != arrowPosition) {
String number = String.valueOf((int) (seriesItem.getBarWidth()));
// arrowRect.y = (r.y + r.height) / 2 - imageRect.height / 2;
arrowRect.y = barPosY + barHeight / 2 - imageRect.height / 2;
if (DAChartSeriesItem.SERIES_ARROW_RIGHT == arrowPosition) {
- arrowRect.x = pixcelStartX + EVENT_WIDTH;
+ arrowRect.x = pixelStartX + EVENT_WIDTH;
} else {
- arrowRect.x = pixcelStartX - imageRect.width;
+ arrowRect.x = pixelStartX - imageRect.width;
}
gc.drawImage(arw, arrowRect.x, arrowRect.y);
Point p = gc.textExtent(number, SWT.DRAW_MNEMONIC);
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
double currentX = seriesItem.getX();
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
color = seriesItem.getColor();
foreColor = seriesItem.getGradationForegroundColor();
int state = (int) seriesItem.getY();
barWidth = EVENT_WIDTH;
}
- if (!equals(oldStateBarRectangle, pixcelStartX, r.y + heightMargin, barWidth, r.y
+ if (!equals(oldStateBarRectangle, pixelStartX, r.y + heightMargin, barWidth, r.y
+ r.height / 2 - heightMargin)) {
- oldStateBarRectangle.x = pixcelStartX;
+ oldStateBarRectangle.x = pixelStartX;
oldStateBarRectangle.y = r.y + heightMargin;
oldStateBarRectangle.width = barWidth;
oldStateBarRectangle.height = r.y + r.height / 2 - heightMargin;
gc.fillRectangle(oldStateBarRectangle);
}
- prevEndX = pixcelStartX + barWidth;
+ prevEndX = pixelStartX + barWidth;
break;
case DAChartSeriesItem.SERIES_STATE_CONTINUE:
if (i + 1 == seriesItemSize) {
- barWidth = plot.getXPixcelFromX(plot.getValidEndX(), r) - pixcelStartX;
+ barWidth = plot.getXPixelFromX(plot.getValidEndX(), r) - pixelStartX;
} else {
- barWidth = plot.getXPixcelFromX(seriesItems.get(i + 1).getX(), r)
- - pixcelStartX;
+ barWidth = plot.getXPixelFromX(seriesItems.get(i + 1).getX(), r)
+ - pixelStartX;
}
if (barWidth <= 0) {
barWidth = 1;
}
- if (pixcelStartX < prevEndX) {
- int diff = prevEndX - pixcelStartX;
+ if (pixelStartX < prevEndX) {
+ int diff = prevEndX - pixelStartX;
- pixcelStartX = prevEndX;
+ pixelStartX = prevEndX;
barWidth -= diff;
}
if (barWidth <= 0) {
barWidth = 0;
}
- if (!equals(oldStateContinueRectangle, pixcelStartX, r.y + heightMargin, barWidth,
+ if (!equals(oldStateContinueRectangle, pixelStartX, r.y + heightMargin, barWidth,
r.y + r.height - heightMargin * 2)) {
- oldStateContinueRectangle.x = pixcelStartX;
+ oldStateContinueRectangle.x = pixelStartX;
oldStateContinueRectangle.y = r.y + heightMargin;
oldStateContinueRectangle.width = barWidth;
oldStateContinueRectangle.height = r.y + r.height - heightMargin * 2;
if (null != foreColor) {
gc.setForeground(foreColor);
- gc.fillGradientRectangle(pixcelStartX, r.y + heightMargin, barWidth, r.y
+ gc.fillGradientRectangle(pixelStartX, r.y + heightMargin, barWidth, r.y
+ r.height - heightMargin * 2, true);
} else {
gc.fillRectangle(oldStateContinueRectangle);
}
}
- prevEndX = pixcelStartX + barWidth;
+ prevEndX = pixelStartX + barWidth;
break;
case DAChartSeriesItem.SERIES_STATE_CONNECTION:
if (i + 1 < seriesItemSize) {
- barWidth = plot.getXPixcelFromX(seriesItems.get(i + 1).getX(), r)
- - pixcelStartX;
+ barWidth = plot.getXPixelFromX(seriesItems.get(i + 1).getX(), r)
+ - pixelStartX;
} else {
barWidth = 1;
}
- if (pixcelStartX < prevEndX) {
- int diff = prevEndX - pixcelStartX;
+ if (pixelStartX < prevEndX) {
+ int diff = prevEndX - pixelStartX;
- pixcelStartX = prevEndX;
+ pixelStartX = prevEndX;
barWidth -= diff;
}
if (barWidth < 0) {
barWidth = 0;
}
- if (!equals(oldStateConnectionRectangle, pixcelStartX, r.y + heightMargin,
+ if (!equals(oldStateConnectionRectangle, pixelStartX, r.y + heightMargin,
barWidth, r.y + r.height - heightMargin * 2)) {
- oldStateConnectionRectangle.x = pixcelStartX;
+ oldStateConnectionRectangle.x = pixelStartX;
oldStateConnectionRectangle.y = r.y + heightMargin;
oldStateConnectionRectangle.width = barWidth;
oldStateConnectionRectangle.height = r.y + r.height - heightMargin * 2;
if (null != foreColor) {
gc.setForeground(foreColor);
- gc.fillGradientRectangle(pixcelStartX, r.y + heightMargin, barWidth, r.y
+ gc.fillGradientRectangle(pixelStartX, r.y + heightMargin, barWidth, r.y
+ r.height - heightMargin * 2, true);
} else {
gc.fillRectangle(oldStateConnectionRectangle);
}
}
- prevEndX = pixcelStartX + barWidth;
+ prevEndX = pixelStartX + barWidth;
break;
default:
break;
public static final double ITEM_HEIGHT_RATIO_NORMAL = 1;
protected static final double ITEM_HEIGHT_RATIO_TALL = 2;
private double itemHeightRatio = ITEM_HEIGHT_RATIO_NORMAL;
- private int interval; // count of pixcel implementing 1 second
+ private int interval; // count of pixel implementing 1 second
private int itemHeight = DEFAULT_ITEM_HEIGHT;
/**
* change chart height. charts of DAChartBoard can have different height.
- * If this method is not called, chart height is default size (84pixcel).
+ * If this method is not called, chart height is default size (84pixel).
*
- * @param height pixcel to be changed
+ * @param height pixel to be changed
*/
public void setHeight(int height) {
this.height = height;
for (LifecycleData lifecycleData : cloneList) {
double startTime = lifecycleData.getStartTime();
- int startPx = (int) secondToPixcel(startTime);
+ int startPx = (int) secondToPixel(startTime);
double endTime = lifecycleData.getEndTime();
if (startPx < getClientArea().width) {
}
if (endTime > visibleStartTime) {
- int endPx = (int) secondToPixcel(endTime);
+ int endPx = (int) secondToPixel(endTime);
gc.setBackground(lifecycleData.getColor());
gc.fillRectangle(startPx + 1, 0, endPx
}
public String getTooltipMessage(int x) {
- double time = pixcelToSecond(x);
+ double time = pixelToSecond(x);
int size = lifecycleDataList.size();
if (size == 0
|| (lifecycleDataList.get(0).getStartTime() > time && lifecycleDataList
redraw();
}
- private double secondToPixcel(double second) {
+ private double secondToPixel(double second) {
return (second - visibleStartTime) * scale
* DATimelineRenderer.DEFAULT_INTERVAL;
}
- private double pixcelToSecond(int pixcel) {
- return (double) pixcel / scale / DATimelineRenderer.DEFAULT_INTERVAL
+ private double pixelToSecond(int pixel) {
+ return (double) pixel / scale / DATimelineRenderer.DEFAULT_INTERVAL
+ visibleStartTime;
}
}
return detailedTimePosition;
}
- private double secondToPixcel(double second) {
+ private double secondToPixel(double second) {
return (second - startTime) * scale
* DATimelineRenderer.DEFAULT_INTERVAL;
}
- private double pixcelToSecond(int pixcel) {
- return (double) pixcel / scale / DATimelineRenderer.DEFAULT_INTERVAL
+ private double pixelToSecond(int pixel) {
+ return (double) pixel / scale / DATimelineRenderer.DEFAULT_INTERVAL
+ startTime;
}
} else if (stickyTimeList.size() == 1) {
stickyTime = stickyTimeList.get(0);
} else {
- double eTime = pixcelToSecond(e.x);
+ double eTime = pixelToSecond(e.x);
double minGapTime = stickyTimeList.get(0);
for (int i = 1; i < stickyTimeList.size(); i++) {
stickyTime = minGapTime;
}
- int timePixcel = (int) secondToPixcel(stickyTime);
+ int timePixel = (int) secondToPixel(stickyTime);
- if (e.x - timePixcel < 5 && e.x - timePixcel > -5) {
- e.x = timePixcel;
+ if (e.x - timePixel < 5 && e.x - timePixel > -5) {
+ e.x = timePixel;
}
if (startRangeMarker.isPushed()) {
e.x = 0;
} else if (e.x > DATimeline.this.getBounds().width
- startRangeMarker.getImage().getBounds().width) {
- double endTimePx = secondToPixcel(totalEndTime);
+ double endTimePx = secondToPixel(totalEndTime);
if (e.x > endTimePx) {
e.x = (int) endTimePx;
} else {
- startRangeMarker.getImage().getBounds().width;
}
} else {
- double endTimePx = secondToPixcel(totalEndTime);
+ double endTimePx = secondToPixel(totalEndTime);
if (e.x > endTimePx) {
e.x = (int) endTimePx;
}
}
- double movedTime = pixcelToSecond(e.x);
+ double movedTime = pixelToSecond(e.x);
startRangeMarker.setTime(movedTime);
DATimeline.this.redraw();
} else if (endRangeMarker.isPushed()) {
if (e.x < 0 + endRangeMarker.getImage().getBounds().width) {
e.x = endRangeMarker.getImage().getBounds().width;
} else if (e.x > DATimeline.this.getBounds().width) {
- double endTimePx = secondToPixcel(totalEndTime);
+ double endTimePx = secondToPixel(totalEndTime);
if (e.x > endTimePx) {
e.x = (int) endTimePx;
} else {
e.x = DATimeline.this.getBounds().width;
}
} else {
- double endTimePx = secondToPixcel(totalEndTime);
+ double endTimePx = secondToPixel(totalEndTime);
if (e.x > endTimePx) {
e.x = (int) endTimePx;
}
}
- double movedTime = pixcelToSecond(e.x);
+ double movedTime = pixelToSecond(e.x);
endRangeMarker.setTime(movedTime);
DATimeline.this.redraw();
}
}
private void setStatusInMarkerImage(int x, int y, MARKER_STATUS status) {
- double startMarkerPosition = secondToPixcel(startRangeMarker
+ double startMarkerPosition = secondToPixel(startRangeMarker
.getTime());
- double endMarkerPosition = secondToPixcel(endRangeMarker.getTime());
+ double endMarkerPosition = secondToPixel(endRangeMarker.getTime());
// it's means that mouse pointer is in range of end marker image.
if (x >= endMarkerPosition -
private final int balloonHalfWidth = balloon.getBounds().width / 2;
private final int balloonHalfHeight = balloon.getBounds().height / 2;
- protected static final int TIME_STRING_PIXCEL_Y = 4;
- protected static final int TIME_BALLOON_PIXCEL_Y = 18;
+ protected static final int TIME_STRING_PIXEL_Y = 4;
+ protected static final int TIME_BALLOON_PIXEL_Y = 18;
- private void drawTimeString(GC gc, int totalSecond, int pixcelX, int pixcelY) {
+ private void drawTimeString(GC gc, int totalSecond, int pixelX, int pixelY) {
Point p;
String timeString = String.valueOf(totalSecond);
p = gc.textExtent(timeString, SWT.DRAW_MNEMONIC);
gc.setForeground(ColorResources.TIMELINE_NUMBER_COLOR);
- gc.drawText(timeString, pixcelX - p.x / 2, pixcelY, true);
+ gc.drawText(timeString, pixelX - p.x / 2, pixelY, true);
gc.setForeground(ColorResources.TIMELINE_TICK_COLOR);
}
int current = DRAW_FRAME_INTERVAL - (startFrame % DRAW_FRAME_INTERVAL);
current %= 10;
startMargin -= startFrame;
- int pixcelX = (int) ((current-startMargin) * frameInterval);
+ int pixelX = (int) ((current-startMargin) * frameInterval);
- for (; pixcelX < rt.width; current+=DRAW_FRAME_INTERVAL){
- pixcelX = (int) ((current-startMargin) * frameInterval);
- gc.drawLine(pixcelX, rt.height - 5, pixcelX, rt.height - 1);
+ for (; pixelX < rt.width; current+=DRAW_FRAME_INTERVAL){
+ pixelX = (int) ((current-startMargin) * frameInterval);
+ gc.drawLine(pixelX, rt.height - 5, pixelX, rt.height - 1);
if (scale >= DATimeline.SCALE_800) {
- drawTimeString(gc, current+startFrame, pixcelX, TIME_STRING_PIXCEL_Y);
+ drawTimeString(gc, current+startFrame, pixelX, TIME_STRING_PIXEL_Y);
}else if (scale >= DATimeline.SCALE_400) {
if((current+startFrame) % (DRAW_FRAME_INTERVAL*2) == 0){
- drawTimeString(gc, current+startFrame, pixcelX, TIME_STRING_PIXCEL_Y);
+ drawTimeString(gc, current+startFrame, pixelX, TIME_STRING_PIXEL_Y);
}
}else{
if((current+startFrame) % (DRAW_FRAME_INTERVAL*5) == 0){
- drawTimeString(gc, current+startFrame, pixcelX, TIME_STRING_PIXCEL_Y);
+ drawTimeString(gc, current+startFrame, pixelX, TIME_STRING_PIXEL_Y);
}
}
}
gc.drawImage(balloon, 0, 0, balloon.getBounds().width,
balloon.getBounds().height,
timeline.getDetailedTimePosition() - balloonHalfWidth, 2,
- balloon.getBounds().width, TIME_BALLOON_PIXCEL_Y);
+ balloon.getBounds().width, TIME_BALLOON_PIXEL_Y);
String time = String.valueOf((int)timeline.getDetailedTime());
gc.setForeground(ColorResources.BLACK);
gc.drawString(time,
timeline.getDetailedTimePosition()
- gc.stringExtent(time).x / 2,
- TIME_STRING_PIXCEL_Y, true);
+ TIME_STRING_PIXEL_Y, true);
}
}
}
protected static final int TICK_LINE_HEIGHT_TALL = 4;
protected static final int TICK_LINE_HEIGHT_SMALL = 2;
- protected static final int TIME_STRING_PIXCEL_Y = 4;
+ protected static final int TIME_STRING_PIXEL_Y = 4;
protected static final int MARKER_START_Y = 3;
protected int startTime;
double startMarkerTime = startMarker.getTime()
- timeline.getStartTime();
- int pixcelStartX = (int) Math.round(startMarkerTime * scale
+ int pixelStartX = (int) Math.round(startMarkerTime * scale
* DEFAULT_INTERVAL) - startMarkerImage.getBounds().width / 2;
- gc.drawImage(startMarkerImage, pixcelStartX, MARKER_START_Y);
+ gc.drawImage(startMarkerImage, pixelStartX, MARKER_START_Y);
}
if (endMarker.getTime() >= 0) {
double endMarkerTime = endMarker.getTime()
- timeline.getStartTime();
- int pixcelEndX = (int) Math.round(endMarkerTime * scale
+ int pixelEndX = (int) Math.round(endMarkerTime * scale
* DEFAULT_INTERVAL);
- gc.drawImage(endMarker.getImage(), pixcelEndX
+ gc.drawImage(endMarker.getImage(), pixelEndX
- endMarker.getImage().getBounds().width / 2, MARKER_START_Y);
}
}
- protected void drawTimeString(GC gc, int totalSecond, int pixcelX, int pixcelY) {
+ protected void drawTimeString(GC gc, int totalSecond, int pixelX, int pixelY) {
Point p;
String timeString = Formatter.toTimelineFormat(totalSecond);
p = gc.textExtent(timeString, SWT.DRAW_MNEMONIC);
gc.setForeground(ColorResources.TIMELINE_NUMBER_COLOR);
- gc.drawText(timeString, pixcelX - p.x / 2, pixcelY, true);
+ gc.drawText(timeString, pixelX - p.x / 2, pixelY, true);
gc.setForeground(ColorResources.TIMELINE_TICK_COLOR);
}
gc.drawLine(0, rt.height - 1, rt.width, rt.height - 1);
// draw time
- int pixcelX = 0;
+ int pixelX = 0;
scale = timeline.getScale();
int secondInterval = scale * DEFAULT_INTERVAL;
startTime = (int) timeline.getStartTime();
- pixcelX -= (timeline.getStartTime() - (double) startTime)
+ pixelX -= (timeline.getStartTime() - (double) startTime)
* ((double) secondInterval);
- for (; pixcelX < rt.width; startTime++, pixcelX += secondInterval) {
+ for (; pixelX < rt.width; startTime++, pixelX += secondInterval) {
if (startTime % 10 == 0) {
- drawTimeString(gc, startTime, pixcelX, TIME_STRING_PIXCEL_Y);
- gc.drawLine(pixcelX, rt.height - TICK_LINE_HEIGHT_TALL,
- pixcelX, rt.height - 1);
+ drawTimeString(gc, startTime, pixelX, TIME_STRING_PIXEL_Y);
+ gc.drawLine(pixelX, rt.height - TICK_LINE_HEIGHT_TALL,
+ pixelX, rt.height - 1);
} else if (startTime % 5 == 0) {
if (scale >= DATimeline.SCALE_400) {
- drawTimeString(gc, startTime, pixcelX, TIME_STRING_PIXCEL_Y);
+ drawTimeString(gc, startTime, pixelX, TIME_STRING_PIXEL_Y);
}
- gc.drawLine(pixcelX, rt.height - TICK_LINE_HEIGHT_TALL, pixcelX,
+ gc.drawLine(pixelX, rt.height - TICK_LINE_HEIGHT_TALL, pixelX,
rt.height - 1);
} else {
if (scale >= DATimeline.SCALE_800) {
- drawTimeString(gc, startTime, pixcelX, TIME_STRING_PIXCEL_Y);
+ drawTimeString(gc, startTime, pixelX, TIME_STRING_PIXEL_Y);
}
- gc.drawLine(pixcelX, rt.height - TICK_LINE_HEIGHT_SMALL,
- pixcelX, rt.height - 1);
+ gc.drawLine(pixelX, rt.height - TICK_LINE_HEIGHT_SMALL,
+ pixelX, rt.height - 1);
}
}
public class DATimelineTinyTimeRenderer extends DATimelineTimeRenderer {
private static final int MAX_STRING_GAP = 200;
private static final int MIN_STRING_GAP = 40;
- protected static final int TIME_STRING_PIXCEL_Y = 4;
+ protected static final int TIME_STRING_PIXEL_Y = 4;
@Override
public void draw(GC gc, DATimeline timeline) {
gc.drawLine(0, rt.height - 1, rt.width, rt.height - 1);
// draw time
- int pixcelX = 0;
+ int pixelX = 0;
scale = timeline.getScale();
double oneSecondInterval = scale * DEFAULT_INTERVAL;
double startTime = timeline.getStartTime();
double firstTime = timeInterval.doubleValue()
* ((int) (startTime / timeInterval.doubleValue()));
- pixcelX = (int) (oneSecondInterval * (firstTime - startTime));
+ pixelX = (int) (oneSecondInterval * (firstTime - startTime));
- for (; pixcelX < rt.width; firstTime = new BigDecimal(
- String.valueOf(firstTime)).add(timeInterval).doubleValue(), pixcelX += STRING_GAP) {
- gc.drawLine(pixcelX, rt.height - TICK_LINE_HEIGHT_TALL, pixcelX,
+ for (; pixelX < rt.width; firstTime = new BigDecimal(
+ String.valueOf(firstTime)).add(timeInterval).doubleValue(), pixelX += STRING_GAP) {
+ gc.drawLine(pixelX, rt.height - TICK_LINE_HEIGHT_TALL, pixelX,
rt.height - 1);
String timeString = null;
Point p;
p = gc.textExtent(timeString, SWT.DRAW_MNEMONIC);
gc.setForeground(ColorResources.TIMELINE_NUMBER_COLOR);
- gc.drawText(timeString, pixcelX - p.x / 2, TIME_STRING_PIXCEL_Y, true);
+ gc.drawText(timeString, pixelX - p.x / 2, TIME_STRING_PIXEL_Y, true);
gc.setForeground(ColorResources.TIMELINE_TICK_COLOR);
}
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
if (e.button == 3) {
List<DAPopupMenuItem> itemList = menu.getItems();
DAChartSeriesItem item = series.getSeriesItemList().get(index);
double itemTime = item.getX();
int imageWidth = item.getImage().getBounds().width;
- double imageRightTime = itemTime + plot.getXFromXPixcel(imageWidth)
+ double imageRightTime = itemTime + plot.getXFromXPixel(imageWidth)
- plot.getVisibleStartX();
if (eventTime > itemTime && eventTime < imageRightTime) {
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
double markerStartTime;
double markerEndTime;
if (plot instanceof DAScreenshotChartPlot) {
DAChartSeries series = chart.getSeries(0);
if (series != null) {
- int index = series.getPrevIndexByXvalue(plot.getXFromXPixcel(e.x));
+ int index = series.getPrevIndexByXvalue(plot.getXFromXPixel(e.x));
if (index >= 0 && index < series.getSeriesItemList().size()) {
DAChartSeriesItem item = series.getSeriesItemList().get(index);
double itemTime = item.getX();
int imageWidth = item.getImage().getBounds().width;
- double imageRightTime = itemTime + plot.getXFromXPixcel(imageWidth)
+ double imageRightTime = itemTime + plot.getXFromXPixel(imageWidth)
- plot.getVisibleStartX();
if (markerEndTime > itemTime && markerEndTime < imageRightTime) {
DAChartPlotTooltip tooltip;
if ((e.stateMask & SWT.BUTTON1) != 0) {
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
if (baseTime > eventTime) {
intervalMarker.setInterval(eventTime, baseTime);
int seriesIndex = (int) (newYPosRatio * chart.getSeriesList().size());
uiEventChartPlot.setHighlightedEventIndexX(chart.getSeriesList().get(seriesIndex)
- .getPrevIndexByXvalue(plot.getXFromXPixcel(e.x)));
+ .getPrevIndexByXvalue(plot.getXFromXPixel(e.x)));
uiEventChartPlot.setHighlightedEventIndexY(seriesIndex);
chart.redraw();
}
- timeline.setDetailTime(plot.getXFromXPixcel(e.x));
+ timeline.setDetailTime(plot.getXFromXPixel(e.x));
timeline.setDetailTimePosition(e.x);
timeline.setDrawDetailTime(true);
timeline.redraw();
if (plot instanceof DAScreenshotChartPlot) {
DAChartSeries series = seriesList.get(0);
- return series.getPrevIndexByXvalue(plot.getXFromXPixcel(x));
+ return series.getPrevIndexByXvalue(plot.getXFromXPixel(x));
} else {
return TimelineConstants.NOT_INITED;
}
i = (int) (seriesList.size() * yPosRatio);
}
DAChartSeries series = seriesList.get(i);
- int index = series.getPrevIndexByXvalue(plot.getXFromXPixcel(x));
+ int index = series.getPrevIndexByXvalue(plot.getXFromXPixel(x));
if (-1 == index) {
if (plot instanceof DAUIEventChartPlot) {
break;
DAChartPlot plot = chart.getPlot();
DAChartSeries series = chart.getSeriesList().get(0);
- int index = series.getPrevIndexByXvalue(plot.getXFromXPixcel(e.x));
+ int index = series.getPrevIndexByXvalue(plot.getXFromXPixel(e.x));
if (index < 0) {
return -1;
}
screenshotWidth /= 2;
}
- if (e.x < plot.getXPixcelFromX(item.getX()) + screenshotWidth
- && e.x >= plot.getXPixcelFromX(item.getX())) {
+ if (e.x < plot.getXPixelFromX(item.getX()) + screenshotWidth
+ && e.x >= plot.getXPixelFromX(item.getX())) {
return index;
} else {
return -1;
}
}
DAChartSeries series = seriesList.get(i);
- int index = series.getPrevIndexByXvalue(plot.getXFromXPixcel(x));
+ int index = series.getPrevIndexByXvalue(plot.getXFromXPixel(x));
if (-1 == index) {
if (plot instanceof DAUIEventChartPlot) {
break;
*/
int margin = (int) ((r.height * (MARGIN_PERCENT / 100.0)) / (seriesSize + 1));
int areaHeight = (r.height - margin * (seriesSize + 1)) / seriesSize;
- int pixcelStartY = (margin * (seriesIndex + 1)) + (areaHeight * seriesIndex);
+ int pixelStartY = (margin * (seriesIndex + 1)) + (areaHeight * seriesIndex);
List<DAChartSeriesItem> barSeriesItems = new ArrayList<DAChartSeriesItem>();
/*
gc.setForeground(foreGroundColor);
gc.setBackground(backGroundcolor);
- int pixcelStartX = plot.getXPixcelFromX(seriesItem.getX(), r);
- int pixcelWidth;
+ int pixelStartX = plot.getXPixelFromX(seriesItem.getX(), r);
+ int pixelWidth;
if (endSeriesItem != null) {
- pixcelWidth = plot.getXPixcelFromX(endSeriesItem.getX(), r) - pixcelStartX;
+ pixelWidth = plot.getXPixelFromX(endSeriesItem.getX(), r) - pixelStartX;
} else {
/*
* endSeriesItem is null when end series is not exist. this
* case, draw it as much as getValidEndX.
*/
- pixcelWidth = plot.getXPixcelFromX(plot.getValidEndX(), r) - pixcelStartX;
+ pixelWidth = plot.getXPixelFromX(plot.getValidEndX(), r) - pixelStartX;
}
- if (pixcelWidth == 0) { // If diffence is less than 1 second.
- // draw 1 pixcel force.
- pixcelWidth = 1;
+ if (pixelWidth == 0) { // If diffence is less than 1 second.
+ // draw 1 pixel force.
+ pixelWidth = 1;
}
- gc.fillRectangle(pixcelStartX, pixcelStartY, pixcelWidth, areaHeight);
+ gc.fillRectangle(pixelStartX, pixelStartY, pixelWidth, areaHeight);
/*
* If it's needed, draw diagonal line. diagonal line is composed
gc.setForeground(DIAGONAL_BOX_COLOR);
gc.setBackground(DIAGONAL_BOX_COLOR);
for (int j = 0; j < 16; j++) {
- int boxY = pixcelStartY + (diagonalBoxSize * j);
+ int boxY = pixelStartY + (diagonalBoxSize * j);
// Formula to draw diagonal line like "/"
- for (int k = 3 - (j % 4) - (j / 4); k < pixcelWidth; k = k + 3) {
- int boxX = diagonalBoxSize * k + pixcelStartX;
- if (pixcelStartX <= boxX && boxX <= pixcelWidth + pixcelStartX - diagonalBoxSize) {
+ for (int k = 3 - (j % 4) - (j / 4); k < pixelWidth; k = k + 3) {
+ int boxX = diagonalBoxSize * k + pixelStartX;
+ if (pixelStartX <= boxX && boxX <= pixelWidth + pixelStartX - diagonalBoxSize) {
gc.fillRectangle(boxX, boxY, diagonalBoxSize, diagonalBoxSize);
}
}
Color backGroundcolor = barSeriesItem.getColor();
gc.setForeground(foreGroundColor);
gc.setBackground(backGroundcolor);
- int pixcelStartX = plot.getXPixcelFromX(barSeriesItem.getX(), r);
- gc.fillRectangle(pixcelStartX, pixcelStartY, STATE_AREA_BAR_WIDTH, areaHeight);
+ int pixelStartX = plot.getXPixelFromX(barSeriesItem.getX(), r);
+ gc.fillRectangle(pixelStartX, pixelStartY, STATE_AREA_BAR_WIDTH, areaHeight);
}
}
gc.setForeground(tooltip.getLineColor());
gc.setLineStyle(SWT.LINE_DOT);
gc.setLineWidth(1);
- gc.drawLine(plot.getXPixcelFromX(xVal), 0, plot.getXPixcelFromX(xVal), r.height);
+ gc.drawLine(plot.getXPixelFromX(xVal), 0, plot.getXPixelFromX(xVal), r.height);
gc.setLineStyle(SWT.LINE_CUSTOM);
// event color
endX = plot.getValidEndX();
}
- int pixcelX = plot.getXPixcelFromX(x, r);
- int pixcelEndX = plot.getXPixcelFromX(endX, r);
+ int pixelX = plot.getXPixelFromX(x, r);
+ int pixelEndX = plot.getXPixelFromX(endX, r);
gc.setBackground(seriesColor);
if (seriesItem.getColor() != null) {
}
Color boarderColor = seriesItem.getBorderColor();
- int leftX = pixcelX + ARC;
- int rightX = pixcelEndX - ARC;
+ int leftX = pixelX + ARC;
+ int rightX = pixelEndX - ARC;
int upperY = rect.y + (int) Math.round((rect.height * 0.1));
int underY = rect.y + (int) Math.round((rect.height * 0.9));
int[] points;
leftX = leftX - gap / 2;
rightX = rightX + gap / 2;
}
- points = new int[] { leftX, upperY, pixcelX, upperY + ARC, pixcelX,
- underY - ARC, leftX, underY, rightX, underY, pixcelEndX,
- underY - ARC, pixcelEndX, upperY + ARC, rightX, upperY };
+ points = new int[] { leftX, upperY, pixelX, upperY + ARC, pixelX,
+ underY - ARC, leftX, underY, rightX, underY, pixelEndX,
+ underY - ARC, pixelEndX, upperY + ARC, rightX, upperY };
gc.fillPolygon(points);
if (boarderColor != null) {
}
break;
case ContextSwitchingChartSeriesItem.STYLE_OCTAGON_LEFT_ONLY:
- if (leftX > pixcelEndX) {
- int gap = leftX - pixcelEndX;
+ if (leftX > pixelEndX) {
+ int gap = leftX - pixelEndX;
leftX = leftX - gap;
}
- points = new int[] { leftX, upperY, pixcelX, upperY + ARC, pixcelX,
- underY - ARC, leftX, underY, pixcelEndX, underY,
- pixcelEndX, upperY, };
+ points = new int[] { leftX, upperY, pixelX, upperY + ARC, pixelX,
+ underY - ARC, leftX, underY, pixelEndX, underY,
+ pixelEndX, upperY, };
gc.fillPolygon(points);
if (boarderColor != null) {
}
break;
case ContextSwitchingChartSeriesItem.STYLE_OCTAGON_RIGHT_ONLY:
- if (rightX < pixcelX) {
- int gap = pixcelX - rightX;
+ if (rightX < pixelX) {
+ int gap = pixelX - rightX;
rightX = rightX + gap;
}
- points = new int[] { pixcelX, upperY, pixcelX, underY, rightX,
- underY, pixcelEndX, underY - ARC, pixcelEndX, upperY + ARC,
+ points = new int[] { pixelX, upperY, pixelX, underY, rightX,
+ underY, pixelEndX, underY - ARC, pixelEndX, upperY + ARC,
rightX, upperY };
gc.fillPolygon(points);
break;
case ContextSwitchingChartSeriesItem.STYLE_SQUARE:
default:
- gc.fillRectangle(pixcelX, rect.y + (int) (rect.height * 0.1),
- pixcelEndX - pixcelX, (int) (rect.height * 0.8));
+ gc.fillRectangle(pixelX, rect.y + (int) (rect.height * 0.1),
+ pixelEndX - pixelX, (int) (rect.height * 0.8));
if (boarderColor != null) {
gc.setForeground(boarderColor);
- gc.drawRectangle(pixcelX, rect.y + (int) (rect.height * 0.1),
- pixcelEndX - pixcelX, (int) (rect.height * 0.8));
+ gc.drawRectangle(pixelX, rect.y + (int) (rect.height * 0.1),
+ pixelEndX - pixelX, (int) (rect.height * 0.8));
}
break;
}
String name = seriesItem.getName();
if (name != null) {
int extentX = gc.stringExtent(name).x;
- if (extentX < pixcelEndX - pixcelX) {
+ if (extentX < pixelEndX - pixelX) {
gc.setForeground(ColorResources.BLACK);
- gc.drawText(name, (pixcelEndX + pixcelX) / 2 - extentX / 2,
+ gc.drawText(name, (pixelEndX + pixelX) / 2 - extentX / 2,
rect.y + rect.height / 2 - gc.stringExtent(name).y / 2,
true);
}
return;
}
- int pixcelEndX = plot.getXPixcelFromX(seriesItem.getEndX(), r);
+ int pixelEndX = plot.getXPixelFromX(seriesItem.getEndX(), r);
int arrow = seriesItem.getArrow();
if (arrow != 0) {
gc.setForeground(seriesItem.getBorderColor());
}
int arrowHeadY = rect.y + rect.height / 2 + rect.height * arrow;
- gc.drawLine(pixcelEndX, rect.y + rect.height / 2, pixcelEndX,
+ gc.drawLine(pixelEndX, rect.y + rect.height / 2, pixelEndX,
arrowHeadY);
int y = -5;
if (arrow < 0) {
y = 5;
}
- gc.drawLine(pixcelEndX, arrowHeadY, pixcelEndX - 3, arrowHeadY
+ gc.drawLine(pixelEndX, arrowHeadY, pixelEndX - 3, arrowHeadY
+ y);
- gc.drawLine(pixcelEndX, arrowHeadY, pixcelEndX + 3, arrowHeadY
+ gc.drawLine(pixelEndX, arrowHeadY, pixelEndX + 3, arrowHeadY
+ y);
}
}
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
double markerStartTime;
double markerEndTime;
int frame = (int) eventTime;
DAChartPlotTooltip tooltip;
if ((e.stateMask & SWT.BUTTON1) != 0) {
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
if (baseTime > eventTime) {
intervalMarker.setInterval(eventTime, baseTime);
tooltip.setStartVal(newStartVal);
}
- timeline.setDetailTime(plot.getXFromXPixcel(e.x));
+ timeline.setDetailTime(plot.getXFromXPixel(e.x));
timeline.setDetailTimePosition(e.x);
timeline.setDrawDetailTime(true);
timeline.redraw();
double ret = -1;
for (int i = 0; i < seriesList.size(); i++) {
DAChartSeries series = seriesList.get(i);
- int index = series.getPrevIndexByXvalue(plot.getXFromXPixcel(x));
+ int index = series.getPrevIndexByXvalue(plot.getXFromXPixel(x));
if (-1 == index) {
if (plot instanceof DAUIEventChartPlot) {
break;
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
if (e.button == 3) {
List<DAPopupMenuItem> itemList = menu.getItems();
chart.redraw();
clickChartIndex = chart.getSeriesList().get(0)
- .getPrevIndexByXvalue(plot.getXFromXPixcel(e.x));
+ .getPrevIndexByXvalue(plot.getXFromXPixel(e.x));
if (clickChartIndex < 0) {
return;
}
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventFrameIndex = plot.getXFromXPixcel(e.x);
+ double eventFrameIndex = plot.getXFromXPixel(e.x);
double markerStartVal;
double markerEndVal;
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventTime = plot.getXFromXPixcel(e.x);
+ double eventTime = plot.getXFromXPixel(e.x);
boolean bShift = false;
if ((e.stateMask & SWT.SHIFT) != 0) {
chart.redraw();
clickChartIndex = chart.getSeriesList().get(0)
- .getPrevIndexByXvalue(plot.getXFromXPixcel(e.x));
+ .getPrevIndexByXvalue(plot.getXFromXPixel(e.x));
if (clickChartIndex < 0) {
return;
}
}
DAChartPlotIntervalMarker intervalMarker = (DAChartPlotIntervalMarker) marker;
- double eventFrameIndex = plot.getXFromXPixcel(e.x);
+ double eventFrameIndex = plot.getXFromXPixel(e.x);
double markerStartVal;
double markerEndVal;
public void drawCreateLine(GC gc, DAChart chart, ThreadPageThreadData selectedData) {
Rectangle r = chart.getClientArea();
double start = (double) selectedData.getStartTime() / TimelineConstants.MEGA_DOUBLE;
- int startTime = plot.getXPixcelFromX(start);
+ int startTime = plot.getXPixelFromX(start);
gc.setForeground(ColorResources.RED);
gc.setAlpha(150);
gc.setLineWidth(2);
public void drawJoinLine(GC gc, DAChart chart, ThreadPageThreadData selectedData) {
Rectangle r = chart.getClientArea();
double end = (double) selectedData.getEndTime() / TimelineConstants.MEGA_DOUBLE;
- int endTime = plot.getXPixcelFromX(end);
+ int endTime = plot.getXPixelFromX(end);
gc.setForeground(ColorResources.RED);
gc.setAlpha(150);
gc.setLineWidth(2);
}
DAChartSeriesItem seriesItem;
- int newPixcelX = 0;
+ int newPixelX = 0;
double newY = 0;
if (index > 0) {
seriesItem = seriesItems.get(index - 1);
- newPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ newPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
newY = seriesItem.getY();
}
gc.setForeground(series.getColor());
for (int i = index; i < seriesItemSize; i++) {
- int oldPixcelX = newPixcelX;
+ int oldPixelX = newPixelX;
double oldY = newY;
seriesItem = seriesItems.get(i);
double x = seriesItem.getX();
- newPixcelX = plot.getXPixcelFromX(x, r);
+ newPixelX = plot.getXPixelFromX(x, r);
newY = seriesItem.getY();
if (seriesItem.getColor() != null) {
}
if (oldY != newY) {
- gc.drawLine(oldPixcelX, (int) (rect.y + rect.height
- * (1.0 - (oldY / states[seriesIndex]))), oldPixcelX,
+ gc.drawLine(oldPixelX, (int) (rect.y + rect.height
+ * (1.0 - (oldY / states[seriesIndex]))), oldPixelX,
(int) (rect.y + rect.height
* (1.0 - (newY / states[seriesIndex]))));
oldY = newY;
}
- gc.drawLine(oldPixcelX, (int) (rect.y + rect.height
- * (1.0 - (oldY / states[seriesIndex]))), newPixcelX,
+ gc.drawLine(oldPixelX, (int) (rect.y + rect.height
+ * (1.0 - (oldY / states[seriesIndex]))), newPixelX,
(int) (rect.y + rect.height
* (1.0 - (newY / states[seriesIndex]))));
if (x > plot.getVisibleEndX()) {
DAChartSeriesItem seriesItem = seriesItems.get(0);
double maxY = series.getEndY();
- int oldPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int oldPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
if (seriesItemSize == 1) {
- if (oldPixcelX < r.x) {
+ if (oldPixelX < r.x) {
return;
}
Color color = seriesItem.getColor();
color = series.getColor();
}
gc.setForeground(color);
- gc.drawPoint(oldPixcelX,
- plot.getYPixcelFromY(maxY, seriesItem.getY(), r));
+ gc.drawPoint(oldPixelX,
+ plot.getYPixelFromY(maxY, seriesItem.getY(), r));
return;
}
seriesItem = seriesItems.get(index);
double currentX = seriesItem.getX();
- int newPixcelX = plot.getXPixcelFromX(currentX, r);
+ int newPixelX = plot.getXPixelFromX(currentX, r);
double newY = seriesItem.getY();
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
currentX = seriesItem.getX();
- oldPixcelX = newPixcelX;
+ oldPixelX = newPixelX;
- newPixcelX = plot.getXPixcelFromX(currentX, r);
+ newPixelX = plot.getXPixelFromX(currentX, r);
newY = seriesItem.getY();
gc.setForeground(series.getColor());
gc.setBackground(series.getColor());
int startY = rect.y + rect.height;
- int widthPixcel = 2;
+ int widthPixel = 2;
- int[] barPointArray = {newPixcelX, startY,
- newPixcelX + widthPixcel, startY,
- newPixcelX + widthPixcel, (int) (rect.y + rect.height * (1.0 - (newY / maxY))),
- newPixcelX, (int) (rect.y + rect.height * (1.0 - (newY / maxY)))};
+ int[] barPointArray = {newPixelX, startY,
+ newPixelX + widthPixel, startY,
+ newPixelX + widthPixel, (int) (rect.y + rect.height * (1.0 - (newY / maxY))),
+ newPixelX, (int) (rect.y + rect.height * (1.0 - (newY / maxY)))};
gc.fillPolygon(barPointArray);
if (currentX > plot.getVisibleEndX()) {
gc.setLineStyle(SWT.LINE_DOT);
gc.setLineWidth(1);
- gc.drawLine(plot.getXPixcelFromX(xVal), 0,
- plot.getXPixcelFromX(xVal), r.height);
+ gc.drawLine(plot.getXPixelFromX(xVal), 0,
+ plot.getXPixelFromX(xVal), r.height);
gc.setLineStyle(SWT.LINE_CUSTOM);
// event color
DAChartSeriesItem seriesItem = seriesItems.get(0);
double maxY = getMaxYToDraw(series, index);
- int oldPixcelX = plot.getXPixcelFromX(seriesItem.getX(), r);
+ int oldPixelX = plot.getXPixelFromX(seriesItem.getX(), r);
double oldY = seriesItem.getY();
if (seriesItemSize == 1) {
- if (oldPixcelX < r.x) {
+ if (oldPixelX < r.x) {
return;
}
Color color = seriesItem.getColor();
color = series.getColor();
}
gc.setForeground(color);
- gc.drawPoint(oldPixcelX,
- plot.getYPixcelFromY(maxY, seriesItem.getY(), r));
+ gc.drawPoint(oldPixelX,
+ plot.getYPixelFromY(maxY, seriesItem.getY(), r));
return;
}
seriesItem = seriesItems.get(index);
double currentX = seriesItem.getX();
- int newPixcelX = plot.getXPixcelFromX(currentX, r);
+ int newPixelX = plot.getXPixelFromX(currentX, r);
double newY = seriesItem.getY();
for (int i = index; i < seriesItemSize; i++) {
seriesItem = seriesItems.get(i);
currentX = seriesItem.getX();
- oldPixcelX = newPixcelX;
+ oldPixelX = newPixelX;
oldY = newY;
- newPixcelX = plot.getXPixcelFromX(currentX, r);
+ newPixelX = plot.getXPixelFromX(currentX, r);
newY = seriesItem.getY();
- gc.drawLine(oldPixcelX, (int) (rect.y + rect.height
- * (1.0 - (oldY / maxY))), newPixcelX,
+ gc.drawLine(oldPixelX, (int) (rect.y + rect.height
+ * (1.0 - (oldY / maxY))), newPixelX,
(int) (rect.y + rect.height * (1.0 - (newY / maxY))));
if (currentX > plot.getVisibleEndX()) {
return;
gc.setLineStyle(SWT.LINE_DOT);
gc.setLineWidth(1);
- gc.drawLine(plot.getXPixcelFromX(xVal), 0,
- plot.getXPixcelFromX(xVal), r.height);
+ gc.drawLine(plot.getXPixelFromX(xVal), 0,
+ plot.getXPixelFromX(xVal), r.height);
gc.setLineStyle(SWT.LINE_CUSTOM);
// event color
projects / sdk / tools / dynamic-analyzer.git / commitdiff