public static final int TOOLTIP_HEIGHT = 18;
public static final int TOOLTIP_SERIES_RECT_LENGTH = 10;
public static final int TOOLTIP_SHOW_MIN = 50;
- private boolean bTooltip = false;
+ private boolean drawTooltip = false;
private double startVal;
private double yPosRatio;
private Color backgroundColor;
public void setBackgroundColor(Color backgroundColor) {
this.backgroundColor = backgroundColor;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setForegroundColor(Color foregroundColor) {
this.foregroundColor = foregroundColor;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setLineColor(Color lineColor) {
this.lineColor = lineColor;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setTextColor(Color textColor) {
this.textColor = textColor;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setTimeColor(Color timeColor) {
this.timeColor = timeColor;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setFont(Font font) {
this.font = font;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setStartVal(double startVal) {
this.startVal = startVal;
- if(true == bTooltip){
+ if(true == drawTooltip){
redrawRegisteredChart();
}
}
public void setYPosRatio(double yPosRatio) {
this.yPosRatio = yPosRatio;
- if(true == bTooltip) {
+ if(true == drawTooltip) {
redrawRegisteredChart();
}
}
- public boolean isTooltip() {
- return bTooltip;
+ public boolean shouldBeDrawn() {
+ return drawTooltip;
}
public void setTooltip(boolean show) {
- this.bTooltip = show;
+ this.drawTooltip = show;
redrawRegisteredChart();
}
}
}
}
- public void draw(GC gc, DAChart chart) {
- drawToGc(gc, chart);
- if (r.height > DAChartPlotTooltip.TOOLTIP_SHOW_MIN) {
- drawTooltip(gc);
- }
- drawRange(gc);
- }
-
public void drawBuffer(Image buffer, DAChart chart) {
GC bufGc = new GC(buffer);
drawToGc(bufGc, chart);
}
DAChartPlotTooltip tooltip = plot.getTooltip();
- if (null == tooltip || false == tooltip.isTooltip()
- || -1 == tooltip.getStartVal()) {
+ if (tooltip == null || tooltip.shouldBeDrawn() == false
+ || tooltip.getStartVal() == -1) {
return;
}
Rectangle rect = new Rectangle(r.x, r.y
+ (r.height / seriesSize * seriesIndex), r.width, r.height
/ seriesSize);
- if (r.height == DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT - 1) {
+ if (r.height == DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
gc.setForeground(ColorResources.UI_EVENT_CHART_TEXT);
Font tempFont = gc.getFont();
Font multiCheckBarFont = series.getFont();
int pixcelStartX = plot.getXPixcelFromX(currentX, r);
Image image = seriesItem.getImage();
int yPosition = (int) seriesItem.getY();
- if (r.height != DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT - 1) {
+ if (r.height != DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
image = new Image(Display.getDefault(), image.getImageData()
.scaledTo(image.getBounds().width / 2,
image.getBounds().height / 2));
Image selectedImage = seriesItem.getImage();
int yPosition = (int) seriesItem.getY();
int highlightedYPosition = SCREENSHOT_SELECTED_Y_POSITION;
- if (r.height != DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT - 1) {
+ if (r.height != DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
selectedImage = new Image(Display.getDefault(), selectedImage
.getImageData().scaledTo(
selectedImage.getBounds().width / 2,
.get(highlightedImageIndex);
Image highlightedImage = seriesItem.getImage();
int highlightedYPosition = SCREENSHOT_SELECTED_Y_POSITION;
- if (r.height != DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT - 1) {
+ if (r.height != DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
highlightedImage = new Image(Display.getDefault(),
highlightedImage.getImageData().scaledTo(
highlightedImage.getBounds().width / 2,
DAChartPlotTooltip tooltip = tooltipInfo.chart.getPlot().getTooltip();
List<DAChartSeries> seriesList = tooltipInfo.chart.getSeriesList();
- if (null == tooltip || false == tooltip.isTooltip()
+ if (null == tooltip || false == tooltip.shouldBeDrawn()
|| -1 == tooltip.getStartVal()) {
return;
}
// private DACustomButton titleButton;
private Composite titleComp;
- private DACustomToggleButton chartZoomButton;
+ private DACustomToggleButton itemCollapseButton;
private DATimeline timeline;
private LifecycleBar lifecycleBar;
private DefaultToolTip lifecycleBarTooltip;
private Font nameFont;
// private final static int DEFAULT_CHART_ZOOMOUT_HEIGHT = 50;
- public final static int DEFAULT_CHART_ZOOMIN_HEIGHT = 80;
+ public final static int DEFAULT_ITEM_HEIGHT = 80;
private final static int DEFAULT_CHARTBOARD_HEADER_HEIGHT = 20;
private final static int DEFAULT_CHARTBOARD_TITLE_BUTTON_WIDTH = 78;
- private final static int DEFAULT_CHARTBOARD_ZOOM_BUTTON_WIDTH = 21;
+ private final static int DEFAULT_CHARTBOARD_COLLAPSE_BUTTON_WIDTH = 21;
private final static int DEFAULT_CHARTBOARD_FOOTER_HEIGHT = 20;
private final static int DEFAULT_CHARTBOARD_SCALE_WIDTH = 99;
- // private final static int DEFAULT_CHART_CELL_HEIGHT = 200;
- protected final static double DEFAULT_EXPAND_SMALL = 0.5;
- protected final static double DEFAULT_EXPAND_MEDIUM = 1;
- protected final static double DEFAULT_EXPAND_MAX = 2;
- private double itemRatio = DEFAULT_EXPAND_MEDIUM;
+
+ protected final static double ITEM_HEIGHT_RATIO_SHORT = 0.5;
+ protected final static double ITEM_HEIGHT_RATIO_NORMAL = 1;
+ protected final static double ITEM_HEIGHT_RATIO_TALL = 2;
+ private double currentItemHeightRatio = ITEM_HEIGHT_RATIO_NORMAL;
private int interval;
- private int chartHeight = DEFAULT_CHART_ZOOMIN_HEIGHT;
+ private int itemHeight = DEFAULT_ITEM_HEIGHT;
public final static int BOARD_STYLE_TIME = 0;
public final static int BOARD_STYLE_FRAME = 1;
titleComp = new Composite(this, SWT.NONE);
titleComp.setLayout(new FillLayout());
- chartZoomButton = new DACustomToggleButton(this,
+ itemCollapseButton = new DACustomToggleButton(this,
ImageResources.CHART_ALL_SIZE_MIN_NORMAL,
ImageResources.CHART_ALL_SIZE_MIN_PUSH,
ImageResources.CHART_ALL_SIZE_MIN_HOVER, null,
ImageResources.CHART_ALL_SIZE_RESTORE_NORMAL,
ImageResources.CHART_ALL_SIZE_RESTORE_HOVER);
- chartZoomButton
+ itemCollapseButton
.addClickListener(new DACustomButtonClickEventListener() {
@Override
public void handleClickEvent(DACustomButton button) {
-
- // long startTime = System.currentTimeMillis();
- boolean bZoomout = chartZoomButton.isToggled();
- zoomoutItem(bZoomout);
-
- // long endTime = System.currentTimeMillis();
- // System.out.println("board end : "
- // + (endTime - startTime));
+ adjustItemsHeight(itemCollapseButton.isToggled());
}
});
e.gc.setForeground(ColorResources.CHART_BOARD_ITEM_LINE);
e.gc.fillRectangle(rt);
- int height = (int) (chartHeight * itemRatio);
+ int height = (int) (itemHeight * currentItemHeightRatio);
int nItemSize = rt.height / height + 1;
for (int i = 0; i < nItemSize; i++) {
e.gc.drawRectangle(rt.x, i * height - 1,
data.left = new FormAttachment(titleComp, 0);
data.top = new FormAttachment(0, 0);
// data.width = 0;
- data.width = DEFAULT_CHARTBOARD_ZOOM_BUTTON_WIDTH;
+ data.width = DEFAULT_CHARTBOARD_COLLAPSE_BUTTON_WIDTH;
data.height = DEFAULT_CHARTBOARD_HEADER_HEIGHT;
- chartZoomButton.setLayoutData(data);
+ itemCollapseButton.setLayoutData(data);
if (BOARD_STYLE_TIME == boardStyle) {
data = new FormData();
- data.left = new FormAttachment(chartZoomButton, 0);
+ data.left = new FormAttachment(itemCollapseButton, 0);
data.top = new FormAttachment(0, 0);
data.right = new FormAttachment(100, 0);
data.height = DEFAULT_CHARTBOARD_HEADER_HEIGHT
timeline.setLayoutData(data);
data = new FormData();
- data.left = new FormAttachment(chartZoomButton, 0);
+ data.left = new FormAttachment(itemCollapseButton, 0);
data.right = new FormAttachment(100, 0);
data.top = new FormAttachment(timeline, 0);
data.height = LifecycleBar.HEIGHT;
lifecycleBar.setLayoutData(data);
} else { // BOARD_STYLE_FRAME == boardStyle
data = new FormData();
- data.left = new FormAttachment(chartZoomButton, 0);
+ data.left = new FormAttachment(itemCollapseButton, 0);
data.top = new FormAttachment(0, 0);
data.right = new FormAttachment(100, 0);
data.height = DEFAULT_CHARTBOARD_HEADER_HEIGHT;
boardManager = new DAChartBoardManager(this);
}
- private void zoomoutItem(boolean bZoomout) {
- if (true == bZoomout) {
- itemRatio = DEFAULT_EXPAND_SMALL;
+ private void adjustItemsHeight(boolean minimize) {
+ if (minimize) {
+ currentItemHeightRatio = ITEM_HEIGHT_RATIO_SHORT;
} else {
- itemRatio = DEFAULT_EXPAND_MEDIUM;
+ currentItemHeightRatio = ITEM_HEIGHT_RATIO_NORMAL;
}
-
- itemListHeight = itemList.callbackZoom(itemRatio, false);
+ itemList.setListHeightRatio(currentItemHeightRatio, false);
+ itemListHeight = itemList.getListHeight();
itemList.layout();
itemList.setSize(itemListScrollComp.getClientArea().width, itemListHeight);
itemListScrollComp.redraw();
itemList.layout();
}
- public boolean isZoomout() {
- if (null == chartZoomButton) {
- return false;
- }
- return chartZoomButton.isToggled();
+ public boolean isItemMinimized() {
+ return itemCollapseButton.isToggled();
}
- public void setZoomout(boolean bZoomout) {
- if (null == chartZoomButton || chartZoomButton.isToggled() == bZoomout) {
+ public void setItemsHeightMode(boolean minimize) {
+ if (itemCollapseButton.isToggled() == minimize) {
return;
}
- chartZoomButton.setToggled(bZoomout);
- zoomoutItem(bZoomout);
+ itemCollapseButton.setToggled(minimize);
+ adjustItemsHeight(minimize);
}
public int getVisibleStart() {
}
protected void registeItem(DAChartBoardItem item) {
- int listHeight = itemList.registeItem(item);
+ itemList.registeItem(item);
+
+ int listHeight = itemList.getListHeight();
itemList.setSize(itemListScrollComp.getClientArea().width, listHeight);
}
if (0 == childSize || childIndex >= childSize) {
return;
}
- item.fold(false);
+ item.unFold();
DAChartBoardItem childItem = childList.get(childIndex);
selectRow(childItem);
int selection = itemList.getItemYPos(parentIndex)
}
protected double getItemHeightRatio() {
- return itemRatio;
+ return currentItemHeightRatio;
}
public LifecycleBar getLifecycleBar() {
parentItem = parent;
depth = parent.getDepth() + 1;
initWidget(itemName, null);
- parentItem.registeItem(this);
+ parentItem.registerItem(this);
}
protected double getItemHeightRatio() {
} else if (null != parentItem) {
itemHeightRatio = parentItem.getItemHeightRatio();
} else {
- itemHeightRatio = DAChartBoard.DEFAULT_EXPAND_MAX;
+ itemHeightRatio = DAChartBoard.ITEM_HEIGHT_RATIO_TALL;
}
return itemHeightRatio;
}
callNotifyResizeChild();
}
- protected int expandItem(boolean isFold) {
+ protected void expandItem(boolean isFold) {
itemCellHeight = (int) (expandRatio * DEFAULT_ITEM_HEIGHT);
if (isFold == false) {
FormData data = (FormData) itemCell.getLayoutData();
data.height = itemCellHeight;
itemCell.setLayoutData(data);
}
-
- return itemCellHeight;
}
protected void expandFoldItem() {
itemCell.setLayoutData(data);
}
- protected void registeItem(DAChartBoardItem child) {
+ protected void registerItem(DAChartBoardItem child) {
if (0 == childList.getItemSize()) {
itemCell.addChildFoldToggleButton();
}
- int chartListHeight = childList.registeItem(child);
+ childList.registeItem(child);
+ itemChildListHeight = childList.getListHeight();
- itemChildListHeight = chartListHeight;
FormData childDListata = (FormData) childList.getLayoutData();
childDListata.height = itemChildListHeight;
childList.setLayoutData(childDListata);
protected void callbackExpand(boolean bExpand) {
if (true == bExpand) {
- expandRatio = DAChartBoard.DEFAULT_EXPAND_MAX;
+ expandRatio = DAChartBoard.ITEM_HEIGHT_RATIO_TALL;
} else {
expandRatio = normalRatio;
}
expandItem(false);
callNotifyResizeChild();
}
+
+ public void setRatio(double ratio) {
+ expandRatio = ratio;
+ expandItem(false);
+ callNotifyResizeChild();
+ }
- protected int callbackZoom(double zoomRatio, boolean isFold) {
+ protected void setItemHeightRatio(double zoomRatio, boolean isFold) {
normalRatio = zoomRatio;
expandRatio = normalRatio;
if (null != childList) {
- itemChildListHeight = childList
- .callbackZoom(zoomRatio, this.isFold);
+ childList.setListHeightRatio(zoomRatio, this.isFold);
+ itemChildListHeight = childList.getListHeight();
+
if (this.isFold == false) {
FormData childDListata = (FormData) childList.getLayoutData();
childDListata.height = itemChildListHeight;
}
itemCell.setExpandButtonNormal();
- itemCellHeight = expandItem(isFold);
-
- return getItemHeight();
+ expandItem(isFold);
}
protected int zoomoutFoldItem() {
- final int height;
if (null != childList) {
- height = childList.zoomoutFoldItem();
+ childList.zoomoutFoldItem();
+ int height = childList.getListHeight();
if (this.isFold == true) {
FormData childDListata = (FormData) childList.getLayoutData();
childDListata.height = height;
}
}
- public void fold(boolean bFold) {
- if (isFold == bFold) {
+ public void unFold() {
+ if (!isFold) {
return;
}
- itemCell.foldChild(bFold);
+ itemCell.unFoldChild();
+ callbackFold(false);
}
public Font getNameFont() {
private Image itemIcon;
private Image foldBackBuffer;
- // private Rectangle itemNamePoint;
- // private Rectangle itemIconPoint;
-
protected DAChartBoardItemCell(final DAChartBoardItem parent, String name,
Image icon, int chartStyle) {
super(parent, SWT.NONE);
chartCell.setLayoutData(data);
}
- protected void foldChild(boolean bFold) {
+ protected void unFoldChild() {
if (null == childFoldButton) {
System.out.println("error - childFoldButton is not exist");
return;
}
boolean isFold = !childFoldButton.isToggled();
- if (isFold == bFold) {
+ if (!isFold) {
return;
}
- childFoldButton.setToggled(!bFold);
- parent.callbackFold(bFold);
+ childFoldButton.setToggled(true);
}
protected void addChildFoldToggleButton() {
class DAChartBoardItemList extends Composite {
private List<DAChartBoardItem> items = new ArrayList<DAChartBoardItem>();
- private int defaultItemHeight = DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT;
+ private int defaultItemHeight = DAChartBoard.DEFAULT_ITEM_HEIGHT;
private double itemRatio = 1;
private boolean isFold = false;
private int listHeight = 0;
super(parent, SWT.NONE);
}
- public int registeItem(DAChartBoardItem item) {
+ public void registeItem(DAChartBoardItem item) {
int itemHeight = (int) (defaultItemHeight * itemRatio);
listHeight += itemHeight;
FormData data = new FormData();
items.add(item);
this.layout();
-
- return listHeight;
}
public int getDefaultItemHeight() {
return items.size();
}
- protected int callbackZoom(double zoomRatio, boolean isFold) {
+ protected void setListHeightRatio(double zoomRatio, boolean isFold) {
itemRatio = zoomRatio;
- if (null == items) {
- return 0;
- }
- int itemsSize = items.size();
- DAChartBoardItem item;
- int itemHeight;
listHeight = 0;
- for (int i = 0; i < itemsSize; i++) {
- item = items.get(i);
- itemHeight = item.callbackZoom(zoomRatio, isFold);
+ for (DAChartBoardItem item : items) {
+ item.setItemHeightRatio(zoomRatio, isFold);
+ int itemHeight = item.getItemHeight();
if (isFold == false) {
FormData data = (FormData) item.getLayoutData();
}
listHeight += itemHeight;
}
- return listHeight;
}
- protected int zoomoutFoldItem() {
+ protected void zoomoutFoldItem() {
int itemsSize = items.size();
for (int i = 0; i < itemsSize; i++) {
item.setLayoutData(data);
}
}
- return listHeight;
}
protected void setChartAxis(double startX, double endX) {
parent.addMouseListener(new MouseListener() {
@Override
public void mouseUp(MouseEvent e) {
- switch (e.button) {
- case 1:
- break;
- case 2:
- break;
- case 3:
+ if (e.button == 3) {
Point pt = Display.getCurrent().getCursorLocation();
if (true == isInParent(pt)) {
open(topShell, pt.x - 5, pt.y - 5);
}
- break;
}
}
@Override
public void mouseDown(MouseEvent event) {
- // TODO Auto-generated method stub
switch (event.button) {
case MOUSE_LEFT: {
closeParent();
private Object data;
private boolean inRange = false;
private boolean isSecondSelection = false;
+ private boolean isFailed = false;
+
+ public boolean isFailed() {
+ return isFailed;
+ }
+
+ public void setFailed(boolean isFailed) {
+ this.isFailed = isFailed;
+ }
public TableInput() {
text = new ArrayList<String>();
DAChartSeriesItem item = series.getSeriesItemList().get(index);
int screenshotWidth = item.getImage().getBounds().width;
- if (chart.getBounds().height != DAChartBoard.DEFAULT_CHART_ZOOMIN_HEIGHT - 1) {
+ if (chart.getBounds().height != DAChartBoard.DEFAULT_ITEM_HEIGHT - 1) {
screenshotWidth /= 2;
}
private static void initialize() {
gles20ErrorMap = new HashMap<Long, String>();
gles20ErrorMap.put(new Long(0), "No error");
- gles20ErrorMap.put(new Long(500), "GL_INVALID_ENUM");
- gles20ErrorMap.put(new Long(501), "GL_INVALID_VALUE");
- gles20ErrorMap.put(new Long(502), "GL_INVALID_OPERATION");
- gles20ErrorMap.put(new Long(505), "GL_OUT_OF_MEMORY");
- gles20ErrorMap.put(new Long(506), "GL_INVALID_FRAMEBUFFER_OPERATION");
+ gles20ErrorMap.put(new Long(1280), "GL_INVALID_ENUM");
+ gles20ErrorMap.put(new Long(1281), "GL_INVALID_VALUE");
+ gles20ErrorMap.put(new Long(1282), "GL_INVALID_OPERATION");
+ gles20ErrorMap.put(new Long(1285), "GL_OUT_OF_MEMORY");
+ gles20ErrorMap.put(new Long(1286), "GL_INVALID_FRAMEBUFFER_OPERATION");
gles20ErrorDescriptionMap = new HashMap<String, String>();
gles20ErrorDescriptionMap.put("0", "No error");
private CurrentContextValueList currentContextValueList;
private ArrayList<List<String>> contextValueDBInputList;
- p
ublic static ArrayList<ArrayList<String>> contextValueChangeList;
+ p
rivate ArrayList<ArrayList<String>> contextValueChangeList;
private ArrayList<List<String>> contextChangeInfoDBInputList;
private List<String> gvaV0ValueList;
String apiName = logData.getApiName();
String parameter = logData.getArgs();
long errorNo = logData.getErrno();
+
//FIXME
if(apiName.equals(API_EGL_SWAPBUFFERS)) {
errorNo = 0;
logData.setErrNo(0);
}
+
+ if(errorNo != 0) {
+ System.out.println("00");
+ }
if (apiType != API_TYPE_INIT) {
glFrameDataList.get(currentFrameIndex).addGLAPIData(
return -1;
}
+
+ public ArrayList<String> getChangeList(int columnIndex) {
+ return contextValueChangeList.get(columnIndex);
+ }
}
import org.tizen.dynamicanalyzer.model.TableInput;
import org.tizen.dynamicanalyzer.nl.GLPageLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.sql.DBTableInfo;
import org.tizen.dynamicanalyzer.sql.DBTableManager;
import org.tizen.dynamicanalyzer.sql.SqlManager;
setTableName(GLPageLabels.GL_API_LIST_VIEW_TITLE);
setSortTypes(sortTypes);
- setFailedAPITableIndex(5);
setColumnAlignment(columnAlignment);
setColumns(columnNames);
setColumnSize(columnSizes);
texts.add(glAPIData.getParameter());
texts.add(String.valueOf(glAPIData.getElapsedTime()));
texts.add(GLES20ErrorInformation.getError(glAPIData.getErrorNo()));
-
+
tableData.getData().addAll(texts);
TableInput tableInput = new TableInput();
tableInput.setText(texts);
tableInput.setData(tableData);
+ if(glAPIData.getErrorNo() != 0) {
+ tableInput.setFailed(true);
+ }
+
inputList.add(tableInput);
if (involvedMap != null) {
gridItem.setBackground(rangeColor);
}
+ if (input.get(i).isFailed()) {
+ gridItem.setBackground(ColorResources.TABLE_CONTENTS_FAILED_BACGOUND_COLOR);
+ gridItem.setForeground(ColorResources.TABLE_CONTENTS_FAILED_FONT_COLOR);
+ gridItem.setImage(0,
+ ImageResources.FAILED_API_ICON_TABLE);
+ }
+
if (gridData != null) {
long seqNum = gridData.getSelectionKey();
for (int ii = 0; ii < selSeqs.size(); ii++) {
timeCombo.setText(GLPageLabels.GL_CHART_TITLE_TIME);
timeChartBoard.setScaleVal(frameChartBoard.getScaleVal());
timeChartBoard.setVisibleStart(frameChartBoard.getVisibleStart());
- timeChartBoard.setZoomout(frameChartBoard.isZoomout());
+ timeChartBoard.setItemsHeightMode(frameChartBoard.isItemMinimized());
updateView();
}
frameCombo.setText(GLPageLabels.GL_CHART_TITLE_FRAME);
frameChartBoard.setScaleVal(timeChartBoard.getScaleVal());
frameChartBoard.setVisibleStart(timeChartBoard.getVisibleStart());
- frameChartBoard.setZoomout(timeChartBoard.isZoomout());
+ frameChartBoard.setItemsHeightMode(timeChartBoard.isItemMinimized());
updateView();
}
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.layout.FormAttachment;
+import org.eclipse.swt.layout.FormData;
+import org.eclipse.swt.layout.FormLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Event;
private static GLContextTreeTable instance = null;
private static final int COLUMN_SIZE_NAME = 200;
- private static final int COLUMN_SIZE_VALUE = 100;
+ private static final int COLUMN_SIZE_VALUE = 200;
private static final int COLUMN_SIZE_DIFF = 100;
private String[] columnNames = { GLPageLabels.GL_CONTEXT_VIEW_NAME,
private Point hover = new Point(-1, -1);
private Point push = new Point(-1, -1);
+ private Composite naviButtonComposite;
+ private Button buttonLeftLeft;
private Button buttonLeft;
private Button buttonRight;
+ private Button buttonRightRight;
+
+ private GLDataMaker glDataMaker = GLDataMaker.getInstance();
public static GLContextTreeTable getInstance(Composite parent,
int compStyle, int tableStyle) {
makeTreeInput = false;
updateTree();
table.setSelection(selectionIndex);
-
- if(index != -1) {
- ArrayList<String> list = GLDataMaker.contextValueChangeList.get(index);
+
+ if (index != -1) {
+ ArrayList<String> list = glDataMaker.getChangeList(index);
System.out.println(list);
- } else {
- System.out.println("-1-1-1-1");
}
}
return;
}
- GridEditor editor = new GridEditor(table);
- buttonLeft = new Button(table, SWT.NONE);
+ naviButtonComposite = new Composite(table, SWT.NONE);
+ naviButtonComposite.setLayout(new FormLayout());
+
+ buttonLeftLeft = new Button(naviButtonComposite, SWT.NONE);
+ buttonLeftLeft.setText("<<");
+ FormData formData = new FormData();
+ formData.top = new FormAttachment(0, 0);
+ formData.bottom = new FormAttachment(100, 0);
+ formData.left = new FormAttachment(0, 0);
+ formData.right = new FormAttachment(0, 27);
+ buttonLeftLeft.setLayoutData(formData);
+
+ buttonLeft = new Button(naviButtonComposite, SWT.NONE);
buttonLeft.setText("<");
- buttonLeft.pack();
- editor.minimumWidth = buttonLeft.getSize().x;
- editor.horizontalAlignment = SWT.LEFT;
- editor.setEditor(buttonLeft, gridItem, 2);
- buttonLeft.addSelectionListener(new SelectionListener() {
- @Override
- public void widgetSelected(SelectionEvent e) {
- ArrayList<String> changeList = GLDataMaker.contextValueChangeList
- .get(treeNodeData.getDBColumnIndex());
- if (seq == null) {
- return;
- }
-
- int bSearchedIndex = bSearchPrev(changeList,
- Integer.parseInt(seq));
- if (bSearchedIndex < 0) {
- return;
- }
-
- String[] prevChangeInfo = changeList
- .get(bSearchedIndex).split(
- GLDataMaker.DELIMITER);
- List<String> viewNameList = new ArrayList<String>();
- viewNameList.add(GLAPIListView.class.getName());
- viewNameList.add(GLDetailsView.class.getName());
- AnalyzerManager.getCurrentPage().updateSelectedViews(
- new GLSelectionData(ID, Integer
- .parseInt(prevChangeInfo[0]), -1,
- prevChangeInfo[1]), viewNameList);
- }
-
- @Override
- public void widgetDefaultSelected(SelectionEvent e) {
- }
- });
-
- editor = new GridEditor(table);
- buttonRight = new Button(table, SWT.NONE);
+ formData = new FormData();
+ formData.top = new FormAttachment(0, 0);
+ formData.bottom = new FormAttachment(100, 0);
+ formData.left = new FormAttachment(0, 28);
+ formData.right = new FormAttachment(0, 55);
+ buttonLeft.setLayoutData(formData);
+
+ buttonRight = new Button(naviButtonComposite, SWT.NONE);
buttonRight.setText(">");
- buttonRight.pack();
- editor.minimumWidth = buttonRight.getSize().x;
- editor.horizontalAlignment = SWT.RIGHT;
- editor.setEditor(buttonRight, gridItem, 2);
- buttonRight.addSelectionListener(new SelectionListener() {
- @Override
- public void widgetSelected(SelectionEvent e) {
- ArrayList<String> changeList = GLDataMaker.contextValueChangeList
- .get(treeNodeData.getDBColumnIndex());
- if (seq == null) {
- return;
- }
-
- int bSearchedIndex = bSearchNext(changeList,
- Integer.parseInt(seq));
- if (bSearchedIndex < 0 || bSearchedIndex >= changeList.size()) {
- return;
- }
-
- String[] prevChangeInfo = changeList
- .get(bSearchedIndex).split(
- GLDataMaker.DELIMITER);
- List<String> viewNameList = new ArrayList<String>();
- viewNameList.add(GLAPIListView.class.getName());
- viewNameList.add(GLDetailsView.class.getName());
- AnalyzerManager.getCurrentPage().updateSelectedViews(
- new GLSelectionData(ID, Integer
- .parseInt(prevChangeInfo[0]), -1,
- prevChangeInfo[1]), viewNameList);
- }
-
- @Override
- public void widgetDefaultSelected(SelectionEvent e) {
- }
- });
+ formData = new FormData();
+ formData.top = new FormAttachment(0, 0);
+ formData.bottom = new FormAttachment(100, 0);
+ formData.left = new FormAttachment(100, -55);
+ formData.right = new FormAttachment(100, -28);
+ buttonRight.setLayoutData(formData);
+
+ buttonRightRight = new Button(naviButtonComposite, SWT.NONE);
+ buttonRightRight.setText(">>");
+ formData = new FormData();
+ formData.top = new FormAttachment(0, 0);
+ formData.bottom = new FormAttachment(100, 0);
+ formData.left = new FormAttachment(100, -27);
+ formData.right = new FormAttachment(100, 0);
+ buttonRightRight.setLayoutData(formData);
+
+ GridEditor editor = new GridEditor(table);
+ editor.minimumWidth = naviButtonComposite.getSize().x;
+ editor.grabHorizontal = true;
+ editor.setEditor(naviButtonComposite, gridItem, 1);
+
+ setNaviButtonEventListener(treeNodeData);
}
});
initContextTree();
}
+ private void setNaviButtonEventListener(
+ final GLContextTreeNodeData treeNodeData) {
+ buttonLeftLeft.addSelectionListener(new SelectionListener() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ ArrayList<String> changeList = glDataMaker
+ .getChangeList(treeNodeData.getDBColumnIndex());
+ if (seq == null) {
+ return;
+ }
+
+ int bSearchedIndex = bSearchPrev(changeList,
+ Integer.parseInt(seq));
+ if (bSearchedIndex < 0) {
+ return;
+ }
+
+ String[] prevChangeInfo = changeList.get(bSearchedIndex).split(
+ GLDataMaker.DELIMITER);
+ List<String> viewNameList = new ArrayList<String>();
+ viewNameList.add(GLAPIListView.class.getName());
+ viewNameList.add(GLDetailsView.class.getName());
+ AnalyzerManager.getCurrentPage().updateSelectedViews(
+ new GLSelectionData(ID, Integer
+ .parseInt(prevChangeInfo[0]), -1,
+ prevChangeInfo[1]), viewNameList);
+ }
+
+ @Override
+ public void widgetDefaultSelected(SelectionEvent e) {
+ }
+ });
+
+// buttonLeft.addSelectionListener(new SelectionListener() {
+// @Override
+// public void widgetSelected(SelectionEvent e) {
+// ArrayList<String> changeList = glDataMaker
+// .getChangeList(treeNodeData.getDBColumnIndex());
+// if (seq == null) {
+// return;
+// }
+//
+// int bSearchedIndex = bSearchPrev(changeList,
+// Integer.parseInt(seq));
+// if (bSearchedIndex < 0) {
+// return;
+// }
+//
+// String[] prevChangeInfo = changeList.get(bSearchedIndex).split(
+// GLDataMaker.DELIMITER);
+// List<String> viewNameList = new ArrayList<String>();
+// viewNameList.add(GLAPIListView.class.getName());
+// viewNameList.add(GLDetailsView.class.getName());
+// AnalyzerManager.getCurrentPage().updateSelectedViews(
+// new GLSelectionData(ID, Integer
+// .parseInt(prevChangeInfo[0]), -1,
+// prevChangeInfo[1]), viewNameList);
+// }
+//
+// @Override
+// public void widgetDefaultSelected(SelectionEvent e) {
+// }
+// });
+//
+// buttonRight.addSelectionListener(new SelectionListener() {
+// @Override
+// public void widgetSelected(SelectionEvent e) {
+// ArrayList<String> changeList = glDataMaker
+// .getChangeList(treeNodeData.getDBColumnIndex());
+// if (seq == null) {
+// return;
+// }
+//
+// int bSearchedIndex = bSearchNext(changeList,
+// Integer.parseInt(seq));
+// if (bSearchedIndex < 0 || bSearchedIndex >= changeList.size()) {
+// return;
+// }
+//
+// String[] prevChangeInfo = changeList.get(bSearchedIndex).split(
+// GLDataMaker.DELIMITER);
+// List<String> viewNameList = new ArrayList<String>();
+// viewNameList.add(GLAPIListView.class.getName());
+// viewNameList.add(GLDetailsView.class.getName());
+// AnalyzerManager.getCurrentPage().updateSelectedViews(
+// new GLSelectionData(ID, Integer
+// .parseInt(prevChangeInfo[0]), -1,
+// prevChangeInfo[1]), viewNameList);
+// }
+//
+// @Override
+// public void widgetDefaultSelected(SelectionEvent e) {
+// }
+// });
+
+ buttonRightRight.addSelectionListener(new SelectionListener() {
+ @Override
+ public void widgetSelected(SelectionEvent e) {
+ ArrayList<String> changeList = glDataMaker
+ .getChangeList(treeNodeData.getDBColumnIndex());
+ if (seq == null) {
+ return;
+ }
+
+ int bSearchedIndex = bSearchNext(changeList,
+ Integer.parseInt(seq));
+ if (bSearchedIndex < 0 || bSearchedIndex >= changeList.size()) {
+ return;
+ }
+
+ String[] prevChangeInfo = changeList.get(bSearchedIndex).split(
+ GLDataMaker.DELIMITER);
+ List<String> viewNameList = new ArrayList<String>();
+ viewNameList.add(GLAPIListView.class.getName());
+ viewNameList.add(GLDetailsView.class.getName());
+ AnalyzerManager.getCurrentPage().updateSelectedViews(
+ new GLSelectionData(ID, Integer
+ .parseInt(prevChangeInfo[0]), -1,
+ prevChangeInfo[1]), viewNameList);
+ }
+
+ @Override
+ public void widgetDefaultSelected(SelectionEvent e) {
+ }
+ });
+ }
+
private int bSearchPrev(List<String> list, int target) {
int first = 0;
int last = list.size() - 1;
private void disposeButtons() {
+ if(naviButtonComposite != null) {
+ naviButtonComposite.dispose();
+ }
+
+ if(buttonLeftLeft != null) {
+ buttonLeftLeft.dispose();
+ }
+
if(buttonLeft != null) {
buttonLeft.dispose();
}
if(buttonRight != null) {
buttonRight.dispose();
}
+
+ if(buttonRightRight != null) {
+ buttonRightRight.dispose();
+ }
}
private void setNodeProperty(TreeInput treeInput) {
threadCombo.setText("Thread");
threadChart.setScaleVal(syncChart.getScaleVal());
threadChart.setVisibleStart(syncChart.getVisibleStart());
- threadChart.setZoomout(syncChart.isZoomout());
+ threadChart.setItemsHeightMode(syncChart.isItemMinimized());
callUpdatePage(threadChart.getSelectItem());
updateView();
}
syncCombo.setText("Sync");
syncChart.setScaleVal(threadChart.getScaleVal());
syncChart.setVisibleStart(threadChart.getVisibleStart());
- syncChart.setZoomout(threadChart.isZoomout());
+ syncChart.setItemsHeightMode(threadChart.isItemMinimized());
callUpdatePage(syncChart.getSelectItem());
updateView();
}
package org.tizen.dynamicanalyzer.ui.timeline.chart;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
+import org.eclipse.swt.widgets.Display;
import org.tizen.dynamicanalyzer.nl.TimelineChartLabels;
import org.tizen.dynamicanalyzer.resources.ColorResources;
+import org.tizen.dynamicanalyzer.resources.FontResources;
import org.tizen.dynamicanalyzer.resources.ImageResources;
import org.tizen.dynamicanalyzer.swap.channel.data.DataChannelConstants;
import org.tizen.dynamicanalyzer.swap.logparser.LogPackage;
import org.tizen.dynamicanalyzer.swap.logparser.Logs;
import org.tizen.dynamicanalyzer.swap.model.data.LogData;
import org.tizen.dynamicanalyzer.swap.model.data.SystemData;
+import org.tizen.dynamicanalyzer.ui.common.PopupAnalysisMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupClearMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupEndMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupFromSelectionMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.PopupStartMenuItemClickListener;
+import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseEventListener;
+import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
import org.tizen.dynamicanalyzer.ui.timeline.common.TimelineConstants;
import org.tizen.dynamicanalyzer.utils.Formatter;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChart;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlot.AutoRangeType;
+import org.tizen.dynamicanalyzer.widgets.chart.DAChartPlotTooltip;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeries;
import org.tizen.dynamicanalyzer.widgets.chart.DAChartSeriesItem;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoard;
import org.tizen.dynamicanalyzer.widgets.chartBoard.DAChartBoardItem;
+import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenu;
+import org.tizen.dynamicanalyzer.widgets.popupMenu.DAPopupMenuItem;
public class CPUChart extends TimelineChart {
private static CPUChart instance = null;
+ private String COMMA = ",";
private DAChartSeries appLoadSeries;
private DAChartSeries totalLoadSeries;
+ DAChartBoard chartBoard = null;
+ DAChartBoardItem item = null;
+ private DAChartBoardItem childItem = null;
+ private Map<Integer, DAChartSeries> childSeriesMap;
+
public static CPUChart getInstance() {
if (instance == null) {
instance = new CPUChart();
TimelineChartLabels.CPU_CHART_SERIES_NAME_TOTAL_LOAD,
DAChartSeries.SERIES_STYLE_AREA,
ColorResources.SERIES_COLOR_CPU_APP);
+
+ childSeriesMap = new HashMap<Integer, DAChartSeries>();
}
@Override
public DAChartBoardItem createBoardItem(DAChartBoard board) {
- DAChartBoardItem item = super.createBoardItem(board);
+ item = super.createBoardItem(board);
chart.addSeries(totalLoadSeries);
chart.addSeries(appLoadSeries);
@Override
public void parseLogPackage(LogPackage logPack) {
Logs logs = logPack.getLogs(probeType);
- if(logs == null) {
+ if (logs == null) {
return;
}
-
+
List<LogData> logDataList = logs.getLogs();
-
+
for (LogData logData : logDataList) {
- parseLog((SystemData)logData);
+ parseLog((SystemData) logData);
}
}
private void parseLog(SystemData logData) {
+ double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
+
/* app load */
try {
- double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
double appCpuRate = logData.getAppCpuUsage();
appLoadSeries.addSeriesItem(new DAChartSeriesItem(time, appCpuRate,
Formatter.toPercentageFormat(appCpuRate)));
}
/* total load */
-
try {
- double time = logData.getTime() / TimelineConstants.MEGA_DOUBLE;
String[] cpuRates = logData.getCpuLoad().split(","); //$NON-NLS-1$
double systemAvgLoad = Double
.parseDouble(cpuRates[cpuRates.length - 1]);
} catch (NumberFormatException ne) {
ne.printStackTrace();
}
+
+ if (childItem == null) {
+ Display.getDefault().asyncExec(new Runnable() {
+ @Override
+ public void run() {
+
+ childItem = new DAChartBoardItem(item, "Processes");
+ childItem.useExpand(false);
+
+ DAChart childChart = childItem.getChart();
+ DAChartPlot childPlot = childChart.getPlot();
+ DAChartPlotTooltip tooltip = new DAChartPlotTooltip(-1);
+
+ childPlot.setBackgroundImage(ImageResources.BG_GRADIENT);
+ tooltip.setFont(FontResources.CHART_TOOLTIP_FONT);
+ childPlot.setTooltip(tooltip);
+ childPlot.setAxisFont(FontResources.CHART_AXIS_FONT);
+ childPlot.setAutoHeightRange(AutoRangeType.MANUAL);
+ childPlot.setAxisRangeY(0, 100);
+ childPlot.setAxisUnit("%");
+ childPlot.setShowAxis(true);
+ childPlot.setMarkers(chartBoard.getMarkers());
+
+ DAPopupMenu popupMenu = new DAPopupMenu(childChart);
+ popupMenu.setFont(FontResources.CONTEXT_MENU_ITEM_FONT);
+ DAPopupMenuItem startItem = new DAPopupMenuItem(popupMenu);
+ startItem
+ .setText(TimelineChartLabels.RANGE_CONTEXT_SET_START);
+ startItem.addListener(new PopupStartMenuItemClickListener(
+ startItem, chartBoard));
+
+ DAPopupMenuItem endItem = new DAPopupMenuItem(popupMenu);
+ endItem.setText(TimelineChartLabels.RANGE_CONTEXT_SET_END);
+ endItem.addListener(new PopupEndMenuItemClickListener(
+ endItem, chartBoard));
+
+ DAPopupMenuItem fromSelectionItem = new DAPopupMenuItem(
+ popupMenu);
+ fromSelectionItem
+ .setText(TimelineChartLabels.RANGE_CONTEXT_SET_FROM_SELECTION);
+ fromSelectionItem
+ .addListener(new PopupFromSelectionMenuItemClickListener(
+ fromSelectionItem, chartBoard));
+
+ DAPopupMenuItem analysisItem = new DAPopupMenuItem(
+ popupMenu);
+ analysisItem
+ .setText(TimelineChartLabels.RANGE_CONTEXT_ANALYSIS);
+ analysisItem
+ .addListener(new PopupAnalysisMenuItemClickListener());
+
+ DAPopupMenuItem clearItem = new DAPopupMenuItem(popupMenu);
+ clearItem.setText(TimelineChartLabels.RANGE_CONTEXT_CLEAR);
+ clearItem
+ .addListener(new PopupClearMenuItemClickListener());
+
+ TimelineChartMouseEventListener timelineChartMouseEventListener = new TimelineChartMouseEventListener(
+ popupMenu, chartBoard.getTimeline());
+ childChart
+ .addMouseListener(timelineChartMouseEventListener);
+ childChart
+ .addMouseMoveListener(timelineChartMouseEventListener);
+ childChart
+ .addMouseTrackListener(new TimelineChartMouseTrackAdapter(
+ chartBoard.getTimeline()));
+ }
+ });
+ }
+
+ String[] processLoadDatas = logData.getProcessLoad().split(COMMA);
+
+ int prevChildSize = childSeriesMap.size();
+ for (int i = 0; i < processLoadDatas.length; i++) {
+ int pid = Integer.parseInt(processLoadDatas[i]);
+ double load = Double.parseDouble(processLoadDatas[++i]);
+
+ DAChartSeries series = childSeriesMap.get(pid);
+
+ if (series == null) {
+ if (load != 0) {
+ DAChartSeries newSeries = new DAChartSeries(
+ Integer.toString(pid),
+ DAChartSeries.SERIES_STYLE_LINE,
+ ColorResources.SERIES_COLOR_CPU_SYSTEM);
+ newSeries.addSeriesItem(new DAChartSeriesItem(time, load,
+ Formatter.toPercentageFormat(load)));
+ childItem.getChart().addSeries(newSeries);
+
+ childSeriesMap.put(pid, newSeries);
+ }
+ } else {
+ series.addSeriesItem(new DAChartSeriesItem(time, load,
+ Formatter.toPercentageFormat(load)));
+ }
+ }
+
+ if (prevChildSize != childSeriesMap.size()) {
+ Display.getDefault().asyncExec(new Runnable() {
+ @Override
+ public void run() {
+ childItem.setRatio(childSeriesMap.size() / 3.0);
+ }
+ });
+ }
+ }
+
+ public void setChartBoard(DAChartBoard chartBoard) {
+ this.chartBoard = chartBoard;
+ }
+
+ @Override
+ public void clear() {
+ super.clear();
+
+ chartBoard = null;
+ childItem = null;
+ childSeriesMap.clear();
}
}
return selectedChartList;
}
- public DAChartBoard getChartBoard() {
- return chartBoard;
- }
-
private TimelineChart getChartInstance(String chartName) {
return chartInstanceMapNameKey.get(chartName);
}
import org.tizen.dynamicanalyzer.ui.common.TimelineChartMouseTrackAdapter;
import org.tizen.dynamicanalyzer.ui.common.UICommonConstants;
import org.tizen.dynamicanalyzer.ui.range.RangeDataManager;
+import org.tizen.dynamicanalyzer.ui.timeline.chart.CPUChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.HeapChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.ScreenshotChart;
import org.tizen.dynamicanalyzer.ui.timeline.chart.TimelineChart;
customLogParser.clear();
// SnapshotData.getInstance().clear();
initializeCharts();
+
+ CPUChart.getInstance().setChartBoard(chartBoard);
}
private void initializeCharts() {
}
table.setSelection(sel);
table.setTopIndex(topIndex);
+
}
}
}
}
}
-
+
if (gridData != null) {
long seqNum = gridData.getSelectionKey();
for (int ii = 0; ii < selSeqs.size(); ii++) {
projects / sdk / tools / dynamic-analyzer.git / commitdiff