From 6345edf9b6735513ee998fa9ed80a7724f334477 Mon Sep 17 00:00:00 2001 From: "jy.exe.lee" Date: Thu, 5 Jul 2012 13:14:36 +0900 Subject: [PATCH] [Title] custom widget plug-in added [Type] new feature [Module] DynamicAnalyzer [Priority] normal [CQ#] [Redmine#] [Problem] [Cause] [Solution] [TestCase] --- org.tizen.dynamicanalyzer.widgets/.classpath | 7 + org.tizen.dynamicanalyzer.widgets/.project | 28 + .../.settings/org.eclipse.jdt.core.prefs | 8 + .../META-INF/MANIFEST.MF | 15 + org.tizen.dynamicanalyzer.widgets/build.properties | 4 + .../tizen/dynamicanalyzer/widgets/Activator.java | 50 ++ .../widgets/button/TizenButton.java | 213 ++++++++ .../button/TizenButtonClickEventListener.java | 26 + .../widgets/button/TizenButtonRenderer.java | 83 +++ .../widgets/button/TizenDefaultButtonRenderer.java | 10 + .../widgets/button/TizenWidgetAttribute.java | 93 ++++ .../widgets/button/toggle/TizenToggleButton.java | 80 +++ .../button/toggle/TizenToggleButtonRenderer.java | 33 ++ .../combo/DefaultTizenComboPopupRenderer.java | 50 ++ .../widgets/combo/DefaultTizenComboRenderer.java | 50 ++ .../dynamicanalyzer/widgets/combo/TizenCombo.java | 588 +++++++++++++++++++++ .../widgets/combo/TizenComboPopupRenderer.java | 19 + .../widgets/combo/TizenComboRenderer.java | 11 + .../widgets/combo/TizenComboSelectionListener.java | 20 + .../widgets/graph/circular/CircularGraph.java | 186 +++++++ .../widgets/helper/ColorResources.java | 313 +++++++++++ .../dynamicanalyzer/widgets/helper/Formatter.java | 253 +++++++++ .../widgets/helper/ImageResources.java | 69 +++ .../src/test/TestClass.java | 118 +++++ .../testImages/dialog_button_push.png | Bin 0 -> 2995 bytes .../testImages/noImage.png | Bin 0 -> 4125 bytes .../testImages/snapshot_arrow_left_disable.png | Bin 0 -> 3229 bytes .../testImages/snapshot_arrow_left_hover.png | Bin 0 -> 3195 bytes .../testImages/snapshot_arrow_left_nor.png | Bin 0 -> 3234 bytes .../testImages/snapshot_arrow_left_push.png | Bin 0 -> 3245 bytes .../testImages/snapshot_arrow_right_disable.png | Bin 0 -> 3241 bytes .../testImages/snapshot_arrow_right_hover.png | Bin 0 -> 3226 bytes .../testImages/snapshot_arrow_right_nor.png | Bin 0 -> 3236 bytes .../testImages/snapshot_arrow_right_push.png | Bin 0 -> 3248 bytes .../testImages/toolbar_about_disable.png | Bin 0 -> 3573 bytes .../testImages/toolbar_about_hover.png | Bin 0 -> 3874 bytes .../testImages/toolbar_about_nor.png | Bin 0 -> 3666 bytes .../testImages/toolbar_about_push.png | Bin 0 -> 3905 bytes .../testImages/toolbar_source_view_disable.png | Bin 0 -> 3183 bytes .../testImages/toolbar_source_view_hover.png | Bin 0 -> 3424 bytes .../testImages/toolbar_source_view_nor.png | Bin 0 -> 3279 bytes .../testImages/toolbar_source_view_push.png | Bin 0 -> 3411 bytes .../testImages/toolbar_source_view_tog.png | Bin 0 -> 3446 bytes org.tizen.dynamicanalyzer/.classpath | 1 - org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF | 6 +- .../dynamicanalyzer/ui/views/CoolbarArea.java | 8 +- .../ui/widgets/combo/TitleComboPopupRenderer.java | 2 +- .../ui/widgets/combo/TitleComboRenderer.java | 2 +- 48 files changed, 2336 insertions(+), 10 deletions(-) create mode 100644 org.tizen.dynamicanalyzer.widgets/.classpath create mode 100644 org.tizen.dynamicanalyzer.widgets/.project create mode 100644 org.tizen.dynamicanalyzer.widgets/.settings/org.eclipse.jdt.core.prefs create mode 100644 org.tizen.dynamicanalyzer.widgets/META-INF/MANIFEST.MF create mode 100644 org.tizen.dynamicanalyzer.widgets/build.properties create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/Activator.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButton.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonClickEventListener.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenDefaultButtonRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenWidgetAttribute.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButton.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButtonRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboPopupRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenCombo.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboPopupRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboRenderer.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboSelectionListener.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/graph/circular/CircularGraph.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ColorResources.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/Formatter.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java create mode 100644 org.tizen.dynamicanalyzer.widgets/src/test/TestClass.java create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/dialog_button_push.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/noImage.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_disable.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_hover.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_nor.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_push.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_disable.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_hover.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_nor.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_push.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_disable.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_hover.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_nor.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_push.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_disable.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_hover.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_nor.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_push.png create mode 100644 org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_tog.png diff --git a/org.tizen.dynamicanalyzer.widgets/.classpath b/org.tizen.dynamicanalyzer.widgets/.classpath new file mode 100644 index 0000000..ad32c83 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/.classpath @@ -0,0 +1,7 @@ + + + + + + + diff --git a/org.tizen.dynamicanalyzer.widgets/.project b/org.tizen.dynamicanalyzer.widgets/.project new file mode 100644 index 0000000..07c232f --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/.project @@ -0,0 +1,28 @@ + + + org.tizen.dynamicanalyzer.widgets + + + + + + org.eclipse.jdt.core.javabuilder + + + + + org.eclipse.pde.ManifestBuilder + + + + + org.eclipse.pde.SchemaBuilder + + + + + + org.eclipse.pde.PluginNature + org.eclipse.jdt.core.javanature + + diff --git a/org.tizen.dynamicanalyzer.widgets/.settings/org.eclipse.jdt.core.prefs b/org.tizen.dynamicanalyzer.widgets/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 0000000..cf90579 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,8 @@ +#Thu Jul 05 13:02:20 KST 2012 +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6 +org.eclipse.jdt.core.compiler.compliance=1.6 +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.source=1.6 diff --git a/org.tizen.dynamicanalyzer.widgets/META-INF/MANIFEST.MF b/org.tizen.dynamicanalyzer.widgets/META-INF/MANIFEST.MF new file mode 100644 index 0000000..ec6898d --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/META-INF/MANIFEST.MF @@ -0,0 +1,15 @@ +Manifest-Version: 1.0 +Bundle-ManifestVersion: 2 +Bundle-Name: Widgets +Bundle-SymbolicName: org.tizen.dynamicanalyzer.widgets +Bundle-Version: 1.0.0.qualifier +Bundle-Activator: org.tizen.dynamicanalyzer.widgets.Activator +Require-Bundle: org.eclipse.ui, + org.eclipse.core.runtime +Bundle-ActivationPolicy: lazy +Bundle-RequiredExecutionEnvironment: JavaSE-1.6 +Export-Package: org.tizen.dynamicanalyzer.widgets, + org.tizen.dynamicanalyzer.widgets.button, + org.tizen.dynamicanalyzer.widgets.button.toggle, + org.tizen.dynamicanalyzer.widgets.combo, + org.tizen.dynamicanalyzer.widgets.helper diff --git a/org.tizen.dynamicanalyzer.widgets/build.properties b/org.tizen.dynamicanalyzer.widgets/build.properties new file mode 100644 index 0000000..34d2e4d --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/build.properties @@ -0,0 +1,4 @@ +source.. = src/ +output.. = bin/ +bin.includes = META-INF/,\ + . diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/Activator.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/Activator.java new file mode 100644 index 0000000..f539e9f --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/Activator.java @@ -0,0 +1,50 @@ +package org.tizen.dynamicanalyzer.widgets; + +import org.eclipse.ui.plugin.AbstractUIPlugin; +import org.osgi.framework.BundleContext; + +/** + * The activator class controls the plug-in life cycle + */ +public class Activator extends AbstractUIPlugin { + + // The plug-in ID + public static final String PLUGIN_ID = "org.tizen.dynamicanalyzer.widgets"; //$NON-NLS-1$ + + // The shared instance + private static Activator plugin; + + /** + * The constructor + */ + public Activator() { + } + + /* + * (non-Javadoc) + * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext) + */ + public void start(BundleContext context) throws Exception { + super.start(context); + plugin = this; + } + + /* + * (non-Javadoc) + * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext) + */ + public void stop(BundleContext context) throws Exception { + plugin = null; + super.stop(context); + } + + /** + * Returns the shared instance + * + * @return the shared instance + */ + public static Activator getDefault() { + return plugin; + } + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButton.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButton.java new file mode 100644 index 0000000..a6b3b7c --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButton.java @@ -0,0 +1,213 @@ +package org.tizen.dynamicanalyzer.widgets.button; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.events.PaintListener; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + +public class TizenButton extends Canvas { + public static final int MAX_SIZE = 100; + + public static final int STATE_NORMAL = 0; + public static final int STATE_PUSH = 1; + public static final int STATE_HOVER = 2; + public static final int STATE_DISABLE = 3; + + public static final int TYPE_IMAGE = 0; + public static final int TYPE_COLOR = 1; + public static final int TYPE_GRADATION = 2; + + Composite parent; + protected boolean enabled = true; + + protected int state = STATE_NORMAL; + protected TizenWidgetAttribute attr; + protected TizenDefaultButtonRenderer buttonRenderer = null; + + public void addListeners() { + this.addListener(SWT.MouseEnter, buttonMouseListener); + this.addListener(SWT.MouseExit, buttonMouseListener); + this.addListener(SWT.MouseDown, buttonMouseListener); + this.addListener(SWT.MouseUp, buttonMouseListener); + } + + public TizenButton(Composite parent, int style) { + super(parent, style); + + this.parent = parent; + FillLayout layout = new FillLayout(SWT.HORIZONTAL); + this.setLayout(layout); + + this.setForeground(ColorResources.WHITE); + this.addPaintListener(buttonPaintListener); + addListeners(); + buttonRenderer = new TizenButtonRenderer(); + attr = new TizenWidgetAttribute(); + setDefaultColors(); + } + + public TizenButton(Composite parent, int style, String titleText) { + this(parent, style); + attr.setTitle(titleText); + } + + public TizenButton(Composite parent, Image normal, Image mouseDown, + Image hover, Image disable) { + this(parent, SWT.TRANSPARENT); + setImages(normal, mouseDown, hover, disable); + attr.setDrawType(TYPE_IMAGE); + } + + protected void changeButtonState(int s) { + state = s; + this.redraw(); + } + + protected Listener buttonMouseListener = new Listener() { + + @Override + public void handleEvent(Event event) { + if (state == STATE_DISABLE) { + return; + } + + if (event.type == SWT.MouseEnter) { + changeButtonState(STATE_HOVER); + } + + if (event.type == SWT.MouseExit) { + changeButtonState(STATE_NORMAL); + } + + if (event.type == SWT.MouseDown) { + changeButtonState(STATE_PUSH); + } + + if (event.type == SWT.MouseUp) { // FIXME + changeButtonState(STATE_HOVER); + } + } + }; + + private void setDefaultColors() { + attr.setColor(STATE_DISABLE, + new Color(Display.getCurrent(), 48, 48, 48)); + attr.setColor(STATE_PUSH, new Color(Display.getCurrent(), 29, 109, 140)); + attr.setColor(STATE_HOVER, new Color(Display.getCurrent(), 0, 134, 185)); + attr.setColor(STATE_NORMAL, new Color(Display.getCurrent(), 67, 67, 67)); + } + + private PaintListener buttonPaintListener = new PaintListener() { + + @Override + public void paintControl(PaintEvent e) { + buttonRenderer.draw(e.gc, (Canvas) e.widget, state, attr); + } + }; + + public void setTitle(String newTitle) { + attr.setTitle(newTitle); + } + + public void setText(String newTitle) { + attr.setTitle(newTitle); + } + + public void setRenderer(TizenDefaultButtonRenderer newRenderer) { + buttonRenderer = newRenderer; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + if (enabled) { + changeButtonState(STATE_NORMAL); + } else { + changeButtonState(STATE_DISABLE); + } + } + + public boolean getEnabled() { + return this.enabled; + } + + public void setHoverImage(Image image) { + attr.setImage(STATE_HOVER, image); + } + + public void setNormalImage(Image image) { + attr.setImage(STATE_NORMAL, image); + } + + public void setPushImage(Image image) { + attr.setImage(STATE_PUSH, image); + } + + public void setDisableImage(Image image) { + attr.setImage(STATE_DISABLE, image); + } + + public Image getHoverImage() { + return attr.getImage(STATE_HOVER); + } + + public Image getNormalImage() { + return attr.getImage(STATE_NORMAL); + } + + public Image getPushImage() { + return attr.getImage(STATE_PUSH); + } + + public Image getDisableImage(Image image) { + return attr.getImage(STATE_DISABLE); + } + + public void setHoverColor(Color color) { + attr.setColor(STATE_HOVER, color); + } + + public void setNormalColor(Color color) { + attr.setColor(STATE_NORMAL, color); + } + + public void setPushColor(Color color) { + attr.setColor(STATE_PUSH, color); + } + + public void setDisableColor(Color color) { + attr.setColor(STATE_DISABLE, color); + } + + public void setVisible(boolean visible) { + setVisible(visible); + } + + public void setFont(Font font) { + attr.setFont(font); + } + + public void setFontPoint(Point p) { + attr.setFontPoint(p); + } + + public void setImages(Image normal, Image push, Image hover, Image disable) { + attr.setImage(STATE_NORMAL, normal); + attr.setImage(STATE_PUSH, push); + attr.setImage(STATE_HOVER, hover); + attr.setImage(STATE_DISABLE, disable); + } + + public void addClickListener(TizenButtonClickEventListener listener) { + addListener(SWT.MouseUp, listener); + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonClickEventListener.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonClickEventListener.java new file mode 100644 index 0000000..495fcbb --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonClickEventListener.java @@ -0,0 +1,26 @@ +package org.tizen.dynamicanalyzer.widgets.button; + +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; + +public abstract class TizenButtonClickEventListener implements Listener { + + @Override + public void handleEvent(Event event) { + TizenButton button = (TizenButton) event.widget; + if (null != button) { + Rectangle rectangle = button.getBounds(); + int x = event.x; + int y = event.y; + + if (x < 0 || x > rectangle.width || y < 0 || y > rectangle.height) { + return; + } + } + + handleClickEvent(event); + } + + public abstract void handleClickEvent(Event event); +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonRenderer.java new file mode 100644 index 0000000..ce4d432 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenButtonRenderer.java @@ -0,0 +1,83 @@ +package org.tizen.dynamicanalyzer.widgets.button; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Display; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + +public class TizenButtonRenderer extends TizenDefaultButtonRenderer { + + @Override + public void draw(GC gc, Canvas canvas, int state, TizenWidgetAttribute attr) { + Rectangle rect = canvas.getClientArea(); + + if (attr.getDrawType() == TizenButton.TYPE_IMAGE) { + Image image = attr.getImage(state); + if (null == image) { + return; + } + + gc.drawImage(image, rect.x, rect.y); + drawButtonText(gc, rect, attr); + } else if (attr.getDrawType() == TizenButton.TYPE_COLOR) { + Color color = attr.getColor(state); + drawButton(gc, rect, color, attr); + } else if (attr.getDrawType() == TizenButton.TYPE_GRADATION) { + // TODO: implement.. + } + } + + public int computeFontSize(Rectangle rect) { + if (rect.height > 20) + return 10; + else + return 8; + } + + public void drawButton(GC gc, Rectangle rect, Color c, + TizenWidgetAttribute attr) { + gc.setBackground(c); + gc.fillRectangle(rect); + Rectangle r = new Rectangle(0, 0, rect.width - 1, rect.height - 1); + drawButtonText(gc, r, attr); + c = gc.getForeground(); + gc.setForeground(ColorResources.BLACK); + gc.drawRectangle(r); + gc.setForeground(c); + } + + protected void drawButtonText(GC gc, Rectangle rect, TizenWidgetAttribute attr) { + String s = null; + Font f = null; + Point p = null; + if (null != (s = attr.getTitle())) { + if (null == (f = attr.getFont())) { + f = new Font(Display.getCurrent(), "Arial", + computeFontSize(rect), SWT.BOLD); + attr.setFont(f); + } + gc.setFont(f); + + int x = 0, y = 0; + int offset = 0; + if (null == (p = attr.getFontPoint())) { + p = gc.textExtent(s, SWT.DRAW_MNEMONIC); + x = (rect.width - p.x) / 2; + y = (rect.height - p.y) / 2; + x = (x < 0) ? 0 : x; + // rect size < text length -> insert offset + offset = ((x - rect.x) < 4) ? 4 : 0; + } else { + x = p.x; + y = p.y; + } + gc.drawString(s, x + offset, y, true); + } + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenDefaultButtonRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenDefaultButtonRenderer.java new file mode 100644 index 0000000..59f2c25 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenDefaultButtonRenderer.java @@ -0,0 +1,10 @@ +package org.tizen.dynamicanalyzer.widgets.button; + +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.widgets.Canvas; + +public abstract class TizenDefaultButtonRenderer { + public abstract void draw(GC gc, Canvas canvas, int state, + TizenWidgetAttribute attr); + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenWidgetAttribute.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenWidgetAttribute.java new file mode 100644 index 0000000..b7dc013 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/TizenWidgetAttribute.java @@ -0,0 +1,93 @@ +package org.tizen.dynamicanalyzer.widgets.button; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; + +public class TizenWidgetAttribute { + private final int MAX_SIZE = 10; + private String title; + private Font font; + private Point fontPoint; + private int drawType = TizenButton.TYPE_COLOR; + + private List images = new ArrayList(); + private List colors = new ArrayList(); + private boolean enabled; + + public TizenWidgetAttribute() { + enabled = true; + + // init array + for (int i = 0; i < MAX_SIZE; i++) { + images.add(null); + colors.add(null); + } + } + + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + public Font getFont() { + return font; + } + + public void setFont(Font font) { + this.font = font; + } + + public Point getFontPoint() { + return fontPoint; + } + + public void setFontPoint(Point fontPoint) { + this.fontPoint = fontPoint; + } + + public int getDrawType() { + return drawType; + } + + public void setDrawType(int type) { + drawType = type; + } + + public boolean isEnabled() { + return enabled; + } + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + } + + public Image getImage(int state) { + if (!images.isEmpty()) { + return images.get(state); + } + return null; + } + + public void setImage(int state, Image img) { + images.set(state, img); + } + + public Color getColor(int state) { + if (!colors.isEmpty()) { + return colors.get(state); + } + return null; + } + + public void setColor(int state, Color color) { + colors.set(state, color); + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButton.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButton.java new file mode 100644 index 0000000..dcfd8c7 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButton.java @@ -0,0 +1,80 @@ +package org.tizen.dynamicanalyzer.widgets.button.toggle; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.tizen.dynamicanalyzer.widgets.button.TizenButton; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + +public class TizenToggleButton extends TizenButton { + + public static final int STATE_TOGGLE = 4; + private boolean toggle = false; + + public TizenToggleButton(Composite parent, Image normal, Image mouseDown, + Image hover, Image disable, Image toggle) { + super(parent, normal, mouseDown, hover, disable); + buttonRenderer = new TizenToggleButtonRenderer(); + + attr.setImage(STATE_TOGGLE, toggle); + addListeners(); + } + + public TizenToggleButton(Composite parent, int style) { + super(parent, style); + buttonRenderer = new TizenToggleButtonRenderer(); + attr.setColor(STATE_TOGGLE, ColorResources.BLUE); + addListeners(); + } + + public void setToggled(boolean toggled) { + toggle = toggled; + } + + public boolean isToggled() { + return toggle; + } + + @Override + public void addListeners() { + if (null != toggleButtonMouseListener) { + this.addListener(SWT.MouseEnter, toggleButtonMouseListener); + this.addListener(SWT.MouseExit, toggleButtonMouseListener); + this.addListener(SWT.MouseDown, toggleButtonMouseListener); + this.addListener(SWT.MouseUp, toggleButtonMouseListener); + } + } + + private Listener toggleButtonMouseListener = new Listener() { + + @Override + public void handleEvent(Event event) { + if (state == STATE_DISABLE) { + return; + } + + if (event.type == SWT.MouseEnter) { + changeButtonState(STATE_HOVER); + } + + if (event.type == SWT.MouseExit) { + if (toggle) { + changeButtonState(STATE_TOGGLE); + } else { + changeButtonState(STATE_NORMAL); + } + } + + if (event.type == SWT.MouseDown) { + changeButtonState(STATE_PUSH); + } + + if (event.type == SWT.MouseUp) { // FIXME + toggle = !toggle; + changeButtonState(STATE_HOVER); + } + } + }; +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButtonRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButtonRenderer.java new file mode 100644 index 0000000..1f40cc2 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/button/toggle/TizenToggleButtonRenderer.java @@ -0,0 +1,33 @@ +package org.tizen.dynamicanalyzer.widgets.button.toggle; + +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; +import org.tizen.dynamicanalyzer.widgets.button.TizenButton; +import org.tizen.dynamicanalyzer.widgets.button.TizenButtonRenderer; +import org.tizen.dynamicanalyzer.widgets.button.TizenWidgetAttribute; + +public class TizenToggleButtonRenderer extends TizenButtonRenderer { + + @Override + public void draw(GC gc, Canvas canvas, int state, TizenWidgetAttribute attr) { + Rectangle rect = canvas.getClientArea(); + if (attr.getDrawType() == TizenButton.TYPE_IMAGE) { + Image image = attr.getImage(state); + if (null == image) { + return; + } + + gc.drawImage(image, rect.x, rect.y); + drawButtonText(gc, rect, attr); + } else if (attr.getDrawType() == TizenButton.TYPE_COLOR) { + Color color = attr.getColor(state); + drawButton(gc, rect, color, attr); + } else if (attr.getDrawType() == TizenButton.TYPE_GRADATION) { + // TODO: implement.. + } + } + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboPopupRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboPopupRenderer.java new file mode 100644 index 0000000..f64add1 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboPopupRenderer.java @@ -0,0 +1,50 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import java.util.List; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + + +public class DefaultTizenComboPopupRenderer extends TizenComboPopupRenderer { + + @Override + public void draw(GC gc, Canvas canvas, int state, List rects, + int selection, List items) { + int size = rects.size(); + for (int i = 0; i < size; i++) { + Rectangle r = rects.get(i); + gc.setBackground(ColorResources.WINDOW_BG_COLOR); + if (selection == i) { + gc.setBackground(ColorResources.RED); + gc.fillRectangle(r); + gc.setBackground(ColorResources.WINDOW_BG_COLOR); + } + gc.setForeground(ColorResources.WHITE); + gc.drawRectangle(r.x, r.y, r.width - 1, r.height - 1); + Point p = gc.textExtent(items.get(i), SWT.DRAW_MNEMONIC); + gc.drawString(items.get(i), 5, (r.height - p.y) / 2 + i * r.height, + true); + } + } + + @Override + public void drawPattern(GC gc, Canvas canvas, Image patternImage, + int state, List rects, int selection, List items) { + // TODO Auto-generated method stub + + } + + @Override + public void drawImage(GC gc, Canvas canvas, Image image, int state, + List rects, int selection, List items) { + // TODO Auto-generated method stub + + } + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboRenderer.java new file mode 100644 index 0000000..fb90f3e --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/DefaultTizenComboRenderer.java @@ -0,0 +1,50 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + + +public class DefaultTizenComboRenderer extends TizenComboRenderer { + + @Override + public void draw(GC gc, Canvas canvas, String text, int state) { + Rectangle rect = canvas.getClientArea(); + if (state == TizenCombo.STATE_NORMAL) { + gc.setBackground(ColorResources.WINDOW_BG_COLOR); + } else if (state == TizenCombo.STATE_HOVER) { + gc.setBackground(ColorResources.ITEM_BLUE_DARK); + } else if (state == TizenCombo.STATE_PUSH) { + gc.setBackground(ColorResources.BLUE); + } else if (state == TizenCombo.STATE_DISABLE) { + gc.setBackground(ColorResources.BAR_GRAY1); + } + gc.fillRectangle(rect); + gc.drawRectangle(rect.x, rect.y, rect.width - 20, rect.height - 1); + + if (null == text) { + text = ""; //$NON-NLS-1$ + } + Point p = gc.textExtent(text, SWT.DRAW_MNEMONIC); + gc.drawString(text, 5, (rect.height - p.y)/2, true); + gc.fillRectangle(rect.x + rect.width - 20, rect.y, 19, rect.height - 1); + gc.drawRectangle(rect.x + rect.width - 20, rect.y, 19, rect.height - 1); + } + + @Override + public void drawPattern(GC gc, Canvas canvas, Image patternImage, + String text, int state) { + + } + + @Override + public void drawImage(GC gc, Canvas canvas, Image image, String text, + int state) { + + } + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenCombo.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenCombo.java new file mode 100644 index 0000000..543ccf5 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenCombo.java @@ -0,0 +1,588 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import java.util.ArrayList; +import java.util.List; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.MouseEvent; +import org.eclipse.swt.events.MouseListener; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.events.PaintListener; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.layout.FormAttachment; +import org.eclipse.swt.layout.FormData; +import org.eclipse.swt.layout.FormLayout; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; +import org.eclipse.swt.widgets.Shell; +import org.tizen.dynamicanalyzer.widgets.button.TizenButton; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; + +public class TizenCombo extends Canvas { + public static final int MAX_SIZE = 10; + public static final int STATE_NORMAL = 0; + public static final int STATE_HOVER = 1; + public static final int STATE_PUSH = 2; + public static final int STATE_DISABLE = 3; + + private static final int pageSize = 5; + + Composite parent; + private Canvas combo = null; + private Canvas popup = null; + private int itemHeight = 0; + private TizenButton upArrowButton = null; + private TizenButton downArrowButton = null; + private int itemIndex = 0; + + private List items; + private List rects = null; + + private List images = null; + private boolean enabled = true; + private Shell childShell = null; + private int selection = 0; + private String text = ""; //$NON-NLS-1$ + private boolean imgCombo = false; + private int state = STATE_NORMAL; // 0 normal 1 hover 2 push 3 disable + private TizenComboRenderer comboRenderer = new DefaultTizenComboRenderer();; + private TizenComboPopupRenderer popupRenderer = new DefaultTizenComboPopupRenderer(); + + public TizenCombo(Composite parent, int style) { + super(parent, style); + combo = this; + + this.parent = parent; + addPaintListener(comboPaintListener); + setForeground(ColorResources.WHITE); + addListeners(); + } + + public void addListeners() { + addListener(SWT.MouseEnter, comboMouseListener); + addListener(SWT.MouseHover, comboMouseListener); + addListener(SWT.MouseExit, comboMouseListener); + addListener(SWT.MouseDown, comboMouseListener); + addListener(SWT.MouseMove, comboMouseListener); + addListener(SWT.MouseUp, comboMouseListener); + } + + public String getText() { + if (getItems().size() > 0) { + return getItems().get(itemIndex + selection); + } + return null; + } + + public List getItems() { + if (null == items) { + items = new ArrayList(); + } + return items; + } + + private List getRects() { + if (null == rects) { + rects = new ArrayList(); + } + return rects; + } + + private void changeComboState(int s) { + state = s; + redraw(); + } + + private Listener popupSelectionListener = new TizenComboSelectionListener() { + + @Override + public void selectionEvent(TizenCombo combo) { + System.out.println("default selection" + combo.getText()); + } + }; + + public void addSelectionListener(TizenComboSelectionListener listener) { + popupSelectionListener = listener; + } + + private Listener comboMouseListener = new Listener() { + @Override + public void handleEvent(Event event) { + if (enabled) { + if (event.type == SWT.MouseEnter) { + changeComboState(STATE_HOVER); + } + + if (event.type == SWT.MouseHover) { + if (!isOutOfBounds(event.x, event.y)) { + if (0 != (event.stateMask & SWT.BUTTON1)) { + changeComboState(STATE_PUSH); + } else if (0 == (event.stateMask & SWT.BUTTON1)) { + changeComboState(STATE_HOVER); + } + } + } + + if (event.type == SWT.MouseDown) { + changeComboState(STATE_PUSH); + } + + if (event.type == SWT.MouseUp) { + changeComboState(STATE_HOVER); + if (childShell == null || childShell.isDisposed()) { + openChildShell(); + } else { + childShell.close(); + childShell = null; + } + } + + if (event.type == SWT.MouseMove) { + if (isOutOfBounds(event.x, event.y)) { + changeComboState(STATE_NORMAL); + } else if (isOutOfBounds(event.x, event.y)) { + if (0 != (event.stateMask & SWT.BUTTON1)) { + changeComboState(STATE_PUSH); + } else if (0 == (event.stateMask & SWT.BUTTON1)) { + changeComboState(STATE_HOVER); + } + } + } + + if (event.type == SWT.MouseExit) { + changeComboState(STATE_NORMAL); + } + } + } + }; + + protected boolean isOutOfBounds(int x, int y) { + Rectangle rectangle = combo.getBounds(); + + if (x < 0 || x > rectangle.width || y < 0 || y > rectangle.height) { + return true; + } + + return false; + } + + private int getShellWidth() { + if (getItems().isEmpty()) { + return 0; + } + int max = 0; + int size = items.size(); + GC gc = new GC(parent.getDisplay(), SWT.NONE); + for (int i = 0; i < size; i++) { + Point p = gc.textExtent(items.get(i), SWT.DRAW_MNEMONIC); + if (p.x > max) { + max = p.x; + } + } + max += 10; + gc.dispose(); + return max; + } + + public int getItemHeight() { + return itemHeight; + } + + public void setItemHeight(int height) { + itemHeight = height; + } + + private void openChildShell() { + childShell = new Shell(parent.getShell(), SWT.ON_TOP); + childShell.setLayout(new FormLayout()); + + Point p = combo.toDisplay(0, 0); + Rectangle rect = combo.getBounds(); + int size = getItems().size(); + + int boundSize = (size > MAX_SIZE) ? MAX_SIZE : (size > 0) ? size : 1; + + int textSize = getShellWidth() + 4; + int shellWidth = (textSize > rect.width) ? textSize : rect.width + 4; + int height = 0; + + if (getItemHeight() == 0) { + height = rect.height; + } else { + height = getItemHeight(); + } + int shellHeight = height * boundSize + 5; + + childShell.setSize(shellWidth, shellHeight); + childShell.setLocation(p.x, p.y + rect.height); + + popup = new Canvas(childShell, SWT.DOUBLE_BUFFERED); + popup.setData(this); + popup.setBackground(ColorResources.WINDOW_BG_COLOR); + popup.addPaintListener(popupPaintListener); + popup.addListener(SWT.MouseUp, popupMouseEventListener); + popup.addListener(SWT.MouseMove, popupMouseEventListener); + popup.addListener(SWT.FocusOut, popupMouseEventListener); + popup.addListener(SWT.MouseUp, popupSelectionListener); + popup.addListener(SWT.MouseWheel, popupMouseEventListener); + + if (size > MAX_SIZE) { + upArrowButton = new TizenButton(childShell, SWT.NONE); + upArrowButton.setText("up"); //$NON-NLS-1$ + FormData data = new FormData(); + data.top = new FormAttachment(0, 0); + data.left = new FormAttachment(0, 0); + data.right = new FormAttachment(100, 0); + data.height = height; + upArrowButton.setLayoutData(data); + upArrowButton.addMouseListener(upArrowListener); + upArrowButton.addListener(SWT.MouseExit, upButtonMouseExitListener); + shellHeight += height; + upArrowButton.setEnabled(false); + + data = new FormData(); + data.top = new FormAttachment(upArrowButton, 0); + data.left = new FormAttachment(0, 0); + data.right = new FormAttachment(100, 0); + data.height = height * boundSize + 5 - 2; + popup.setLayoutData(data); + + downArrowButton = new TizenButton(childShell, SWT.NONE); + downArrowButton.setText("down"); //$NON-NLS-1$ + data = new FormData(); + data.top = new FormAttachment(popup, 0); + data.left = new FormAttachment(0, 0); + data.right = new FormAttachment(100, 0); + data.height = height; + downArrowButton.setLayoutData(data); + downArrowButton.addMouseListener(downArrowListener); + downArrowButton.addListener(SWT.MouseExit, + downButtonMouseExitListener); + shellHeight += height; + + childShell.setSize(shellWidth, shellHeight); + } else { + FormData data = new FormData(); + data.top = new FormAttachment(0, 0); + data.left = new FormAttachment(0, 0); + data.right = new FormAttachment(100, 0); + data.height = shellHeight - 2; + popup.setLayoutData(data); + } + + size = (size > MAX_SIZE) ? MAX_SIZE : size; + getRects().clear(); + for (int i = 0; i < size; i++) { + Rectangle r = new Rectangle(2, 2 + i * height, shellWidth - 2, + height); + getRects().add(r); + } + childShell.open(); + } + + private MouseListener upArrowListener = new MouseListener() { + + @Override + public void mouseUp(MouseEvent event) { + if (!upArrowButton.isEnabled()) { + return; + } + + if (null != upArrowButton) { + Rectangle rectangle = upArrowButton.getBounds(); + int x = event.x; + int y = event.y; + + if (x < 0 || x > rectangle.width || y < 0 + || y > rectangle.height) { + return; + } + } + + int size = getItems().size(); + if (itemIndex - pageSize < 0) { + itemIndex = 0; + upArrowButton.setEnabled(false); + } else { + itemIndex -= pageSize; + } + + if (itemIndex + pageSize < size - 1) { + downArrowButton.setEnabled(true); + } + popup.redraw(); + } + + @Override + public void mouseDown(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseDoubleClick(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + }; + + private MouseListener downArrowListener = new MouseListener() { + + @Override + public void mouseUp(MouseEvent event) { + + if (!downArrowButton.isEnabled()) { + return; + } + + if (null != downArrowButton) { + Rectangle rectangle = downArrowButton.getBounds(); + int x = event.x; + int y = event.y; + + if (x < 0 || x > rectangle.width || y < 0 + || y > rectangle.height) { + return; + } + } + + int size = getItems().size(); + if (itemIndex + pageSize + MAX_SIZE >= size - 1) { + itemIndex = size - MAX_SIZE; + downArrowButton.setEnabled(false); + } else { + itemIndex += pageSize; + } + + if (itemIndex - pageSize > 0) { + upArrowButton.setEnabled(true); + } + popup.redraw(); + } + + @Override + public void mouseDown(MouseEvent arg0) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseDoubleClick(MouseEvent arg0) { + // TODO Auto-generated method stub + } + }; + + private PaintListener popupPaintListener = new PaintListener() { + + @Override + public void paintControl(PaintEvent e) { + List items = getItems(); + List input = new ArrayList(); + int size = (items.size() > MAX_SIZE) ? MAX_SIZE : items.size(); + for (int i = 0; i < size; i++) { + input.add(items.get(itemIndex + i)); + } + popupRenderer + .draw(e.gc, popup, state, getRects(), selection, input); + } + }; + + public void setText(String text) { + if (!setSelect(text)) { + this.text = text; + redraw(); + } + } + + private boolean setSelect(String text) { + if (getItems().isEmpty()) { + return false; + } + + int index = items.indexOf(text); + if (index < 0) { + return false; + } + int size = items.size(); + if (index + MAX_SIZE >= size) { + int lower = size - index; + selection = MAX_SIZE - lower; + itemIndex = size - MAX_SIZE; + select(selection); + } else { + selection = index - itemIndex; + select(selection); + } + return true; + } + + public void upEvent() { + if (getItems().size() > 0) { + setText(getItems().get(itemIndex + selection)); + } else { + setText(""); //$NON-NLS-1$ + } + childShell.close(); + childShell = null; + } + + private Listener popupMouseEventListener = new Listener() { + + @Override + public void handleEvent(Event event) { + if (event.type == SWT.MouseMove) { + List rs = getRects(); + int size = rs.size(); + for (int i = 0; i < size; i++) { + if (rs.get(i).contains(event.x, event.y)) { + selection = i; + popup.redraw(); + break; + } + } + } + + if (event.type == SWT.FocusOut) { + childShell.close(); + childShell = null; + } + + if (event.type == SWT.MouseWheel) { + int size = getItems().size(); + if (null != downArrowButton && null != upArrowButton) { + if (event.count < 0) { + if (itemIndex - event.count + MAX_SIZE >= size - 1) { + itemIndex = size - MAX_SIZE; + downArrowButton.setEnabled(false); + } else { + itemIndex -= event.count; + } + + if (itemIndex - pageSize > 0) { + upArrowButton.setEnabled(true); + } + } else { + + if (itemIndex - event.count < 0) { + itemIndex = 0; + upArrowButton.setEnabled(false); + } else { + itemIndex -= event.count; + } + + if (itemIndex + event.count < size - 1) { + downArrowButton.setEnabled(true); + } + } + popup.redraw(); + } + } + } + }; + + public void setEnabled(boolean enabled) { + this.enabled = enabled; + if (enabled) { + changeComboState(STATE_NORMAL); + if (isImageCombo()) { + setBackgroundImage(images.get(STATE_NORMAL)); + } + } else { + changeComboState(STATE_DISABLE); + if (isImageCombo()) { + setBackgroundImage(images.get(STATE_DISABLE)); + } + } + } + + private PaintListener comboPaintListener = new PaintListener() { + + @Override + public void paintControl(PaintEvent e) { + if (!isImageCombo()) { + comboRenderer.draw(e.gc, combo, text, state); + } else { + comboRenderer.drawImage(e.gc, combo, images.get(state), text, + state); + } + } + }; + + public void setComboRender(TizenComboRenderer newRenderer) { + comboRenderer = newRenderer; + } + + public void setComboPopupRender(TizenComboPopupRenderer newRenderer) { + popupRenderer = newRenderer; + } + + public void removeAll() { + getItems().clear(); + } + + public void add(String item) { + getItems().add(item); + } + + public void select(int index) { + selection = index; + this.text = items.get(itemIndex + selection); + redraw(); + } + + public String getItem(int index) { + if (getItems().size() > 0) { + return getItems().get(index); + } + return ""; //$NON-NLS-1$ + } + + public void setImages(Image normal, Image hover, Image push, Image disable) { + if (null == normal || null == hover || null == push || null == disable) { + return; + } + List imgs = getImages(); + + imgs.add(normal); + imgs.add(hover); + imgs.add(push); + imgs.add(disable); + setImageCombo(true); + } + + private List getImages() { + if (null == images) { + images = new ArrayList(); + } + return images; + } + + private void setImageCombo(boolean b) { + this.imgCombo = b; + } + + public boolean isImageCombo() { + return imgCombo; + } + + private Listener upButtonMouseExitListener = new Listener() { + + @Override + public void handleEvent(Event event) { + } + }; + + private Listener downButtonMouseExitListener = new Listener() { + + @Override + public void handleEvent(Event event) { + + } + }; + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboPopupRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboPopupRenderer.java new file mode 100644 index 0000000..3806fde --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboPopupRenderer.java @@ -0,0 +1,19 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import java.util.List; + +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.widgets.Canvas; + +public abstract class TizenComboPopupRenderer { + public abstract void draw(GC gc, Canvas canvas, int state, + List rects, int selection, List items); + + public abstract void drawPattern(GC gc, Canvas canvas, Image patternImage, + int state, List rects, int selection, List items); + + public abstract void drawImage(GC gc, Canvas canvas, Image image, + int state, List rects, int selection, List items); +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboRenderer.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboRenderer.java new file mode 100644 index 0000000..0822d8e --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboRenderer.java @@ -0,0 +1,11 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.Image; +import org.eclipse.swt.widgets.Canvas; + +public abstract class TizenComboRenderer { + public abstract void draw(GC gc, Canvas canvas, String text, int state); + public abstract void drawPattern(GC gc, Canvas canvas, Image patternImage, String text, int state); + public abstract void drawImage(GC gc, Canvas canvas, Image image, String text, int state); +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboSelectionListener.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboSelectionListener.java new file mode 100644 index 0000000..8fb13b0 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/combo/TizenComboSelectionListener.java @@ -0,0 +1,20 @@ +package org.tizen.dynamicanalyzer.widgets.combo; + +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Listener; + +public abstract class TizenComboSelectionListener implements Listener { + + @Override + public void handleEvent(Event event) { + Canvas popup = (Canvas) event.widget; + TizenCombo combo = (TizenCombo) popup.getData(); + if (null != combo) { + selectionEvent(combo); + combo.upEvent(); + } + } + + public abstract void selectionEvent(TizenCombo combo); +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/graph/circular/CircularGraph.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/graph/circular/CircularGraph.java new file mode 100644 index 0000000..87728ef --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/graph/circular/CircularGraph.java @@ -0,0 +1,186 @@ +package org.tizen.dynamicanalyzer.widgets.graph.circular; + +import org.eclipse.swt.SWT; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.events.PaintListener; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.Point; +import org.eclipse.swt.graphics.Rectangle; +import org.eclipse.swt.layout.FormAttachment; +import org.eclipse.swt.layout.FormData; +import org.eclipse.swt.layout.FormLayout; +import org.eclipse.swt.widgets.Canvas; +import org.eclipse.swt.widgets.Composite; +import org.eclipse.swt.widgets.Label; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; +import org.tizen.dynamicanalyzer.widgets.helper.Formatter; + +public class CircularGraph extends Composite { + + private final int DEFAULT_ANGLE = 90; + private Color defaultGraphColor = ColorResources.ITEM_BLUE_BRIGHT; + private Color defaultGraphBgcolor = ColorResources.TITLEBAR_BG_COLOR; + public static final int TYPE_PERCENT = 0; + public static final int TYPE_CUSTOM = 1; + + private Canvas canvas; + private Label label; + private Font font; + private long max = 100; + private long value = 0; + private Color graphColor = defaultGraphColor; + private Color bgColor = defaultGraphBgcolor; + private String measure; + private int type = TYPE_PERCENT; + private Color textColor = defaultGraphColor; + + public CircularGraph(Composite parent, int style, int type) { + super(parent, style); + this.setLayout(new FormLayout()); + this.type = type; + + if (type == TYPE_PERCENT) { + measure = "%"; //$NON-NLS-1$ + } else { + measure = ""; //$NON-NLS-1$ + } + + canvas = new Canvas(this, SWT.DOUBLE_BUFFERED); + canvas.addPaintListener(paintListener); + FormData data = new FormData(); + data.top = new FormAttachment(0, 0); + data.left = new FormAttachment(0, 0); + data.width = 74; + data.height = 74; + canvas.setLayoutData(data); + + label = new Label(this, SWT.TRANSPARENT); + label.setForeground(textColor); + font = getShell().getDisplay().getSystemFont(); + label.setFont(font); + label.setAlignment(SWT.CENTER); + data = new FormData(); + data.top = new FormAttachment(canvas, 1); + data.left = new FormAttachment(0, 0); + data.height = 25; + data.width = 76; + label.setLayoutData(data); + } + + private PaintListener paintListener = new PaintListener() { + + @Override + public void paintControl(PaintEvent e) { + Rectangle rect = canvas.getBounds(); + int x = rect.x; + int y = rect.y; + int width = rect.width; + int height = rect.height; + if (width > height) { + x += (rect.width - rect.height) / 2; + width = height; + } else if (width < height) { + y += (rect.height - rect.width) / 2; + height = width; + } + + e.gc.setAntialias(SWT.ON); + e.gc.setBackground(bgColor); + e.gc.fillOval(x, y, width, height); + e.gc.setBackground(graphColor); + e.gc.fillArc(x, y, width, height, DEFAULT_ANGLE, calculateAngle()); + e.gc.setBackground(ColorResources.BLACK); + e.gc.fillOval(x + 9, y + 9, 56, 56); + + // Draws text. + String center = getCenterText(); + + e.gc.setFont(font); + e.gc.setForeground(graphColor); + Point textSize = e.gc.textExtent(center, SWT.DRAW_MNEMONIC); + e.gc.drawText(center, (rect.width - textSize.x) / 2, 28 - 6, true); + // (rect.height - textSize.y) / 2 - 5, true); + + e.gc.setFont(font); + e.gc.setForeground(graphColor); + Point measureSize = e.gc.textExtent(measure, SWT.DRAW_MNEMONIC); + e.gc.drawText(measure, (rect.width - measureSize.x) / 2, 46 - 4, + true); + // (rect.height - measureSize.y) / 2 - 5 + textSize.y, true); + } + }; + + public void setMax(long max) { + this.max = max; + canvas.redraw(); + } + + public void update(long max, long value) { + this.max = max; + this.value = value; + canvas.redraw(); + } + + public void update(long value) { + this.value = value; + canvas.redraw(); + } + + private int calculateAngle() { + int angle = (int) (360 * ((float) value / max)) * (-1); + return angle; + } + + public void setText(String text) { + label.setForeground(textColor); + label.setText(text); + } + + public void setFont(Font font) { + label.setFont(font); + this.font = font; + } + + public void setTextColor(Color color) { + textColor = color; + } + + private String getCenterText() { + String str = null; + if (type == TYPE_PERCENT) { + int percent = (int) (((float) value / max) * 100); + str = Integer.toString(percent); + } else { + // type : memory size + if (value >= 1024) { + double dValue = (value) / 1024.; + if (dValue >= 1024. * 1024) { + dValue = (dValue) / 1024. * 1024; + setMeasure("GB"); //$NON-NLS-1$ + } else if (dValue >= 1024.) { + dValue = (dValue) / 1024.0; + setMeasure("MB"); //$NON-NLS-1$ + } else { + setMeasure("KB"); //$NON-NLS-1$ + } + str = Formatter.toDoubleFormat1(Double.toString(dValue)); + } else { + str = Long.toString(value); + } + } + return str; + } + + public void setMeasure(String m) { + measure = m; + } + + public void setGraphColor(Color color) { + graphColor = color; + } + + public void setGraphBgColor(Color color) { + bgColor = color; + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ColorResources.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ColorResources.java new file mode 100644 index 0000000..76b2644 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ColorResources.java @@ -0,0 +1,313 @@ +/* + * Dynamic Analyzer + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Jooyoul Lee + * Juyoung Kim + * + * This program and the accompanying materials are made available + * under the terms of the Eclipse Public License v1.0 + * which accompanies this distribution, and is available at + * http://www.eclipse.org/legal/epl-v10.html + * + * Contributors: + * - S-Core Co., Ltd + * + */ +package org.tizen.dynamicanalyzer.widgets.helper; + +import org.eclipse.jface.resource.ColorRegistry; +import org.eclipse.swt.graphics.Color; +import org.eclipse.swt.graphics.RGB; + +public class ColorResources { + + private static ColorRegistry colorRegistry = new ColorRegistry(); + + public static final Color WHITE = getColor("white", new RGB(255, 255, 255)); //$NON-NLS-1$ + public static final Color BLACK = getColor("black", new RGB(0, 0, 0)); //$NON-NLS-1$ + public static final Color BLUE = getColor("blue", new RGB(0, 0, 255)); //$NON-NLS-1$ + public static final Color RED = getColor("red", new RGB(255, 0, 0)); //$NON-NLS-1$ + public static final Color PURPLE = getColor("PUPLE", new RGB(226, 101, 225)); //$NON-NLS-1$ + + // shell window background color + public static final Color WINDOW_BG_COLOR = getColor( + "window_bg_color", new RGB(51, 52, 53)); //$NON-NLS-1$ + // + // /** title bar colors **/ + // public static final Color TITLEBAR_TEXT_COLOR = getColor( + // "titlebar_text_color", new RGB(64, 208, 255)); //$NON-NLS-1$ + // + public static final Color TITLEBAR_BG_COLOR = getColor( + "titlebar_bg", new RGB(78, 79, 81)); //$NON-NLS-1$ + // + // /** device and application combo specific colors start **/ + // public static final Color DEVICE_APPLICATION_ENABLE = WHITE; + // + // public static final Color DEVICE_APPLICATION_DISABLE = getColor( + // "device_application_disable", new RGB(128, 128, 128)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_POPUP_OUTER_1 = getColor( + // "device_application_popup_outer_1", new RGB(31, 31, 31)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_POPUP_OUTER_2 = getColor( + // "device_application_popup_outer_2", new RGB(31, 137, 163)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_DROPDOWN_TEXT = WHITE; + // + // public static final Color DEVICE_APPLICATION_ITEM_NORMAL_TOP = getColor( + // "device_application_item_normal_top", new RGB(76, 76, 77)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_ITEM_NORMAL_INNER = + // getColor( + // "device_application_item_normal_inner", new RGB(66, 66, 67)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_ITEM_NORMAL_BOTTOM = + // getColor( + // "device_application_item_normal_bottom", new RGB(56, 56, 60)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_ITEM_SELECT_TOP = getColor( + // "device_application_item_select_top", new RGB(76, 76, 77)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_ITEM_SELECT_INNER = + // getColor( + // "device_application_item_select_inner", new RGB(0, 151, 201)); //$NON-NLS-1$ + // + // public static final Color DEVICE_APPLICATION_ITEM_SELECT_BOTTOM = + // getColor( + // "device_application_item_select_bottom", new RGB(56, 56, 60)); //$NON-NLS-1$ + // + // /** device and application combo specific colors end **/ + // + // /** normal view layout colors start **/ + // + // public static final Color NORMAL_VIEW_LAYOUT_OUTER = getColor( + // "normal_view_layout_outer", new RGB(160, 160, 160)); //$NON-NLS-1$ + // + // public static final Color NORMAL_VIEW_LAYOUT_MIDDLE = getColor( + // "normal_view_layout_middle", new RGB(74, 74, 74)); //$NON-NLS-1$ + // + // public static final Color NORMAL_VIEW_LAYOUT_INNER = getColor( + // "normal_view_layout_inner", new RGB(66, 66, 68)); //$NON-NLS-1$ + // + // /** normal view layout colors end **/ + // + // /** current view colors start **/ + // public static final Color CURRENT_VIEW_OUTLINE = getColor( + // "current_view_outline", new RGB(160, 160, 160)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_TITLE_TEXT = WHITE; + // public static final Color CURRENT_VIEW_MIDDLE = + // NORMAL_VIEW_LAYOUT_MIDDLE; + // public static final Color CURRENT_VIEW_INNER = NORMAL_VIEW_LAYOUT_INNER; + // + // public static final Color CURRENT_VIEW_TABLE_TITLE_BG = getColor( + // "current_view_table_title_bg", new RGB(59, 59, 60)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_TABLE_TITLE_TEXT = getColor( + // "current_view_table_title_text", new RGB(151, 230, 255)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_TABLE_CONTENTS_BG = getColor( + // "current_view_table_contents_bg", new RGB(84, 85, 86)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_TABLE_CONTENTS_TEXT = getColor( + // "current_view_table_contents_text", new RGB(216, 216, 216)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_TABLE_LINE = getColor( + // "current_view_table_line", new RGB(136, 137, 138)); //$NON-NLS-1$ + // + // public static final Color CURRENT_VIEW_CPU_TEXT = getColor( + // "current_view_cpu_text", new RGB(2, 171, 208)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_PROCESS_TEXT = getColor( + // "current_view_process_text", new RGB(114, 203, 8)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_GRAPH_BG = getColor( + // "current_view_graph_bg", new RGB(79, 79, 81)); //$NON-NLS-1$ + // public static final Color CURRENT_VIEW_CPU_GRAPH = CURRENT_VIEW_CPU_TEXT; + // public static final Color CURRENT_VIEW_PROCESS_GRAPH = + // CURRENT_VIEW_PROCESS_TEXT; + // public static final Color CURRENT_VIEW_GRAPH_OUTLINE = getColor( + // "current_view_graph_outline", new RGB(43, 44, 45)); //$NON-NLS-1$ + // + // public static final Color CURRENT_VIEW_SNAPSHOT_OUTLINE = getColor( + // "current_view_snapshot_outline", new RGB(49, 104, 127)); //$NON-NLS-1$ + // /** current view colors end **/ + // + // /** common table colors start **/ + // public static final Color TABLE_HEADER_BG = getColor( + // "table_header_bg", new RGB(59, 59, 60)); //$NON-NLS-1$ + // public static final Color TABLE_LINE = getColor( + // "table_line", new RGB(136, 137, 138)); //$NON-NLS-1$ + // public static final Color TABLE_CONTENTS_NORMAL = getColor( + // "table_contents_normal", new RGB(84, 85, 86)); //$NON-NLS-1$ + // public static final Color TABLE_CONTENTS_HOVER = getColor( + // "table_contents_hover", new RGB(72, 98, 108)); //$NON-NLS-1$ + // public static final Color TABLE_CONTENTS_SELECTED_START = getColor( + // "table_contents_selected_start", new RGB(0, 146, 193)); //$NON-NLS-1$ + // public static final Color TABLE_CONTENTS_SELECTED_END = getColor( + // "table_contents_selected_end", new RGB(0, 60, 79)); //$NON-NLS-1$ + // public static final Color TABLE_HEADER_FONT_COLOR = getColor( + // "table_title_font_color", new RGB(151, 230, 255)); //$NON-NLS-1$ + // public static final Color TABLE_CONTENTS_FONT_COLOR = getColor( + // "table_contents_font_color", new RGB(216, 216, 216)); //$NON-NLS-1$ + // /** common table colors end **/ + // + // /** open trace popup colors **/ + // public static final Color OPEN_TRACE_POPUP_CONTENTS_BG_COLOR = getColor( + // "open_trace_popup_contents_bg_color", new RGB(51, 52, 53)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_POPUP_BOTTOM_BG_COLOR = getColor( + // "open_trace_popup_bottom_bg_color", new RGB(39, 39, 40)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_TITLE_TEXT_COLOR = + // TITLEBAR_TEXT_COLOR; + // public static final Color OPEN_TRACE_INNERTITLE_TEXT_COLOR = WHITE; + // public static final Color OPEN_TRACE_BUTTON_TEXT_COLOR = WHITE; + // public static final Color OPEN_TRACE_TABLE_OUTLINE_COLOR = + // CURRENT_VIEW_TABLE_LINE; + // public static final Color OPEN_TRACE_TABLE_LINE1_NORMAL = getColor( + // "open_trace_table_line1_normal", new RGB(78, 78, 79)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_TABLE_LINE1_HOVER = getColor( + // "open_trace_table_line1_hover", new RGB(72, 98, 108)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_TABLE_LINE_SELECTED_START = + // getColor( + // "open_trace_table_line_selected_start", new RGB(0, 146, 193)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_TABLE_LINE_SELECTED_END = getColor( + // "open_trace_table_line_selected_end", new RGB(0, 60, 79)); //$NON-NLS-1$ + // + // public static final Color OPEN_TRACE_TABLE_LINE2_NORMAL = getColor( + // "open_trace_table_line2_normal", new RGB(84, 85, 86)); //$NON-NLS-1$ + // public static final Color OPEN_TRACE_TABLE_LINE2_HOVER = getColor( + // "open_trace_table_line2_hover", new RGB(72, 98, 108)); //$NON-NLS-1$ + // + // public static final Color OPEN_TRACE_TABLE2_FONT_COLOR = getColor( + // "open_trace_table2_font_color", new RGB(255, 85, 57)); //$NON-NLS-1$ + // + // /** snapshot viewer colors **/ + // public static final Color SNAPSHOT_VIEWER_BORDER = getColor( + // "snapshot_viewer_border", new RGB(49, 104, 127)); //$NON-NLS-1$ + // + // /** File chart colors **/ + // public static final Color FILE_CLOSED_START = getColor( + // "file_closed_start", new RGB(168, 198, 71)); //$NON-NLS-1$ + // public static final Color FILE_CLOSED_END = getColor( + // "file_closed_end", new RGB(130, 152, 54)); //$NON-NLS-1$ + // public static final Color FILE_USED_START = getColor( + // "file_used_start", new RGB(58, 138, 203)); //$NON-NLS-1$ + // public static final Color FILE_USED_END = getColor( + // "file_used_end", new RGB(44, 104, 153)); //$NON-NLS-1$ + // public static final Color FILE_OPEN_START = getColor( + // "file_open_start", new RGB(255, 135, 82)); //$NON-NLS-1$ + // public static final Color FILE_OPEN_END = getColor( + // "file_open_end", new RGB(232, 73, 73)); //$NON-NLS-1$ + // public static final Color FILE_FAILED_START = getColor( + // "file_failed_start", new RGB(226, 58, 242)); //$NON-NLS-1$ + // public static final Color FILE_FAILED_END = getColor( + // "file_failed_end", new RGB(164, 40, 176)); //$NON-NLS-1$ + // public static final Color FILE_CHART_SELECTION_BG = getColor( + // "file_chart_selection_bg", new RGB(0, 151, 201)); //$NON-NLS-1$ + // public static final Color FILE_CHART_PARENT_BG = getColor( + // "file_chart_parent_bg", new RGB(84, 85, 86)); //$NON-NLS-1$ + // public static final Color FILE_CHART_CHILD_BG = getColor( + // "file_chart_child_bg", new RGB(59, 59, 60)); //$NON-NLS-1$ + // + // + // + // public static final Color VIEW_BORDER = getColor( + // "view_border", new RGB(74, 74, 74)); //$NON-NLS-1$ + // public static final Color VIEW_BG_COLOR = getColor( + // "view_bg_color", new RGB(66, 66, 68)); //$NON-NLS-1$ + // + // public static final Color TAB_BG_COLOR = VIEW_BG_COLOR; //$NON-NLS-1$ + // public static final Color TABLE_BG_COLOR = getColor( + // "table_bg_color", new RGB(84, 85, 87)); //$NON-NLS-1$ + // public static final Color TABLE_HEADER_COLOR = getColor( + // "table_header_color", new RGB(59, 59, 61)); //$NON-NLS-1$ + // // public static final Color TABLE_HEADER_FONT_COLOR = getColor( + // // "table_header_font_color", new RGB(75, 229, 253)); //$NON-NLS-1$ + // public static final Color TABLE_LINE_COLOR = getColor( + // "table_line_color", new RGB(96, 97, 99)); //$NON-NLS-1$ + // + // public static final Color UNSELECTED_TAB_FIRST = getColor( + // "unselected_tab_first", new RGB(51, 51, 51)); //$NON-NLS-1$ + // public static final Color UNSELECTED_TAB_SECOND = getColor( + // "unselected_tab_second", new RGB(42, 42, 42)); //$NON-NLS-1$ + // public static final Color SELECTED_TAB_FIRST = getColor( + // "selected_tab_first", new RGB(74, 74, 74)); //$NON-NLS-1$ + // public static final Color SELECTED_TAB_SECOND = getColor( + // "selected_tab_second", new RGB(128, 129, 130)); //$NON-NLS-1$ + // + // public static final Color TOOLTIP = getColor( + // "tooltip", new RGB(255, 255, 225)); //$NON-NLS-1$ + // + public static final Color BAR_GRAY1 = getColor( + "barGRAY1", new RGB(177, 177, 177)); //$NON-NLS-1$ + // public static final Color BAR_GRAY2 = getColor( + // "barGRAY2", new RGB(153, 153, 153)); //$NON-NLS-1$ + // public static final Color BAR_GRAY3 = getColor( + // "barGRAY3", new RGB(216, 216, 216)); //$NON-NLS-1$ + // + // /* Timeline */ + public static final Color ITEM_BLUE_BRIGHT = getColor("item blue right", + new RGB(131, 196, 218));//$NON-NLS-1$ + public static final Color ITEM_BLUE_DARK = getColor("item blue dark", + new RGB(38, 104, 138));//$NON-NLS-1$ + + // public static final Color ITEM_BG = getColor("item background", new + // RGB(50, + // 50, 50));//$NON-NLS-1$ + // public static final java.awt.Color ITEM_BG_AWT = new java.awt.Color(50, + // 50, + // 50);//$NON-NLS-1$ + // public static final java.awt.Color ITEM_BLUE_AWT = new java.awt.Color(38, + // 104, 138);//$NON-NLS-1$ + // public static final Color TIMELINE_BG = getColor( + // "timeline_bg", new RGB(50, 50, 50)); //$NON-NLS-1$ + // public static final Color TRANS = getColor( + // "timeline_bg", new RGB(50, 50, 50)); //$NON-NLS-1$ + // public static final Color SNAPSHOT_CHART_FOREGROUND = BAR_GRAY1; + // public static final Color SNAPSHOT_CHART_BACKGROUND = getColor( + // "snapshot_chart_bg", new RGB(50, 50, 50)); //$NON-NLS-1$ + // + // public static final Color GRAY_80 = getColor("GRAY_80", new RGB(80, 80, 80)); //$NON-NLS-1$ + // public static final Color GRAY_110 = getColor( + // "GRAY_110", new RGB(110, 110, 110)); //$NON-NLS-1$ + // public static final Color GRAY_130 = getColor( + // "GRAY_130", new RGB(130, 130, 130)); //$NON-NLS-1$ + // public static final Color GRAY_170 = getColor( + // "GRAY_170", new RGB(170, 170, 170)); //$NON-NLS-1$ + // public static final Color GRAY_210 = getColor( + // "GRAY_210", new RGB(210, 210, 210)); //$NON-NLS-1$ + // + // public static final java.awt.Color DEFAULT_CHART_FOREGROUND = + // java.awt.Color.LIGHT_GRAY; + // public static final java.awt.Color DEFAULt_CHART_BACKGROUND = new + // java.awt.Color( + // 66, 66, 68); + // public static final Color DEFAULT_FOREGROUND = getColor( + // "defaultForeground", new RGB(0, 0, 0)); //$NON-NLS-1$ + // public static final Color DEFAULT_BACKGROUND = getColor( + // "defaultBackground", new RGB(255, 255, 255)); //$NON-NLS-1$ + // public static final Color DEFAULT_RED = getColor( + // "defaultRed", new RGB(173, 13, 1)); //$NON-NLS-1$ + // + // // circular graph + // public static final Color CPU_CIRCULAR_GRAPH_COLOR = getColor( + // "cpu_circular_graph_color", new RGB(2, 171, 208)); //$NON-NLS-1$ + // public static final Color PROCESS_CIRCULAR_GRAPH_COLOR = getColor( + // "process_circular_graph_color", new RGB(114, 203, 8)); //$NON-NLS-1$ + // + // public static final Color PROFILING_GRAPH_COLOR_START = getColor( + // "profiling_graph_color_start", new RGB(145, 190, 3)); //$NON-NLS-1$ + // public static final Color PROFILING_GRAPH_COLOR_END = getColor( + // "profiling_graph_color_end", new RGB(114, 149, 1)); //$NON-NLS-1$ + // + // public static final Color PROFILING_GRAPH_SELECTION_COLOR_START = + // getColor( + // "profiling_graph_selection_color_start", new RGB(255, 135, 82)); //$NON-NLS-1$ + // public static final Color PROFILING_GRAPH_SELECTION_COLOR_END = getColor( + // "profiling_graph_selection_color_end", new RGB(232, 73, 73)); //$NON-NLS-1$ + + private static Color getColor(String colorName, RGB rgb) { + if (!colorRegistry.hasValueFor(colorName)) { + colorRegistry.put(colorName, rgb); + } + + return colorRegistry.get(colorName); + } + +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/Formatter.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/Formatter.java new file mode 100644 index 0000000..a83781a --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/Formatter.java @@ -0,0 +1,253 @@ +package org.tizen.dynamicanalyzer.widgets.helper; + +import java.text.DecimalFormat; + +public class Formatter { + + public static String toHexString(String decimal) { + if (null == decimal || decimal.isEmpty()) { + return null; + } + + try { + if (decimal.isEmpty()) { + return null; + } else { + long data = 0; + data = Long.parseLong(decimal); + return String.format("0x%08X", data); //$NON-NLS-1$ + } + } catch (NumberFormatException e) { + e.printStackTrace(); + return decimal; + } + } + + public static String toDoubleFormat1(String value) { + if (null == value || value.isEmpty()) { + return null; + } + + try { + double data = Double.parseDouble(value); + return String.format("%.1f", data); //$NON-NLS-1$ + } catch (NumberFormatException e) { + e.printStackTrace(); + return value; + } + } + + public static String toByteNumberFormat(String value) { + if (null == value || value.isEmpty()) { + return null; + } + + try { + long num = Long.parseLong(value); + String str = ""; //$NON-NLS-1$ + while (num > 0) { + long n = num % 1000; + if (str.isEmpty()) { + str += Long.toString(n); + } else { + String zero = ""; //$NON-NLS-1$ + if (str.length() == 1) { + zero += "00"; //$NON-NLS-1$ + } else if (str.length() == 2) { + zero += "0"; //$NON-NLS-1$ + } + str = zero + Long.toString(n) + "," + str; //$NON-NLS-1$ + } + num /= 1000; + } + if (str.isEmpty()) { + str += "0"; //$NON-NLS-1$ + } + return str; + } catch (Exception e) { + e.printStackTrace(); + return "0"; //$NON-NLS-1$ + } + } + + public static String toByteToMbNumberFormat2(String value) { + if (null == value || value.isEmpty()) { + return null; + } + try { + long num = Long.parseLong(value); + num /= 1024; // KB + double kb = num / 1024.; + + String str = Formatter.toDoubleFormat2(Double.toString(kb)); + return str; + } catch (Exception e) { + e.printStackTrace(); + return "0"; //$NON-NLS-1$ + } + } + + public static String toDoubleFormat2(String value) { + if (null == value || value.isEmpty()) { + return null; + } + + try { + double data = Double.parseDouble(value); + return String.format("%.2f", data); //$NON-NLS-1$ + } catch (NumberFormatException e) { + e.printStackTrace(); + return value; + } + } + + public static String toTimeFormat(String time) { + long longTime = Long.parseLong(time); + longTime /= 1000; + long ms = longTime % 1000; + longTime /= 1000; + long second = longTime % 60; + longTime /= 60; + long minute = longTime % 60; + String strMinute = Long.toString(minute); + if (strMinute.length() < 2) { + strMinute = "0" + strMinute; //$NON-NLS-1$ + } + + String strSecond = Long.toString(second); + if (strSecond.length() < 2) { + strSecond = "0" + strSecond; //$NON-NLS-1$ + } + + String strMs = Long.toString(ms); + if (strMs.length() == 2) { + strMs = "0" + strMs; //$NON-NLS-1$ + } else if (strMs.length() == 1) { + strMs = "00" + strMs; //$NON-NLS-1$ + } + + String output = strMinute + ":" + strSecond + ":" + strMs; //$NON-NLS-1$ //$NON-NLS-2$ + return output; + } + + public static String toTimeFormat2(String msTime) { + long longTime = Long.parseLong(msTime); + long ms = longTime % 1000; + longTime /= 1000; + long second = longTime % 60; + + String strSecond = Long.toString(second); + if (strSecond.length() < 2) { + strSecond = "0" + strSecond; //$NON-NLS-1$ + } + + String strMs = Long.toString(ms); + if (strMs.length() == 2) { + strMs = "0" + strMs; //$NON-NLS-1$ + } else if (strMs.length() == 1) { + strMs = "00" + strMs; //$NON-NLS-1$ + } + + String output = strSecond + ":" + strMs; //$NON-NLS-1$ + return output; + } + + public static String toPercentageFormat(Double input) { + String ret = String.format("%.2f", input); //$NON-NLS-1$ + ret += " %"; //$NON-NLS-1$ + return ret; + } + + public static String toNumberFormat(long input) { + int reminder = 0; + long quotient = input; + String output = ""; //$NON-NLS-1$ + + while (true) { + reminder = (int) (quotient % 1000); + quotient = quotient / 1000; + String value = Integer.toString(reminder); + if (quotient > 0) { + if (value.length() < 2) { + value = "00" + value; //$NON-NLS-1$ + } else if (value.length() < 3) { + value = "0" + value; //$NON-NLS-1$ + } + output = value + output; + output = "," + output; //$NON-NLS-1$ + } else { + output = value + output; + break; + } + } + return output; + } + + public static String toNumberFormat(double input) { + return toNumberFormat((long) input); + } + + public static String toByteFormat(long input) { + int reminder = 0; + long quotient = input; + int count = 0; + String value = ""; //$NON-NLS-1$ + + while (true) { + if (quotient >= 1024) { + reminder = (int) (quotient % 1024); + quotient = quotient / 1024; + count++; + continue; + } else { + value = Long.toString(quotient); + String remStr = Integer.toString(reminder); + if (count > 0) { + if (remStr.length() < 3) { + value += ".0"; //$NON-NLS-1$ + } else { + value += "." + remStr.substring(0, 1); //$NON-NLS-1$ + } + } + value += " " + getMeasure(count); //$NON-NLS-1$ + break; + } + } + return value; + } + + public static String toByteFormat(double input) { + return toByteFormat((long) input); + } + + public static String toBpsFormat(long nByte, long startTime, long endTime) { + String value = ""; //$NON-NLS-1$ + DecimalFormat df1 = new DecimalFormat("#,##0.00"); //$NON-NLS-1$ + double Bps = nByte; + + if (endTime - startTime >= 1000000) { + Bps = ((double) nByte * ((double) 1000000 / (double) (endTime - startTime))); + } + + value += df1.format(Bps) + " Bps"; //$NON-NLS-1$ + return value; + } + + public static String toBpsFormat(double nByte, long startTime, long endTime) { + return toBpsFormat((long) nByte, startTime, endTime); + } + + private static String getMeasure(int count) { + if (count == 4) { + return "TB"; //$NON-NLS-1$ + } else if (count == 3) { + return "GB"; //$NON-NLS-1$ + } else if (count == 2) { + return "MB"; //$NON-NLS-1$ + } else if (count == 1) { + return "KB"; //$NON-NLS-1$ + } else { + return "Byte"; //$NON-NLS-1$ + } + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java new file mode 100644 index 0000000..ffd37ae --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/org/tizen/dynamicanalyzer/widgets/helper/ImageResources.java @@ -0,0 +1,69 @@ +package org.tizen.dynamicanalyzer.widgets.helper; + +import java.io.File; +import java.net.MalformedURLException; +import java.net.URL; + +import org.eclipse.jface.resource.ImageDescriptor; +import org.eclipse.jface.resource.ImageRegistry; +import org.eclipse.swt.graphics.Image; + +public class ImageResources { + private static ImageRegistry imageRegistry = new ImageRegistry(); + + // Dialog button + public static final Image DIALOG_PUSH = getPngImage("dialog_button_push"); //$NON-NLS-1$ + + public static final Image ABOUT = getPngImage("toolbar_about_nor"); //$NON-NLS-1$ + public static final Image ABOUT_PUSH = getPngImage("toolbar_about_push"); //$NON-NLS-1$ + public static final Image ABOUT_HOVER = getPngImage("toolbar_about_hover"); //$NON-NLS-1$ + public static final Image ABOUT_DISABLE = getPngImage("toolbar_about_disable"); //$NON-NLS-1$ + + public static final Image VIEW_SOURCE = getPngImage("toolbar_source_view_nor"); //$NON-NLS-1$ + public static final Image VIEW_SOURCE_PUSH = getPngImage("toolbar_source_view_push"); //$NON-NLS-1$ + public static final Image VIEW_SOURCE_HOVER = getPngImage("toolbar_source_view_hover"); //$NON-NLS-1$ + public static final Image VIEW_SOURCE_TOGGLE = getPngImage("toolbar_source_view_tog"); //$NON-NLS-1$ + public static final Image VIEW_SOURCE_DISABLE = getPngImage("toolbar_source_view_disable"); //$NON-NLS-1$ + + /* snapshot */ + public static final Image SNAPSHOT_LEFT_NORMAL = getPngImage("snapshot_arrow_left_nor"); //$NON-NLS-1$ + public static final Image SNAPSHOT_LEFT_PUSH = getPngImage("snapshot_arrow_left_push"); //$NON-NLS-1$ + public static final Image SNAPSHOT_LEFT_HOVER = getPngImage("snapshot_arrow_left_hover"); //$NON-NLS-1$ + public static final Image SNAPSHOT_LEFT_DISABLE = getPngImage("snapshot_arrow_left_disable"); //$NON-NLS-1$ + public static final Image SNAPSHOT_RIGHT_NORMAL = getPngImage("snapshot_arrow_right_nor"); //$NON-NLS-1$ + public static final Image SNAPSHOT_RIGHT_PUSH = getPngImage("snapshot_arrow_right_push"); //$NON-NLS-1$ + public static final Image SNAPSHOT_RIGHT_HOVER = getPngImage("snapshot_arrow_right_hover"); //$NON-NLS-1$ + public static final Image SNAPSHOT_RIGHT_DISABLE = getPngImage("snapshot_arrow_right_disable"); //$NON-NLS-1$ + + public static final Image NO_IMAGE = getPngImage("noImage"); //$NON-NLS-1$ + + private static Image getImage(String folderName, String imageName, + String extension) { + if (null == imageRegistry.get(imageName) + || imageRegistry.get(imageName).isDisposed()) { + // ImageDescriptor desc = + // AbstractUIPlugin.imageDescriptorFromPlugin( + // pluginId, folderName + imageName + extension); + String strUrl = "file:" + folderName + imageName + extension; + URL url = null; + try { + url = new URL(strUrl); + } catch (MalformedURLException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + ImageDescriptor desc = ImageDescriptor.createFromURL(url); + imageRegistry.put(imageName, desc); + } + + return imageRegistry.get(imageName); + } + + private static Image getImage(String imageName, String extension) { + return getImage("testImages" + File.separator, imageName, extension); + } + + private static Image getPngImage(String imageName) { + return getImage(imageName, ".png"); + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/src/test/TestClass.java b/org.tizen.dynamicanalyzer.widgets/src/test/TestClass.java new file mode 100644 index 0000000..1207ed1 --- /dev/null +++ b/org.tizen.dynamicanalyzer.widgets/src/test/TestClass.java @@ -0,0 +1,118 @@ +package test; + +import org.eclipse.swt.SWT; +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.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Shell; +import org.tizen.dynamicanalyzer.widgets.button.TizenButton; +import org.tizen.dynamicanalyzer.widgets.button.TizenButtonClickEventListener; +import org.tizen.dynamicanalyzer.widgets.button.toggle.TizenToggleButton; +import org.tizen.dynamicanalyzer.widgets.combo.TizenCombo; +import org.tizen.dynamicanalyzer.widgets.combo.TizenComboSelectionListener; +import org.tizen.dynamicanalyzer.widgets.graph.circular.CircularGraph; +import org.tizen.dynamicanalyzer.widgets.helper.ColorResources; +import org.tizen.dynamicanalyzer.widgets.helper.ImageResources; + +public class TestClass { + public static void main(String[] args) { + Display display = new Display(); + Shell shell = new Shell(display); + + shell.setSize(new Point(1000, 1000)); + + shell.setLayout(new FormLayout()); + shell.open(); + TizenButton button = new TizenButton(shell, SWT.NONE); + button.setText("test"); + FormData data = new FormData(); + data.top = new FormAttachment(5, 0); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 50; + button.setLayoutData(data); + + button.addClickListener(new TizenButtonClickEventListener() { + + @Override + public void handleClickEvent(Event event) { + System.out.println("button test"); + } + }); + + TizenButton imgButton = new TizenButton(shell, ImageResources.ABOUT, + ImageResources.ABOUT_PUSH, ImageResources.ABOUT_HOVER, + ImageResources.ABOUT_DISABLE); + imgButton.setText("test2"); + data = new FormData(); + data.top = new FormAttachment(button, 10); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 50; + imgButton.setLayoutData(data); + + TizenToggleButton toggle = new TizenToggleButton(shell, SWT.NONE); + toggle.setText("toggle"); + data = new FormData(); + data.top = new FormAttachment(imgButton, 10); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 50; + toggle.setLayoutData(data); + + TizenToggleButton imgToggle = new TizenToggleButton(shell, + ImageResources.VIEW_SOURCE, ImageResources.VIEW_SOURCE_PUSH, + ImageResources.VIEW_SOURCE_HOVER, + ImageResources.VIEW_SOURCE_DISABLE, + ImageResources.VIEW_SOURCE_TOGGLE); + imgToggle.setText("toggle"); + data = new FormData(); + data.top = new FormAttachment(toggle, 10); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 50; + imgToggle.setLayoutData(data); + + TizenCombo combo = new TizenCombo(shell, SWT.NONE); + for (int i = 0; i < 29; i++) { + combo.add("test " + i); + } + data = new FormData(); + data.top = new FormAttachment(imgToggle, 10); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 50; + combo.setLayoutData(data); + + CircularGraph circle = new CircularGraph(shell, SWT.NONE, + CircularGraph.TYPE_PERCENT); + data = new FormData(); + data.top = new FormAttachment(combo, 10); + data.left = new FormAttachment(10, 0); + data.width = 200; + data.height = 100; + circle.setLayoutData(data); + circle.setMax(100); + circle.update(50); + circle.setTextColor(ColorResources.BLACK); + circle.setText("circlular graph test"); + + TizenComboSelectionListener comboSelectionListener = new TizenComboSelectionListener() { + @Override + public void selectionEvent(TizenCombo combo) { + System.out.println("combo selected :" + combo.getText()); + } + }; + + combo.addSelectionListener(comboSelectionListener); + + while (!shell.isDisposed()) { + if (!display.readAndDispatch()) + display.sleep(); + } + display.dispose(); + } +} diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/dialog_button_push.png b/org.tizen.dynamicanalyzer.widgets/testImages/dialog_button_push.png new file mode 100644 index 0000000000000000000000000000000000000000..7fadf9bfb9d9a9cadd4b617b954e5e54d5d26f8f GIT binary patch literal 2995 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 Qc`g7zRdrSB!8TF<2gPH%q5uE@ literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_disable.png b/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_disable.png new file mode 100644 index 0000000000000000000000000000000000000000..34bcf9f49738c3e3c460d9a09c54cf9f2a283465 GIT binary patch literal 3229 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 P00000NkvXXu0mjf#{vYr literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_hover.png b/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_hover.png new file mode 100644 index 0000000000000000000000000000000000000000..8244065ab39d451e2ce2ecb52bed8df267fc496d GIT binary patch literal 3195 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 literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_nor.png b/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_left_nor.png new file mode 100644 index 0000000000000000000000000000000000000000..5169198f7a2087f99573f793f7af88262c1e01e8 GIT binary patch literal 3234 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 bqV;b8!o{pF2o!|V00000NkvXXu0mjfWBCb< literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_hover.png b/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_hover.png new file mode 100644 index 0000000000000000000000000000000000000000..3b272e7e68c92ec1990a8df8af66f000543f660d GIT binary patch literal 3226 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 M07*qoM6N<$f&g>`QUCw| literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_nor.png b/org.tizen.dynamicanalyzer.widgets/testImages/snapshot_arrow_right_nor.png new file mode 100644 index 0000000000000000000000000000000000000000..8bf4605b55b09f550d7004a084e25e52b87c9436 GIT binary patch literal 3236 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 literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_hover.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_hover.png new file mode 100644 index 0000000000000000000000000000000000000000..126d1ea248528f6956381a17859ea25b6a26cb0a GIT binary patch literal 3874 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 literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_nor.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_nor.png new file mode 100644 index 0000000000000000000000000000000000000000..c8d138166d84b8b41a6364edf5fd12dd80872dca GIT binary patch literal 3666 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 literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_push.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_about_push.png new file mode 100644 index 0000000000000000000000000000000000000000..da8a1c3fafe80490ec69f1a2f2a033ac58f933a8 GIT binary patch literal 3905 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 P00000NkvXXu0mjf8N+3O literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_disable.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_disable.png new file mode 100644 index 0000000000000000000000000000000000000000..66f6d64f4b67a4178834d16929c7d2b00512fbd7 GIT binary patch literal 3183 zcmV-#43P7QP)KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z0004+NkllrqK&tma5NmWa4mEC9f9gi>n1-&d<1A>5Edq?C^1l)!M#gCJO~RsaG3 z5S5g&UVpCDY6V*6^A90J2@C*iHeZ|r=Ugcj1VN+m;(1=NeWjGvx&($&nph4)*=)WR z*hnpX2`2w+qbN!klgT98&~CR+5JO1*H2=OZn`oS+lr$4&JRT=?r_-^8$wrsP#IXr; zsz;+ywxQeYCY`2`a?>P}Lg+Bjt-bI>43?bw~3?bxt z4Cj0{n<=G=0mshs7}H{mA>vtegb>D9xwk+z;zD)TOSAZZvWS^Z->qWEW1i|i0{|XA VBt`TuZ_)q&002ovPDHLkV1l3;=hFZH literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_hover.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_hover.png new file mode 100644 index 0000000000000000000000000000000000000000..8fb45810d5866a65448bbd1cb1100de1539f40f0 GIT binary patch literal 3424 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 N002ovPDHLkV1g)#D3JgF literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_push.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_push.png new file mode 100644 index 0000000000000000000000000000000000000000..170c25e538d513e307f9d717ecabe3af8b4f6343 GIT binary patch literal 3411 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 literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_tog.png b/org.tizen.dynamicanalyzer.widgets/testImages/toolbar_source_view_tog.png new file mode 100644 index 0000000000000000000000000000000000000000..bc8e8957e90d1f33a00494136314257e895a23d9 GIT binary patch literal 3446 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 Y0N~M~Decs?NdN!<07*qoM6N<$f_9g2?f?J) literal 0 HcmV?d00001 diff --git a/org.tizen.dynamicanalyzer/.classpath b/org.tizen.dynamicanalyzer/.classpath index 475c79a..5914b67 100644 --- a/org.tizen.dynamicanalyzer/.classpath +++ b/org.tizen.dynamicanalyzer/.classpath @@ -14,6 +14,5 @@ - diff --git a/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF b/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF index 7d7422c..6c98b36 100644 --- a/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF +++ b/org.tizen.dynamicanalyzer/META-INF/MANIFEST.MF @@ -6,7 +6,8 @@ Bundle-SymbolicName: org.tizen.dynamicanalyzer;singleton:=true Bundle-Version: 1.0.0.qualifier Bundle-Vendor: %providerName Require-Bundle: org.eclipse.ui, - org.eclipse.core.runtime + org.eclipse.core.runtime, + org.tizen.dynamicanalyzer.widgets;bundle-version="1.0.0" Bundle-RequiredExecutionEnvironment: JavaSE-1.6 Bundle-Activator: org.tizen.dynamicanalyzer.AnalyzerPlugin Bundle-ActivationPolicy: lazy @@ -21,6 +22,5 @@ Bundle-ClassPath: ., lib/jcommon-1.0.17.jar, lib/jfreechart-1.0.14-experimental.jar, lib/jfreechart-1.0.14-swt.jar, - lib/jfreechart-1.0.14.jar, - lib/org.tizen.widget.jar + lib/jfreechart-1.0.14.jar Export-Package: org.tizen.dynamicanalyzer.ui.views diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/views/CoolbarArea.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/views/CoolbarArea.java index 5d985d1..3a20002 100755 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/views/CoolbarArea.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/views/CoolbarArea.java @@ -56,10 +56,10 @@ import org.tizen.dynamicanalyzer.ui.widgets.button.DAToggleButton; import org.tizen.dynamicanalyzer.ui.widgets.combo.TitleComboPopupRenderer; import org.tizen.dynamicanalyzer.ui.widgets.combo.TitleComboRenderer; import org.tizen.dynamicanalyzer.utils.AnalyzerUtil; -import org.tizen.widgets.button.TizenButton; -import org.tizen.widgets.button.TizenButtonClickEventListener; -import org.tizen.widgets.combo.TizenCombo; -import org.tizen.widgets.combo.TizenComboSelectionListener; +import org.tizen.dynamicanalyzer.widgets.button.TizenButton; +import org.tizen.dynamicanalyzer.widgets.button.TizenButtonClickEventListener; +import org.tizen.dynamicanalyzer.widgets.combo.TizenCombo; +import org.tizen.dynamicanalyzer.widgets.combo.TizenComboSelectionListener; public class CoolbarArea { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboPopupRenderer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboPopupRenderer.java index 598f9c9..7751316 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboPopupRenderer.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboPopupRenderer.java @@ -8,7 +8,7 @@ import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Canvas; import org.tizen.dynamicanalyzer.ColorResources; import org.tizen.dynamicanalyzer.FontResources; -import org.tizen.widgets.combo.TizenComboPopupRenderer; +import org.tizen.dynamicanalyzer.widgets.combo.TizenComboPopupRenderer; public class TitleComboPopupRenderer extends TizenComboPopupRenderer { diff --git a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboRenderer.java b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboRenderer.java index 20b8351..b38473b 100644 --- a/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboRenderer.java +++ b/org.tizen.dynamicanalyzer/src/org/tizen/dynamicanalyzer/ui/widgets/combo/TitleComboRenderer.java @@ -8,7 +8,7 @@ import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Canvas; import org.tizen.dynamicanalyzer.ColorResources; import org.tizen.dynamicanalyzer.FontResources; -import org.tizen.widgets.combo.TizenComboRenderer; +import org.tizen.dynamicanalyzer.widgets.combo.TizenComboRenderer; public class TitleComboRenderer extends TizenComboRenderer { -- 2.7.4